300 lines
12 KiB
C++
300 lines
12 KiB
C++
#include "CFFmpegH264Encoder.h"
|
||
#include "common/config.h"
|
||
#include "common/logger.h"
|
||
|
||
// 合规守护：DISABLE_FFMPEG_FOR_TEST=1 时整个实现 + 所有 #pragma comment(lib,"ffmpeg/...")
|
||
// 都不进编译单元，FFmpeg 静态库不会被链接进二进制
|
||
#if defined(_WIN64) && !DISABLE_FFMPEG_FOR_TEST
|
||
|
||
extern "C" {
|
||
#include <libavcodec/avcodec.h>
|
||
#include <libavutil/opt.h>
|
||
#include <libavutil/imgutils.h>
|
||
#include <libyuv/libyuv.h>
|
||
}
|
||
|
||
#include <string.h>
|
||
#include <cstdlib>
|
||
|
||
// FFmpeg 静态库 + 必要的 Windows 系统库。x86 build 不引入，由 _WIN64 守护。
|
||
// FFmpeg 三个核心库是纯 C，CRT 中性，Debug/Release 共用一份。
|
||
#pragma comment(lib,"ffmpeg/libavcodec_x64.lib")
|
||
#pragma comment(lib,"ffmpeg/libavutil_x64.lib")
|
||
#pragma comment(lib,"ffmpeg/libswresample_x64.lib")
|
||
// dav1d (AV1 软解，C 项目) —— 不分 Debug/Release。
|
||
// build 时启用了 --enable-libdav1d，libavcodec 内部 av1 decoder 引用了 dav1d 符号。
|
||
#pragma comment(lib,"ffmpeg/dav1d_x64.lib")
|
||
// libvpl (Intel QSV, C++ 项目) —— 强制 CRT 一致，必须按 _DEBUG 切。
|
||
// build 时启用了 --enable-libvpl，libavcodec 内部 h264_qsv / av1_qsv encoder 引用 MFX 符号。
|
||
#ifdef _DEBUG
|
||
#pragma comment(lib,"ffmpeg/vpl_x64d.lib")
|
||
#else
|
||
#pragma comment(lib,"ffmpeg/vpl_x64.lib")
|
||
#endif
|
||
|
||
#pragma comment(lib, "mfplat.lib")
|
||
#pragma comment(lib, "mfuuid.lib")
|
||
#pragma comment(lib, "strmiids.lib")
|
||
#pragma comment(lib, "secur32.lib")
|
||
#pragma comment(lib, "bcrypt.lib")
|
||
#pragma comment(lib, "advapi32.lib")
|
||
#pragma comment(lib, "ole32.lib")
|
||
// ws2_32 在 IOCPClient.h 已 link，重复不冲突
|
||
#pragma comment(lib, "ws2_32.lib")
|
||
|
||
// av_opt_set wrappers：FFmpeg 在选项名/值拼错时 silently 返回 AVERROR_OPTION_NOT_FOUND
|
||
// 不报错，导致 encoder 退回默认行为且没人察觉（实际踩过：AMF rc=vbr_peak_constrained
|
||
// 拼成全名，FFmpeg 实际只接受 vbr_peak，没设上去就退回 CBR）。
|
||
// 包一层 helper，任何设置失败 Mprintf 警告。
|
||
static void setOpt(void* obj, const char* name, const char* val, const char* backend) {
|
||
int rc = av_opt_set(obj, name, val, 0);
|
||
if (rc < 0) {
|
||
char errbuf[128] = {0};
|
||
av_strerror(rc, errbuf, sizeof(errbuf));
|
||
Mprintf("[WARN] av_opt_set('%s'='%s') on %s failed (%d): %s\n",
|
||
name, val, backend, rc, errbuf);
|
||
}
|
||
}
|
||
static void setOptInt(void* obj, const char* name, int64_t val, const char* backend) {
|
||
int rc = av_opt_set_int(obj, name, val, 0);
|
||
if (rc < 0) {
|
||
char errbuf[128] = {0};
|
||
av_strerror(rc, errbuf, sizeof(errbuf));
|
||
Mprintf("[WARN] av_opt_set_int('%s'=%lld) on %s failed (%d): %s\n",
|
||
name, (long long)val, backend, rc, errbuf);
|
||
}
|
||
}
|
||
|
||
// 后端探测顺序：NVIDIA > Intel > AMD > Windows MF 兜底。
|
||
// open() 主循环按顺序试，第一个 avcodec_open2 成功的就用。
|
||
// h264_mf 质量/稳定性一般，但是 Windows 系统级 hwaccel，任何 GPU 都能尝试，作最后兜底。
|
||
static const char* kH264Backends[] = {
|
||
"h264_nvenc", // NVIDIA NVENC
|
||
"h264_qsv", // Intel Quick Sync Video
|
||
"h264_amf", // AMD AMF
|
||
"h264_mf", // Windows Media Foundation
|
||
};
|
||
|
||
CFFmpegH264Encoder::CFFmpegH264Encoder() = default;
|
||
|
||
CFFmpegH264Encoder::~CFFmpegH264Encoder() {
|
||
close();
|
||
}
|
||
|
||
void CFFmpegH264Encoder::cleanupCodec() {
|
||
if (m_packet) { av_packet_free(&m_packet); m_packet = nullptr; }
|
||
if (m_frame) { av_frame_free(&m_frame); m_frame = nullptr; }
|
||
if (m_ctx) { avcodec_free_context(&m_ctx); m_ctx = nullptr; }
|
||
}
|
||
|
||
void CFFmpegH264Encoder::close() {
|
||
cleanupCodec();
|
||
m_backend.clear();
|
||
m_pts = 0;
|
||
m_forceIDR = false;
|
||
}
|
||
|
||
bool CFFmpegH264Encoder::open(const EncoderParams& params) {
|
||
close();
|
||
for (const char* name : kH264Backends) {
|
||
if (tryOpenBackend(name, params)) {
|
||
m_backend = name;
|
||
return true;
|
||
}
|
||
cleanupCodec(); // 释放本次失败的 ctx，准备下一次尝试
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool CFFmpegH264Encoder::tryOpenBackend(const char* name, const EncoderParams& p) {
|
||
const AVCodec* codec = avcodec_find_encoder_by_name(name);
|
||
if (!codec) {
|
||
// 失败 = lib 里没注册这个 encoder。几乎肯定是链到了老 ffmpeg lib。
|
||
Mprintf("=> FFmpeg: encoder '%s' NOT in linked lib (old ffmpeg?)\n", name);
|
||
return false;
|
||
}
|
||
|
||
m_ctx = avcodec_alloc_context3(codec);
|
||
if (!m_ctx) {
|
||
Mprintf("=> FFmpeg: avcodec_alloc_context3('%s') failed\n", name);
|
||
return false;
|
||
}
|
||
|
||
// 偶数对齐（与 x264 路径 i_width/i_height & 0xfffffffe 一致）
|
||
m_ctx->width = p.width & ~1;
|
||
m_ctx->height = p.height & ~1;
|
||
m_ctx->time_base = AVRational{1, p.fps};
|
||
m_ctx->framerate = AVRational{p.fps, 1};
|
||
m_ctx->pix_fmt = AV_PIX_FMT_NV12;
|
||
m_ctx->gop_size = p.fps * (p.gop_seconds > 0 ? p.gop_seconds : 4);
|
||
m_ctx->max_b_frames = 0;
|
||
m_ctx->bit_rate = (int64_t)p.bitrate_kbps * 1000;
|
||
m_ctx->rc_max_rate = (int64_t)p.bitrate_kbps * 1500;
|
||
m_ctx->rc_buffer_size = (int)(p.bitrate_kbps * 1000);
|
||
|
||
// RC 策略选择：远程办公 90% 时间是静态画面（文档/IDE/邮件），CBR 会强行
|
||
// 把目标码率填满（静态用不上的部分浪费带宽）。所有硬编后端统一改用 VBR，
|
||
// bit_rate 是平均目标、rc_max_rate (1.5x) 是峰值上限：静态时 encoder 自动
|
||
// 降码率省带宽，动态时回到目标 + 短暂上探到 1.5x 保证画质。
|
||
// 接近 x264 软编 CRF + VBV 的行为，但严格守住峰值不爆。
|
||
if (strcmp(name, "h264_nvenc") == 0) {
|
||
// NVENC preset: p1(最快/低质) ~ p7(最慢/高质)，远控低延迟 p5 兼顾。
|
||
// tune=ll low-latency；rc=vbr 配 max_rate 实现峰值受限的 VBR。
|
||
setOpt(m_ctx->priv_data, "preset", "p5", name);
|
||
setOpt(m_ctx->priv_data, "tune", "ll", name);
|
||
setOpt(m_ctx->priv_data, "rc", "vbr", name);
|
||
setOpt(m_ctx->priv_data, "zerolatency", "1", name);
|
||
} else if (strcmp(name, "h264_qsv") == 0) {
|
||
// Intel Quick Sync Video。preset: veryfast/faster/fast/medium/slow/slower/veryslow
|
||
// QSV 当 bit_rate != rc_max_rate 时自动走 VBR，所以这里只需调 preset。
|
||
// preset=slow 比 medium 慢但画质好，async_depth=1 单帧立即出包。
|
||
// low_power=0 走 PAK 路径，部分集显不支持 low_power 模式。
|
||
setOpt(m_ctx->priv_data, "preset", "slow", name);
|
||
setOptInt(m_ctx->priv_data, "async_depth", 1, name);
|
||
setOptInt(m_ctx->priv_data, "low_power", 0, name);
|
||
} else if (strcmp(name, "h264_amf") == 0) {
|
||
// AMD AMF 远控低延迟配置：
|
||
// usage=ultralowlatency 比 lowlatency 更激进，关闭一切 lookahead；
|
||
// quality=speed 选最快编码路径（vs balanced/quality）；
|
||
// rc=cbr 提供最可预测的输出节拍，避免 RC 切换抖动。
|
||
// 静态画面省码率交给应用层 skip 检测（ScreenCapture::GetNextScreenData
|
||
// 已经过 memcmp 把无变化帧直接拦在编码器之前），不再依赖 vbaq/preanalysis
|
||
// 这些会引入 30-100ms lookahead 的"省码率三件套"。
|
||
setOpt(m_ctx->priv_data, "usage", "ultralowlatency", name);
|
||
setOpt(m_ctx->priv_data, "quality", "speed", name);
|
||
setOpt(m_ctx->priv_data, "rc", "cbr", name);
|
||
setOptInt(m_ctx->priv_data, "filler_data", 0, name);
|
||
setOptInt(m_ctx->priv_data, "enforce_hrd", 0, name);
|
||
} else if (strcmp(name, "h264_mf") == 0) {
|
||
// Windows Media Foundation 兜底。rate_control 实际值（ffmpeg -h encoder=h264_mf）：
|
||
// default / cbr / pc_vbr / u_vbr / quality / ld_vbr / g_vbr / gld_vbr
|
||
// 远控用 pc_vbr (peak-constrained VBR) 与其他后端语义对齐。
|
||
setOptInt(m_ctx->priv_data, "hw_encoding", 1, name);
|
||
setOpt(m_ctx->priv_data, "rate_control", "pc_vbr", name);
|
||
}
|
||
|
||
int ret = avcodec_open2(m_ctx, codec, nullptr);
|
||
if (ret < 0) {
|
||
// 失败 = encoder 找到了但开不起来。常见：无 NVIDIA GPU / 驱动太旧 /
|
||
// NVENC session 占满 / 笔记本独显未唤醒 / 参数组合驱动不接受
|
||
char errbuf[128] = {0};
|
||
av_strerror(ret, errbuf, sizeof(errbuf));
|
||
Mprintf("=> FFmpeg: avcodec_open2('%s') failed (%d): %s\n", name, ret, errbuf);
|
||
return false;
|
||
}
|
||
|
||
m_frame = av_frame_alloc();
|
||
if (!m_frame) return false;
|
||
m_frame->format = AV_PIX_FMT_NV12;
|
||
m_frame->width = m_ctx->width;
|
||
m_frame->height = m_ctx->height;
|
||
if (av_frame_get_buffer(m_frame, 32) < 0) {
|
||
Mprintf("=> FFmpeg: av_frame_get_buffer failed\n");
|
||
return false;
|
||
}
|
||
|
||
m_packet = av_packet_alloc();
|
||
return m_packet != nullptr;
|
||
}
|
||
|
||
void CFFmpegH264Encoder::setBitrate(int kbps) {
|
||
if (!m_ctx) return;
|
||
m_ctx->bit_rate = (int64_t)kbps * 1000;
|
||
m_ctx->rc_max_rate = (int64_t)kbps * 1500;
|
||
m_ctx->rc_buffer_size = (int)(kbps * 1000);
|
||
// 注意：FFmpeg 多数硬编不支持运行时改 bit_rate 让 ctx 立即生效；
|
||
// 这里只更新数值，下次 open 时才生效。Step 1 不依赖动态调码率。
|
||
}
|
||
|
||
int CFFmpegH264Encoder::convertRGB24ToNV12(uint8_t* rgb, uint32_t stride,
|
||
uint32_t width, uint32_t height,
|
||
int direction)
|
||
{
|
||
int signed_height = direction * (int)height;
|
||
int w = (int)width;
|
||
int h = (int)height;
|
||
int y_size = w * h;
|
||
int uv_size = (w / 2) * (h / 2);
|
||
m_i420Scratch.resize(y_size + 2 * uv_size);
|
||
|
||
uint8_t* y = m_i420Scratch.data();
|
||
uint8_t* u = y + y_size;
|
||
uint8_t* v = u + uv_size;
|
||
|
||
if (libyuv::RGB24ToI420(
|
||
rgb, stride,
|
||
y, w,
|
||
u, w / 2,
|
||
v, w / 2,
|
||
w, signed_height) != 0) {
|
||
return -1;
|
||
}
|
||
if (libyuv::I420ToNV12(
|
||
y, w,
|
||
u, w / 2,
|
||
v, w / 2,
|
||
m_frame->data[0], m_frame->linesize[0],
|
||
m_frame->data[1], m_frame->linesize[1],
|
||
w, h) != 0) {
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int CFFmpegH264Encoder::encode(
|
||
uint8_t* rgb, uint8_t bpp, uint32_t stride,
|
||
uint32_t width, uint32_t height,
|
||
uint8_t** lppData, uint32_t* lpSize, int direction)
|
||
{
|
||
if (!m_ctx || !m_frame || !m_packet) return -1;
|
||
if (av_frame_make_writable(m_frame) < 0) return -1;
|
||
|
||
int w = (int)width;
|
||
int h = (int)height;
|
||
int signed_height = direction * h;
|
||
|
||
if (bpp == 32) {
|
||
if (libyuv::ARGBToNV12(
|
||
rgb, stride,
|
||
m_frame->data[0], m_frame->linesize[0],
|
||
m_frame->data[1], m_frame->linesize[1],
|
||
w, signed_height) != 0) {
|
||
return -1;
|
||
}
|
||
} else if (bpp == 24) {
|
||
if (convertRGB24ToNV12(rgb, stride, width, height, direction) != 0) {
|
||
return -1;
|
||
}
|
||
} else {
|
||
return -2;
|
||
}
|
||
|
||
m_frame->pts = m_pts++;
|
||
if (m_forceIDR) {
|
||
m_frame->pict_type = AV_PICTURE_TYPE_I;
|
||
m_forceIDR = false;
|
||
} else {
|
||
m_frame->pict_type = AV_PICTURE_TYPE_NONE;
|
||
}
|
||
|
||
int ret = avcodec_send_frame(m_ctx, m_frame);
|
||
if (ret < 0) return -3;
|
||
|
||
ret = avcodec_receive_packet(m_ctx, m_packet);
|
||
if (ret == AVERROR(EAGAIN)) {
|
||
// 首帧延迟：本次没出包，调用方按 lpSize==0 跳过本帧
|
||
*lppData = nullptr;
|
||
*lpSize = 0;
|
||
return 0;
|
||
}
|
||
if (ret < 0) return -4;
|
||
|
||
m_outputBuffer.assign(m_packet->data, m_packet->data + m_packet->size);
|
||
*lppData = m_outputBuffer.data();
|
||
*lpSize = (uint32_t)m_outputBuffer.size();
|
||
av_packet_unref(m_packet);
|
||
return 0;
|
||
}
|
||
|
||
#endif // _WIN64 && !DISABLE_FFMPEG_FOR_TEST
|