// JointRepresentation — the core structure of the joint latent space
type JointRepresentation struct {
    TextEmbeddings [][]float32  // [batch, seq_len, d_model]
    VoiceFeatures  [][]float32  // [batch, voice_channels, feature_dim]
    SFXFeatures    [][]float32  // [batch, sfx_channels, feature_dim]
    TimeControl    [][][]float32 // [batch, time_steps, 2] — start position + duration
    
    fusedRepresentation [][]float32
}

// CrossModalAttention — multi-head cross-modal attention
func CrossModalAttention(query, key, value [][]float32, numHeads int) [][]float32 {
    batchSize := len(query)
    seqLen := len(query[0])
    headDim := len(query[0][0]) / numHeads
    
    output := make([][]float32, batchSize)
    for b := 0; b < batchSize; b++ {
        headOutputs := make([][]float32, numHeads)
        for h := 0; h < numHeads; h++ {
            qHead := sliceHead(query[b], h, headDim)
            kHead := sliceHead(key[b], h, headDim)
            vHead := sliceHead(value[b], h, headDim)
            
            scores := matMul(qHead, transpose(kHead))
            scale := float32(math.Sqrt(float64(headDim)))
            for i := range scores {
                for j := range scores[i] {
                    scores[i][j] /= scale
                }
            }
            weights := softmax(scores)
            headOutputs[h] = matMul(weights, vHead)
        }
        output[b] = concatHeads(headOutputs)
    }
    return output
}

// JointFusion — gated fusion for dynamic modality weighting
func JointFusion(text, voice, sfx, timeCtrl [][]float32) [][]float32 {
    gateText := sigmoid(denseLayer(text, 256, 1))
    gateVoice := sigmoid(denseLayer(voice, 256, 1))
    gateSFX := sigmoid(denseLayer(sfx, 256, 1))
    gateTime := sigmoid(denseLayer(timeCtrl, 256, 1))
    
    totalGate := 0.0
    for i := range gateText {
        totalGate += gateText[i][0] + gateVoice[i][0] + gateSFX[i][0] + gateTime[i][0]
    }
    
    fused := make([][]float32, len(text))
    for i := range fused {
        fused[i] = make([]float32, len(text[i]))
        for j := range fused[i] {
            fused[i][j] = (gateText[i][0]*text[i][j] +
                gateVoice[i][0]*voice[i][j] +
                gateSFX[i][0]*sfx[i][j] +
                gateTime[i][0]*timeCtrl[i][j]) / totalGate
        }
    }
    return fused
}

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class AudioDiTDecoder(nn.Module):
    """
    Audio DiT Diffusion Inversion Decoder
    Inverts joint representations into multi-channel audio waveforms
    """
    def __init__(self, latent_dim=1024, audio_channels=4, 
                 num_layers=24, num_heads=16, hidden_dim=2048):
        super().__init__()
        self.latent_dim = latent_dim
        self.audio_channels = audio_channels  # vocals, SFX, ambient, spatial
        
        self.time_embed = nn.Sequential(
            nn.Linear(1, hidden_dim),
            nn.SiLU(),
            nn.Linear(hidden_dim, hidden_dim),
        )
        
        self.input_proj = nn.Linear(latent_dim, hidden_dim)
        
        self.blocks = nn.ModuleList([
            DiTBlock(hidden_dim, num_heads, dropout=0.1)
            for _ in range(num_layers)
        ])
        
        self.output_proj = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim * 2),
            nn.SiLU(),
            nn.Linear(hidden_dim * 2, audio_channels * 256),
        )
        
        self.noise_pred = nn.Linear(hidden_dim, latent_dim)
        
    def forward(self, latent, t, noise_level):
        B, S, D = latent.shape
        t_emb = self.time_embed(t).unsqueeze(1).expand(-1, S, -1)
        h = self.input_proj(latent) + t_emb
        
        for block in self.blocks:
            h = block(h, noise_level)
        
        noise_pred = self.noise_pred(h.mean(dim=1))
        audio_tokens = self.output_proj(h)
        audio_tokens = audio_tokens.view(B, -1, self.audio_channels, 256)
        audio = audio_tokens.permute(0, 2, 1, 3).reshape(B, self.audio_channels, -1)
        
        return audio, noise_pred


class DiTBlock(nn.Module):
    """DiT Transformer block with adaptive layer normalization"""
    def __init__(self, hidden_dim, num_heads, dropout=0.1):
        super().__init__()
        self.norm1 = AdaptiveLayerNorm(hidden_dim)
        self.attn = nn.MultiheadAttention(hidden_dim, num_heads, 
                                          dropout=dropout, batch_first=True)
        self.norm2 = AdaptiveLayerNorm(hidden_dim)
        self.ffn = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim * 4),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim * 4, hidden_dim),
            nn.Dropout(dropout),
        )
        
    def forward(self, x, condition):
        x = x + self.attn(*[self.norm1(x, condition)] * 3)[0]
        x = x + self.ffn(self.norm2(x, condition))
        return x

class VoiceConditionEncoder(nn.Module):
    """Zero-shot voice condition encoder"""
    def __init__(self, ref_sample_rate=16000, embedding_dim=768):
        super().__init__()
        self.mel_spec = torchaudio.transforms.MelSpectrogram(
            sample_rate=ref_sample_rate, n_fft=1024, n_mels=80,
        )
        self.conv_encoder = nn.Sequential(
            nn.Conv1d(80, 256, 3, padding=1), nn.BatchNorm1d(256), nn.ReLU(),
            nn.Conv1d(256, 512, 3, stride=2, padding=1), nn.BatchNorm1d(512), nn.ReLU(),
            nn.Conv1d(512, 512, 3, stride=2, padding=1), nn.BatchNorm1d(512), nn.ReLU(),
        )
        self.attention_pool = nn.Sequential(
            nn.Linear(512, 256), nn.Tanh(), nn.Linear(256, 1),
        )
        self.timbre_proj = nn.Linear(512, embedding_dim)
        self.style_adaptor = StyleAdaptor(embedding_dim)
        
    def forward(self, reference_audio, target_text_embeddings):
        mel = torch.log(self.mel_spec(reference_audio) + 1e-8)
        conv_out = self.conv_encoder(mel).transpose(1, 2)
        attn_weights = torch.softmax(self.attention_pool(conv_out), dim=1)
        global_timbre = self.timbre_proj(torch.sum(attn_weights * conv_out, dim=1))
        return self.style_adaptor(target_text_embeddings, global_timbre), global_timbre

from dataclasses import dataclass
from typing import List, Optional
import numpy as np

@dataclass
class AudioElement:
    element_type: str  # "dialogue", "sfx", "ambient", "music"
    content: str
    start_ms: int
    duration_ms: int
    style: str = "natural"
    voice_ref: Optional[str] = None

class SeedAudioPipeline:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self._model_loaded = False
        
    def generate_scene(self, elements: List[AudioElement]) -> np.ndarray:
        total_ms = max(e.start_ms + e.duration_ms for e in elements)
        total_samples = int(total_ms / 1000 * 24000)
        num_channels = 4
        audio = np.zeros((num_channels, total_samples), dtype=np.float32)
        
        for elem in elements:
            start = int(elem.start_ms / 1000 * 24000)
            dur = int(elem.duration_ms / 1000 * 24000)
            
            if elem.element_type == "dialogue":
                t = np.linspace(0, 2 * np.pi, dur)
                freq = 200 if elem.style == "高亢激昂" else 120
                voice = np.sin(freq * t) * np.exp(-np.linspace(0, 3, dur))
                audio[0, start:start+dur] = voice * 0.3
            elif elem.element_type == "sfx":
                audio[1, start:start+dur] = np.random.randn(dur) * 0.1
                
        return audio / np.max(np.abs(audio)) * 0.95