工业级音视频推流与录制引擎

当把NV12丢给OpenGL或Direct3D渲染时，GPU只需要创建2个纹理（Textures）。取色度时，GPU的采样器一次读取2个字节，瞬间就能拿到U和V还原色彩，极大地提高了Cache的命中率。

在processVideo函数中，系统回进行校验，当同时满足以下三个条件时，触发零拷贝：
1.传入的数据包含有有效的ID3D11Texture2D显存句柄。
2.编码器为硬件加速模式（如：h264_nvenc）。
3.渲染输出分辨率与目标分辨率完全一致。

//在纯GPU路径中，系统绕过了像素级别的字节操作，直接将D3D11 Texture 的显存地址（Pointer）绑定至AVFrame的数据域。
srcFrame->format = AV_PIX_FMT_D3D11;
srcFrame->data[0] = (uint8_t*)data.texture.Get(); // 显存指针直通
srcFrame->hw_frames_ctx = av_buffer_ref(m_vEncoder->getHWFramesRef());

标准的渲染纹理通常位于显卡高速区，禁止CPU直接访问。系统通过创建一个带有D3D11_USAGE_STAGING标志和D3D11_CPU_ACCESS_READ权限的中转纹理，将渲染结果拷贝至此，再通过Map与Unmap接口建立CPU寻址映射。

// 剥离填充字节，逐行安全拷贝 Y 分量
for (int i = 0; i < height; ++i) {
    memcpy(dstY + i * width, src + i * map.RowPitch, width);
}
// 剥离填充字节，逐行安全拷贝 UV 分量
for (int i = 0; i < height / 2; ++i) {
    memcpy(dstUV + i * width, src + ySize + i * map.RowPitch, width);
}

// FFmpegRecorder.cpp
bool FFmpegRecorder::initScaler(int inW, int inH, int inFmt, int outW, int outH, int outFmt) {
    // 如果上下文已存在且参数未变，直接复用
    m_swsCtx = sws_getCachedContext(m_swsCtx,
                                    inW, inH, (AVPixelFormat)inFmt,
                                    outW, outH, (AVPixelFormat)outFmt,
                                    SWS_BICUBIC, nullptr, nullptr, nullptr);

    if (!m_swsCtx) return false;

    // 准备缩放后的 AVFrame 容器，仅在尺寸变化时重新分配 buffer
    if (!m_scaledFrame) {
        m_scaledFrame = av_frame_alloc();
    }
    // ... 检查并执行 av_frame_get_buffer
}

// 配置定义见 RecorderConfig.h
enum class DownscaleFilter {
    Bilinear,   // 线性插值 (快)
    Bicubic,    // 三次卷积 (清晰)
    Lanczos     // 兰索斯 (锐利, 推荐)
};

// FFmpegRecorder.cpp
if (needScale) {
    // 1. 确保缩放器已初始化为 NV12 -> NV12
    if (initScaler(data.width, data.height, AV_PIX_FMT_NV12, targetW, targetH, AV_PIX_FMT_NV12)) {
        // 2. 执行真正的图像重采样
        sws_scale(m_swsCtx, srcFrame->data, srcFrame->linesize, 0, data.height,
                  m_scaledFrame->data, m_scaledFrame->linesize);

        // 3. 将工作指针指向缩放后的内存块
        frameToEncode = m_scaledFrame;
    }
}

// 1. 如果没有翻译官 (swr)，或者输入的频率变了，就重新入职和建水池
if (!ctx.swr || ctx.lastInputRate != inRate || ctx.lastInputChannels != inChannels) {
    if (ctx.swr) swr_free(&ctx.swr); // 辞退老翻译官
    
    // 2. 设置输入输出频道标准
    AVChannelLayout outLayout; av_channel_layout_default(&outLayout, m_outChannels);
    AVChannelLayout inLayout; av_channel_layout_default(&inLayout, inChannels);
    
    // 3. 拟定翻译合同 (swr_alloc_set_opts2)，告诉他输入是什么样，我们要的输出是什么样
    swr_alloc_set_opts2(&ctx.swr, &outLayout, AV_SAMPLE_FMT_FLT, m_outRate, &inLayout, AV_SAMPLE_FMT_FLT, inRate, 0, nullptr);
    
    // 4. 翻译官正式上岗 (swr_init)
    if (swr_init(ctx.swr) < 0) return;
    
    // 5. 修建蓄水池 AVAudioFifo，用来装翻译后的标准水滴，容量给个 4096
    if (ctx.fifo) av_audio_fifo_free(ctx.fifo);
    ctx.fifo = av_audio_fifo_alloc(AV_SAMPLE_FMT_FLT, m_outChannels, 4096);
    
    // 6. 准备一个临时脸盆 (resampleBuffer)，翻译官刚翻译完的水先放脸盆，再倒进水池
    av_samples_alloc_array_and_samples(&ctx.resampleBuffer, nullptr, m_outChannels, 4096, AV_SAMPLE_FMT_FLT, 0);
}

// 1. 计算这次来了多少原始数据
int inSamples = data.size() / (inChannels * sizeof(float));
const uint8_t* inputData[] = { (const uint8_t*)data.constData() };

// 2. 估算翻译后会有多少数据 (因为频率变了，数量也会变)
int outSamplesMax = av_rescale_rnd(swr_get_delay(ctx.swr, inRate) + inSamples, m_outRate, inRate, AV_ROUND_UP);

// 3. 开始干活！swr_convert 把 inputData 翻译成金色水滴，放进脸盆 ctx.resampleBuffer
int convertedSamples = swr_convert(ctx.swr, ctx.resampleBuffer, outSamplesMax, inputData, inSamples);

// 4. 把脸盆里的水，稳稳地倒进蓄水池 AVAudioFifo 里存起来
if (convertedSamples > 0) av_audio_fifo_write(ctx.fifo, (void**)ctx.resampleBuffer, convertedSamples);

// 1. 编码器拿着名为 outL 和 outR 的空盆来了，先洗干净 (置0)
memset(outL, 0, nbSamples * sizeof(float));
memset(outR, 0, nbSamples * sizeof(float));

// 2. 遍历所有的水池（麦克风池、系统池）
for(auto key : sources.keys()) {
    auto& s = sources[key];
    // 3. 检查水池里的水够不够一瓢 (av_audio_fifo_size)
    if (av_audio_fifo_size(s.fifo) >= nbSamples) {
        
        // 4. 从水池舀出一瓢水，放进 tmpBuf
        void* bufPtr = tmpBuf;
        av_audio_fifo_read(s.fifo, &bufPtr, nbSamples);
        
        // 5. 核心：小学加法混音！把舀出来的水，乘以音量，加到主盆 outL/outR 里
        for(int i=0; i<nbSamples; ++i) {
            outL[i] += tmpBuf[i*2] * s.volume;   // 左声道相加
            outR[i] += tmpBuf[i*2+1] * s.volume; // 右声道相加
        }
    }
}

// 6. 智能海绵上场：使用 tanh 挤压主盆里的水，防止加起来的数字超过 1.0 (爆音)
for(int i=0; i<nbSamples; ++i) {
    outL[i] = std::tanh(outL[i]);
    outR[i] = std::tanh(outR[i]);
}
return nbSamples; // 返回满满一瓢完美混合的水！

// 1. 看看编码器的“瓢”有多大 (frameSize)
int frameSize = m_aEncoder->getContext()->frame_size;

while (true) {
    // 2. 调用上面的步骤，去拿一瓢混合好的水  
    int samplesRead = m_audioDSP->popMixedData(m_mixL, m_mixR, frameSize);
    if (samplesRead < frameSize) break; // 如果水不够了，就跳出循环，等下次再来
    
    // 3. 准备好箱子 (m_aFrame)
    if (av_frame_make_writable(m_aFrame) < 0) return;
    
    // 4. 把混好的水，小心翼翼地倒进箱子的左半区和右半区
    float* dstL = (float*)m_aFrame->data[0];
    float* dstR = (float*)m_aFrame->data[1];
    memcpy(dstL, m_mixL, frameSize * sizeof(float));
    memcpy(dstR, m_mixR, frameSize * sizeof(float));
    
    // 5. 贴上时间戳标签 (pts)，表示这是什么时候的包裹
    m_aFrame->pts = m_totalAudioSamples + ptsOffset;
    m_totalAudioSamples += frameSize;
    
    // 6. 送上流水线去编码！
    AVPacket* pkt = m_aEncoder->encode(m_aFrame);
}

**文件**: `FFmpegModules.h`
**类与函数**: `VideoEncoder::tryInitEncoder`
// [企业级优化 1] 强制关闭 B 帧，这是 RTMP 低延迟的核心
// 任何 B 帧都会导致播放器必须等待后续 P 帧到达才能解码，直接引入延迟
ctx->max_b_frames = 0; // 宁可牺牲一点压缩率，也要求编码器做到“出一帧发一帧”

**文件**: `FFmpegModules.h`
**类与函数**: `VideoEncoder::tryInitEncoder`
// [企业级优化 3] 缩减码率控制缓冲区 (VBV Buffer)
// 默认 buffer 往往是 1-2秒，导致网络波动时数据在编码器内部积压。
// 设为 0.5 秒或更小，迫使编码器在带宽受限时快速降低画质而不是堆积数据。
ctx->rc_buffer_size = bitrate / 2; // 强行把编码器的“大肚皮”勒紧，积压上限减半

x264(软编)：设置av_opt_set()，这回彻底关闭Lookahead（向前缓冲）。

NVENC（NVIDIA显卡）：设置tune为ull，并强制delay为0，这是英伟达转为游戏直播设计的超低延迟模式。

AMF（AMD显卡）：设置usage为ultralowlatency。

QSV（Intel显卡）：强制async_depth为1，斩断异步深度的缓冲。

**文件**: `FFmpegModules.h`
**类与函数**: `VideoEncoder::tryInitEncoder`
// ----------------------------------------------------------------------
// [企业级优化 4] 针对不同编码器的低延迟参数深度调优
// ----------------------------------------------------------------------

// >>> 1. x264 软编优化
if (name == "libx264") {
    // "zerolatency" 是核心，它会禁用 B 帧，去除 Lookahead，通过牺牲压缩率换取最低延迟
    av_opt_set(ctx->priv_data, "tune", "zerolatency", 0);
...
// >>> 2. NVENC 硬编优化 (NVIDIA)
else if (name.contains("nvenc")) {
...
    // 调优: ull (Ultra Low Latency) 是 NVENC 专门为直播设计的低延迟模式
    av_opt_set(ctx->priv_data, "tune", "ull", 0);

    // 强制 0 延迟缓冲，彻底干掉并行帧处理的延迟
    av_opt_set(ctx->priv_data, "delay", "0", 0);
...
// >>> 3. AMF 硬编优化 (AMD)
else if (name.contains("amf")) {
    // 开启 AMD 的超低延迟模式
    av_opt_set(ctx->priv_data, "usage", "ultralowlatency", 0);
}
// >>> 4. QSV 硬编优化 (Intel)
else if (name.contains("qsv")) {
    // 异步深度设为1，斩断 Intel 硬件编码器的异步缓冲队列
    av_opt_set(ctx->priv_data, "async_depth", "1", 0);
}

在StreamMuxer::applyNetWorkOptions中开启flush_packets=1强制立即发包。开启tcp_nodelay=1禁用系统的Nagle算法（不拼凑小包）。将FFmpeg内部的积压队列fifo_size从默认1万砍到50，一旦网络拥堵立即让上层感知。

**文件**: `FFmpegModules.h`
**类与函数**: `StreamMuxer::applyNetworkOptions`
void applyNetworkOptions(AVDictionary** opts) {
    // ...
    // [优化] 开启 TCP_NODELAY，禁用 Nagle 算法，对低延迟至关重要
    // 让系统有包就发，绝对不为了节省头部开销去“拼凑大包”
    av_dict_set(opts, "tcp_nodelay", "1", 0);
    // ...
    // [关键优化] 减小 FFmpeg 内部的包缓冲。
    // 原来的 10000 包太大了，会导致网络抖动时 FFmpeg 内部积压数秒数据而不报错
    // 改为 100-200，一旦网络堵塞立即让上层(AdaptiveStreamController)感知并降码率
    av_dict_set(opts, "fifo_size", "50", 0);

    // [关键优化] 强制立即发送，不进行微缓冲
    // 数据一旦 mux 完成，绝不在 FFmpeg 的 IO 层做任何停留
    av_dict_set(opts, "flush_packets", "1", 0);
    // ...
}

**【对应源码 `FFmpegRecorder.cpp -> processVideo`】**
// 算出精准的物理时间
double audioSec = (double)m_totalAudioSamples / m_config.audio.sampleRate;
double videoSec = (double)m_videoPtsCounter / m_config.base.fps;
double frameDur = 1.0 / m_config.base.fps; // 1帧的标准时长 (如 0.033s)

// 计算差距 (Diff)
double diff = audioSec - videoSec;

**【对应源码 `FFmpegRecorder.cpp -> processVideo`】**
if (diff < -frameDur) {
    dropFrame = true;     // 宣判死刑
    m_droppedFrames++;    // 记录罪证
}

// ... 
if (dropFrame) {
    av_frame_free(&srcFrame); // 物理销毁内存，直接扫进垃圾桶
    return; // 立刻返回，绝不阻塞线程！
}

**【对应源码 `FFmpegRecorder.cpp -> processVideo`】**
if (diff > frameDur) {
    // 算出缺了几个坑位
    duplicateCount = (int)(diff / frameDur);
    if (duplicateCount > 5) duplicateCount = 5; // 限制最多补5帧
    m_duplicatedFrames += duplicateCount;
}

// 处理补帧 (疯狂印章)
for (int i = 0; i < duplicateCount; ++i) {
    frameToEncode->pts = m_videoPtsCounter;
    encodeAndWriteVideo(frameToEncode); // 连续多次塞给编码器
    m_videoPtsCounter++; // 时间轴向前推进
}

**【对应源码 `FFmpegRecorder.cpp -> run` 主循环】**
// 获取 AI 流控策略
StreamConfig strategy = m_adaptiveCtrl->getCurrentConfig();
bool shouldDrop = false;

// 发现网络/编码质量差，源头强行降帧
if (strategy.quality == NetworkQuality::Poor) {
    if (m_frameIdx % 3 == 0) shouldDrop = true; // 30fps 强降 20fps
}

if (shouldDrop) {
    // 拦截：根本不进 processVideo 的同步算法！直接丢弃保命！
} else {
    processVideo(vFrame); // 机器健康，才放行处理
}

**【对应源码 `FFmpegRecorder.cpp -> processAudio`】**
// 没有丢弃，没有克隆，单纯的累加就是真理
int64_t ptsOffset = av_rescale_q(m_config.audio.globalSyncOffsetMs, {1, 1000}, m_aEncoder->getContext()->time_base);
m_aFrame->pts = m_totalAudioSamples + ptsOffset;
m_totalAudioSamples += frameSize; // 老老实实铺砖

void FFmpegRecorder::initNetwork() {
    avformat_network_init();
}

// 在 startRecord 中初始化 D3D 设备
if (!m_d3dDevice) {
    setD3DDevice(DX11Context::instance().device());
}

// 在 FFmpegRecorder::run() 中针对直播强制覆盖低延迟参数
if (m_config.streaming.enable) {
    m_config.streaming.tune = "zerolatency";
    m_config.streaming.preset = "superfast";
    m_config.streaming.max_b_frames = 0; // 核心：禁用 B 帧
}

// 在 FFmpegModules.h 中执行底层初始化
ctx = avcodec_alloc_context3(codec);
ctx->max_b_frames = 0; // 对应直播
ctx->rc_buffer_size = bitrate / 2; // 控制 VBV 缓冲区
// ...
av_opt_set(ctx->priv_data, "tune", "zerolatency", 0); 
int ret = avcodec_open2(ctx, codec, nullptr);

// StreamMuxer 网络推流初始化
av_dict_set(&opts, "tcp_nodelay", "1", 0);       // 禁用 Nagle 算法
av_dict_set(&opts, "flush_packets", "1", 0);     // 无缓冲立即发送
av_dict_set(&opts, "rw_timeout", "3000000", 0);  // 3秒超时

ret = avformat_alloc_output_context2(&fmtCtx, nullptr, "flv", m_path.toStdString().c_str());
ret = avio_open2(&fmtCtx->pb, m_path.toStdString().c_str(), AVIO_FLAG_WRITE, nullptr, &opts);
avformat_write_header(fmtCtx, nullptr);

// 视频缩放与格式转换
m_swsCtx = sws_getCachedContext(..., SWS_BICUBIC, ...);
sws_scale(m_swsCtx, srcFrame->data, srcFrame->linesize, 0, data.height, m_scaledFrame->data, m_scaledFrame->linesize);

// 音频重采样
int convertedSamples = swr_convert(ctx.swr, ctx.resampleBuffer, outSamplesMax, inputData, inSamples);
av_audio_fifo_write(ctx.fifo, (void**)ctx.resampleBuffer, convertedSamples);

AVPacket* VideoEncoder::sendAndReceive(AVFrame* frame) {
    int ret = avcodec_send_frame(ctx, frame); // 送入裸帧
    if (ret < 0 && ret != AVERROR_EOF) return nullptr;
    
    ret = avcodec_receive_packet(ctx, pkt);   // 取出压缩包
    if (ret == 0) return av_packet_clone(pkt);
    return nullptr;
}

int BaseMuxer::writePacket(AVPacket* pkt, const AVRational& sourceTimeBase, bool isVideo) {
    // 转换时间基
    av_packet_rescale_ts(localPkt, sourceTimeBase, outStream->time_base);
    // 交织写入
    int ret = av_interleaved_write_frame(fmtCtx, localPkt);
    return ret;
}

//AdaptiveStreamController::reportSentStats()
// --- 核心算法：判断拥塞 ---
// 判据1: socket 发送阻塞超过 100ms (说明带宽满了)
// 判据2: 平均延迟持续升高
bool isCongested = (durationMs > 200) || (m_avgLatency > 150);

//FFmpegRecorder::checkNetworkHealth
int queueSize = m_sender->getQueueSize();
// [调优] 放宽丢帧阈值，高分辨率下包可能会更多
const int THRESHOLD_DROP = 30;       // 原 30 -> 100 (给予更多缓冲时间)
const int THRESHOLD_CONGESTION = 20;  // 原 10 -> 20
// ...
else if (queueSize > THRESHOLD_CONGESTION) {
    // ... 处理轻微拥塞
}

//AdaptiveStreamController::adjustBitrate
if (isCongested) {
    // [乘法减小] Multiplicative Decrease
    m_consecutiveCongestionCount++;
    m_consecutiveGoodCount = 0;
    // 拥塞越严重，降得越快
    float dropFactor = (m_consecutiveCongestionCount > 2) ? 0.5f : 0.7f;
    m_currentBitrate = static_cast<int>(m_currentBitrate * dropFactor);
    qWarning() << "[Adaptive] Network Congestion! Dropping Bitrate to:" << m_currentBitrate / 1000 << "kbps";
    m_lastAdjustmentTime = now;
}

//AdaptiveStreamController::adjustBitrate
else {
    // [加法增大] Additive Increase
    m_consecutiveCongestionCount = 0;
    m_consecutiveGoodCount++;
    // 网络稳定 3秒后才开始试探性增加
    if (m_consecutiveGoodCount > 3) {
        m_currentBitrate += 50000; // 每次加 50kbps
        m_lastAdjustmentTime = now;
    }
}