窄带语音(8kHz) → 预处理/归一化 → 时域编码器(TCN) → 频域扩散解码器 → 后处理/增益补偿 → 全频带语音(16/32/48kHz)
                              ↓
                        知识蒸馏教师模型(离线训练)

L_total = λ1·L_spec + λ2·L_adv + λ3·L_plc_consistency

stateDiagram-v2
    [*] --> NB_8k : 入会协商
    NB_8k --> WB_16k : 带宽>80kbps & RTT<150ms
    WB_16k --> SWB_32k : 带宽>150kbps & 丢包<2%
    SWB_32k --> FB_48k : 带宽>300kbps & 丢包<1%
    WB_16k --> NB_8k : 丢包>10% 或带宽<50kbps
    SWB_32k --> WB_16k : 丢包>5% 或带宽<100kbps

+------------------+       RTP/SAVP       +------------------+
|  终端 SDK (ARM)  | <----------------->  |  媒体服务器 (x86) |
|  - ABE 推理引擎  |   窄带上行/全频带下行 |  - 转码/录制/混音 |
|  - 码率自适应    |                       |  - 旁路 ASR/翻译  |
+------------------+                       +------------------+
        |                                         |
        | gRPC 模型下发/配置下发                   | Prometheus 指标采集
        v                                         v
+------------------+                       +------------------+
|  模型管理平台     |                       |  可观测性平台     |
|  - 版本灰度发布   |                       |  - MOS 预测告警  |
|  - A/B 测试框架   |                       |  - 端到端时延拓扑|
+------------------+                       +------------------+

# 伪代码：三阶段课程学习调度器
class ABECurriculumScheduler:
    def __init__(self, total_steps=1_000_000):
        self.phases = [
            # Phase 1: 纯净宽带重建 (0-30%)
            {"name": "clean_recon", "steps": 300_000, 
             "data_mix": {"clean": 1.0}, 
             "loss_weights": {"spec": 1.0, "adv": 0.0, "plc": 0.0}},
            # Phase 2: 静态噪声/轻度丢包 (30-70%)
            {"name": "noise_plc_mild", "steps": 400_000,
             "data_mix": {"clean": 0.3, "noise": 0.5, "plc_5%": 0.2},
             "loss_weights": {"spec": 1.0, "adv": 0.5, "plc": 0.3}},
            # Phase 3: 实网长尾分布/重度丢包/多语言 (70-100%)
            {"name": "realworld_hard", "steps": 300_000,
             "data_mix": {"real_net": 0.6, "plc_20%": 0.2, "multilingual": 0.2},
             "loss_weights": {"spec": 0.8, "adv": 1.0, "plc": 0.8, "semantic": 0.2}}
        ]

// 核心抽象接口：屏蔽后端差异
class IABEEngine {
public:
    virtual ~IABEEngine() = default;
    // 初始化：模型加载、算子编译、内存池预热
    virtual bool Init(const ModelConfig& cfg, const HardwareContext& hw_ctx) = 0;
    // 流式推理：输入窄带帧(160 samples)，输出全频带帧(320/640/960 samples)
    virtual bool Process(const int16_t* nb_frame, int16_t* wb_frame, 
                         StreamState& state, PerfStats& stats) = 0;
    // 码率切换：零延迟切换内部状态
    virtual void SwitchBandwidth(TargetBandwidth bw) = 0;
    // 获取模型指纹，用于版本校验
    virtual std::string GetModelFingerprint() const = 0;
};

// 后端实现工厂：编译期/运行时双分发
std::unique_ptr<IABEEngine> CreateABEEngine(BackendType type) {
    switch(type) {
        case BackendType::NCNN_VULKAN: return std::make_unique<NCNNABEEngine>(); // Android/鸿蒙
        case BackendType::COREML:      return std::make_unique<CoreMLABEEngine>(); // iOS/macOS
        case BackendType::ONNX_DML:    return std::make_unique<DMLABEEngine>();    // Windows
        case BackendType::TFLITE_GPU:  return std::make_unique<TFLiteABEEngine>(); // Android低端
        case BackendType::OPENVINO:    return std::make_unique<OpenVINOABEEngine>(); // x86服务端/PC
        default: return std::make_unique<ReferenceABEEngine>(); // 兜底纯C++实现
    }
}

// Windows WASAPI 共享模式事件驱动回调（关键路径）
HRESULT CALLBACK AudioClientEventCallback::OnBufferFull(
    UINT32 num_frames_available, 
    const BYTE* input_buffer, 
    BYTE* output_buffer) 
{
    // 1. 指针转型，零拷贝
    const int16_t* nb_in = reinterpret_cast<const int16_t*>(input_buffer);
    int16_t* wb_out = reinterpret_cast<int16_t*>(output_buffer);

    // 2. 状态机检查（原子操作，无锁）
    StreamState local_state = state_.load(std::memory_order_acquire);
    
    // 3. 实时推理（必须在 3ms 内返回，否则触发 xrun 保护）
    PerfStats stats;
    auto start = std::chrono::high_resolution_clock::now();
    bool ok = abe_engine_->Process(nb_in, wb_out, local_state, stats);
    auto elapsed_us = std::chrono::duration_cast<std::chrono::microseconds>(
        std::chrono::high_resolution_clock::now() - start).count();
    
    // 4. 性能埋点（无锁环形缓冲区）
    perf_ring_buffer_.Push({elapsed_us, stats.cpu_cycles, local_state.current_bw});
    
    // 5. 静音/丢包保护：推理失败时输出舒适噪声而非静音
    if (!ok) GenerateComfortNoise(wb_out, num_frames_available * bw_ratio_);
    
    return S_OK;
}

# PyTorch 伪代码：Consistency Distillation for 2-step Inference
def consistency_loss(student, teacher, x_nb, x_wb, t_schedule=[0.0, 0.5, 1.0]):
    """
    x_nb: 窄带条件 [B, 1, T]
    x_wb: 全频带目标 [B, 1, 2T/4T]
    """
    # 教师模型：多步 ODE 轨迹 (冻结)
    with torch.no_grad():
        z_T = torch.randn_like(x_wb)
        # 老师走完整轨迹 t=1.0 -> 0.0
        z_0_teacher = teacher.ode_solve(z_T, x_nb, steps=10) 
    
    # 学生模型：单步/双步映射
    # 采样随机时间步 t_i, t_{i+1}
    t_i, t_next = sample_t_pairs(t_schedule, batch_size=x_nb.shape[0])
    
    # 学生从 t_i 预测 t_next 的解
    z_ti = add_noise(z_0_teacher, t_i)  # 前向加噪
    z_tnext_pred = student.one_step_denoise(z_ti, x_nb, t_i, t_next)
    
    # 目标：老师在 t_next 的真实解
    with torch.no_grad():
        z_tnext_target = add_noise(z_0_teacher, t_next)
    
    # 一致性损失：预测轨迹与真实轨迹对齐
    loss = F.huber_loss(z_tnext_pred, z_tnext_target, delta=0.01)
    
    # 辅助：最终输出重建损失
    z_0_pred = student.one_step_denoise(z_tnext_pred, x_nb, t_next, 0.0)
    loss += 0.5 * F.l1_loss(z_0_pred, x_wb)
    
    return loss

// C++17 无锁状态机实现
class BandwidthSwitcher {
    std::atomic<TargetBandwidth> target_bw_{TargetBandwidth::WB_16K};
    std::atomic<TargetBandwidth> current_bw_{TargetBandwidth::WB_16K};
    CrossFadeBuffer xfade_buf_; // 10ms 交叉淡变缓冲

public:
    // 网络模块调用：请求切换
    void RequestSwitch(TargetBandwidth new_bw) {
        target_bw_.store(new_bw, std::memory_order_release);
    }

    // 推理线程调用：每帧检查并执行
    void MaybeSwitch(ABEEngine& engine, StreamState& state) {
        TargetBandwidth tgt = target_bw_.load(std::memory_order_acquire);
        TargetBandwidth cur = current_bw_.load(std::memory_order_relaxed);
        
        if (tgt == cur) return;

        // 1. 启动交叉淡变：保存当前模型头输出的尾帧
        xfade_buf_.StartFadeOut(engine.GetHead(cur), state);
        
        // 2. 切换模型内部头（共享骨干，零开销）
        engine.ActivateHead(tgt);
        current_bw_.store(tgt, std::memory_order_release);
        state.current_bw = tgt;
        
        // 3. 新模型头前几帧淡入
        xfade_buf_.StartFadeIn(engine.GetHead(tgt), state);
    }

    // 后处理阶段应用交叉淡变
    void ApplyCrossFade(int16_t* frame, size_t frames) {
        xfade_buf_.Process(frame, frames);
    }
};