SDL2视频叠加动态文字：从解码渲染到性能优化的完整实现

SDL2视频渲染动态文字叠加

于 2026-07-31 07:04:43 修改

·本内容遵循CC 4.0 BY-SA版权协议

1. 项目概述：在视频画布上叠加动态文字

最近在做一个需要将实时数据可视化叠加到视频流上的小工具，核心需求很明确：用 SDL2 渲染视频帧，同时在上面动态地显示一些文字信息，比如时间戳、传感器读数或者简单的弹幕效果。这听起来像是视频播放器和简单图形界面的结合，但实际动手时，你会发现从视频解码、纹理渲染到文字字体的加载与混合，每一步都有不少细节需要注意。SDL2 作为一个跨平台的多媒体底层库，它不直接提供高级的视频播放器控件或富文本渲染功能，而是给了你一套绘制像素和纹理的“画笔”，如何用这套画笔画出想要的画面，正是这个项目的挑战和乐趣所在。

这个项目非常适合那些已经熟悉 C/C++ 基础，并希望深入理解图形渲染流水线、或者需要为嵌入式设备、游戏 HUD、或自定义视频分析工具开发轻量级显示界面的开发者。通过它，你不仅能掌握 SDL2 处理视频和文字的核心流程，还能对纹理、表面、渲染器这些图形学基础概念有更直观的认识。整个过程就像在搭积木：视频解码器提供图像数据（积木块），SDL2 负责把它们拼到窗口上（拼装平台），而文字则是另一套需要你先绘制成图像，再贴上去的特殊积木块。

2. 核心思路与架构设计

2.1 为什么选择 SDL2 而不是其他框架？

当需要在一个窗口中同时显示视频和自定义图形时，你有不少选择，比如用 Qt 的 QMediaPlayer 配合 QGraphicsScene，或者基于 OpenCV 的 imshow 和高阶 GUI 功能。我选择 SDL2 主要基于以下几点考量：

首先，轻量与可控。SDL2 是一个接近硬件的、以 C 语言编写的库，它没有复杂的对象模型和信号槽机制，给你的就是窗口、渲染器、纹理这些最原始的“零件”。这种设计让你对内存和性能有更清晰的掌控，特别适合对执行效率有要求的实时应用，或者资源受限的环境。其次，真正的跨平台。SDL2 抽象了 Windows、macOS、Linux、甚至 Android 和 iOS 的视窗与输入系统，写一份代码，稍作编译调整就能在各个平台运行，这对于需要部署到多种设备上的工具来说至关重要。最后，图形渲染的核心能力。SDL2 的渲染 API 虽然不如现代图形 API（如 Vulkan、DirectX 12）强大，但它封装了 OpenGL 或 Direct3D 的常见 2D 操作（纹理上传、矩形绘制、混合），足以高效地完成视频帧的快速拷贝和文字图元的叠加，避免了从零开始学习庞大图形 API 的陡峭曲线。

当然，SDL2 不负责视频解码和文字排版，这意味着你需要引入额外的库来处理这些事，这反而让架构更清晰、职责更分明。

2.2 整体架构与数据流设计

整个程序可以看作一个简化的渲染引擎，其核心数据流如下图所示（用文字描述）：视频文件或流首先被 解码器（如 FFmpeg 的 libavcodec）解压成一帧帧的原始图像数据（通常是 YUV 或 RGB 格式）。这些数据被送入 SDL2 的流程：首先，为每一帧创建一个 SDL_Texture（纹理）；然后，通过 SDL_Renderer（渲染器）将纹理拷贝到默认的渲染目标（即后台缓冲区）。在渲染每一帧视频纹理之前或之后，我们需要处理文字：使用 字体库（如 SDL_ttf）将字符串渲染成一个单独的 SDL_Surface（表面），再将其转换为 SDL_Texture。最后，在渲染器中，先绘制视频纹理作为背景，再在指定位置绘制文字纹理。SDL_RenderPresent 函数则将最终的合成画面提交到前台窗口显示。

这个架构的关键在于理解 SDL2 的“渲染批次”概念。我们不应在每一帧里频繁创建和销毁纹理，而应在初始化阶段创建好可复用的文字纹理（对于静态文字），或高效更新动态文字纹理。视频纹理则通常需要每帧更新其内容。整个主循环遵循“事件处理 -> 更新逻辑（如改变文字内容/位置）-> 清除渲染目标 -> 绘制视频纹理 -> 绘制文字纹理 -> 呈现到屏幕”的标准模式。

注意：SDL2 的渲染默认是带混合（Blending）的。这意味着当你在视频上绘制半透明的文字纹理时，SDL2 会自动进行 Alpha 混合计算。如果你希望文字完全不透明，需要确保文字纹理的 Alpha 通道全为 255（不透明），或者通过 SDL_SetTextureBlendMode 进行设置。

3. 环境准备与核心库配置

3.1 SDL2 主库及扩展库的安装

SDL2 是核心，但为了显示文字，我们还需要 SDL_ttf 扩展库。对于视频解码，我将使用 FFmpeg 的 libavcodec 和 libavformat，这是目前最强大、最通用的解决方案。

在 Ubuntu/Debian 系统上，可以使用 apt 安装：

BASH

sudo apt update

sudo apt install libsdl2-dev libsdl2-ttf-dev libavcodec-dev libavformat-dev libavutil-dev libswscale-dev

在 macOS 上，使用 Homebrew 安装：

BASH

brew install sdl2 sdl2_ttf ffmpeg

在 Windows 上使用 MSYS2/MinGW：

BASH

pacman -S mingw-w64-x86_64-SDL2 mingw-w64-x86_64-SDL2_ttf mingw-w64-x86_64-ffmpeg

如果是 Windows 上的 Visual Studio，你需要从官网下载预编译的 SDL2 开发库（一个包含 include、 lib 和 dll 的压缩包），并正确配置项目属性中的包含目录、库目录和链接器输入。FFmpeg 同样可以下载官方提供的 shared 开发包。这个过程稍显繁琐，核心是确保编译器能找到头文件，链接器能找到 .lib 文件，并且运行时能访问对应的 .dll 文件。

3.2 项目编译与链接配置

无论使用哪种编译系统，正确链接库是关键。一个典型的 CMakeLists.txt 核心部分如下：

CMAKE

cmake_minimum_required(VERSION 3.10)

project(VideoTextOverlay)

find_package(SDL2 REQUIRED)

find_package(SDL2_ttf REQUIRED)

# 对于 FFmpeg，通常使用 pkg-config 或直接指定路径

find_package(PkgConfig REQUIRED)

pkg_check_modules(FFMPEG REQUIRED libavcodec libavformat libavutil libswscale)

add_executable(video_text_overlay main.cpp)

target_include_directories(video_text_overlay PRIVATE

${SDL2_INCLUDE_DIRS}

${SDL2_TTF_INCLUDE_DIRS}

${FFMPEG_INCLUDE_DIRS}

)

target_link_libraries(video_text_overlay

${SDL2_LIBRARIES}

${SDL2_TTF_LIBRARIES}

${FFMPEG_LIBRARIES}

)

如果使用 GCC 命令行直接编译，命令会很长：

BASH

g++ main.cpp -o video_text_overlay \

`pkg-config --cflags --libs sdl2 SDL2_ttf` \

`pkg-config --cflags --libs libavcodec libavformat libavutil libswscale` \

-std=c++11

这里最容易出错的地方是库的顺序和名称。SDL2 的 pkg-config 名称就是 sdl2，而 SDL2_ttf 是 SDL2_ttf。FFmpeg 的库较多，确保 libavcodec、libavformat、libavutil、libswscale 都被链接。如果遇到“未定义的引用”错误，首先检查链接器命令中是否包含了所有必需的库。

4. 核心模块实现详解

4.1 视频解码与 SDL 纹理渲染

视频解码我们交给 FFmpeg。其流程可以概括为：打开媒体文件（avformat_open_input）、查找视频流（av_find_best_stream）、创建解码器（avcodec_alloc_context3， avcodec_open2）、然后循环读取数据包（av_read_frame）、解码成帧（avcodec_send_packet， avcodec_receive_frame）。

解码后得到的 AVFrame 通常包含 YUV420P 格式的数据。SDL2 的纹理需要 RGB 格式。因此，我们需要用 FFmpeg 的 sws_scale 函数进行转换。这里的一个优化点是：创建一个与 SDL 纹理格式匹配的 SwsContext。我们可以先创建一个临时的 RGB SDL_Texture 来查询其像素格式，然后用这个格式来初始化转换器。

CPP

// 假设我们已经有了解码器上下文 video_codec_ctx

AVPixelFormat target_pixel_format = AV_PIX_FMT_RGB24; // SDL_PIXELFORMAT_RGB24 对应的 FFmpeg 格式

// 创建图像转换上下文

SwsContext* sws_ctx = sws_getContext(

video_codec_ctx->width, video_codec_ctx->height, video_codec_ctx->pix_fmt,

video_codec_ctx->width, video_codec_ctx->height, target_pixel_format,

SWS_BILINEAR, nullptr, nullptr, nullptr

);

// 在解码循环中

AVFrame* frame = av_frame_alloc();

// ... 解码得到 frame ...

// 准备一个目标 AVFrame 用于存放转换后的 RGB 数据

AVFrame* rgb_frame = av_frame_alloc();

rgb_frame->format = target_pixel_format;

rgb_frame->width = video_codec_ctx->width;

rgb_frame->height = video_codec_ctx->height;

av_frame_get_buffer(rgb_frame, 0);

// 转换

sws_scale(sws_ctx, frame->data, frame->linesize, 0, video_codec_ctx->height,

rgb_frame->data, rgb_frame->linesize);

// 现在 rgb_frame->data[0] 里就是连续的 RGB 数据了

接下来是 SDL 部分。我们需要创建一个纹理，并每帧更新它的内容：

CPP

// 初始化 SDL 视频子系统，创建窗口和渲染器

SDL_Init(SDL_INIT_VIDEO);

SDL_Window* window = SDL_CreateWindow("Video with Text", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);

SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

// 创建一个流式纹理（STREAMING），因为我们会频繁更新它

SDL_Texture* video_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB24,

SDL_TEXTUREACCESS_STREAMING, width, height);

// 在主循环中，更新纹理

void* texture_pixels;

int texture_pitch;

SDL_LockTexture(video_texture, nullptr, &texture_pixels, &texture_pitch);

// 将 rgb_frame->data[0] 的数据拷贝到 texture_pixels

// 注意：texture_pitch 可能不等于 width * 3（RGB），需要使用它进行行对齐拷贝

memcpy(texture_pixels, rgb_frame->data[0], texture_pitch * height);

SDL_UnlockTexture(video_texture);

// 渲染

SDL_RenderClear(renderer);

SDL_RenderCopy(renderer, video_texture, nullptr, nullptr); // 绘制整个纹理到整个窗口

// 之后在这里绘制文字纹理...

SDL_RenderPresent(renderer);

关键细节：SDL_LockTexture 和 SDL_UnlockTexture 必须成对调用。texture_pitch 是纹理内存中一行像素的字节数，它可能由于内存对齐要求而略大于 width * bytes_per_pixel。直接使用 memcpy 逐行拷贝时，源数据（rgb_frame->linesize[0]）和目标步长（texture_pitch）可能不同，必须按行循环拷贝，而不是一次性拷贝整个内存块，否则会导致图像错乱。

4.2 动态文字纹理的生成与渲染

显示文字需要 SDL_ttf。首先初始化并加载一个字体文件：

CPP

TTF_Init();

TTF_Font* font = TTF_OpenFont("path/to/your/font.ttf", 24); // 24 是字体大小

if (!font) {

// 处理错误，字体文件可能不存在或损坏

}

对于静态文字（如固定的标题），我们可以在程序开始时创建好纹理：

CPP

SDL_Color text_color = {255, 255, 255, 255}; // 白色，不透明

SDL_Surface* text_surface = TTF_RenderUTF8_Blended(font, "静态标题", text_color);

SDL_Texture* static_text_texture = SDL_CreateTextureFromSurface(renderer, text_surface);

SDL_FreeSurface(text_surface); // 表面数据已上传至纹理，可以释放

// 记录文字纹理的尺寸，用于渲染时定位

int text_width, text_height;

SDL_QueryTexture(static_text_texture, NULL, NULL, &text_width, &text_height);

SDL_Rect text_rect = {10, 10, text_width, text_height}; // 左上角(10,10)的位置

对于动态文字（如每秒变化的帧率计数器），每帧都创建新的表面和纹理是巨大的性能开销。正确的做法是复用纹理。我们可以准备一个固定的纹理，当文字内容改变时，重新渲染表面并更新这个纹理的内容。

CPP

// 初始化一个动态文字纹理（可以先创建一个1x1的占位）

SDL_Texture* dynamic_text_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888,

SDL_TEXTUREACCESS_TARGET, 100, 50); // 预估一个大小

SDL_SetTextureBlendMode(dynamic_text_texture, SDL_BLENDMODE_BLEND); // 启用混合，支持透明背景

// 当需要更新文字时（例如每秒一次）

char fps_text[64];

sprintf(fps_text, "FPS: %.1f", current_fps);

SDL_Surface* new_text_surface = TTF_RenderUTF8_Blended(font, fps_text, text_color);

if (new_text_surface) {

// 如果新表面尺寸大于现有纹理，需要重建纹理（简单处理，也可用更复杂的动态调整策略）

if (new_text_surface->w > 100 || new_text_surface->h > 50) {

SDL_DestroyTexture(dynamic_text_texture);

dynamic_text_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888,

SDL_TEXTUREACCESS_TARGET,

new_text_surface->w, new_text_surface->h);

SDL_SetTextureBlendMode(dynamic_text_texture, SDL_BLENDMODE_BLEND);

}

// 将纹理设置为渲染目标，把表面内容拷贝上去

SDL_SetRenderTarget(renderer, dynamic_text_texture);

SDL_RenderClear(renderer); // 清除纹理原有内容（如果是透明背景，这一步很重要）

// 创建一个临时纹理来上传表面数据

SDL_Texture* temp_tex = SDL_CreateTextureFromSurface(renderer, new_text_surface);

SDL_RenderCopy(renderer, temp_tex, nullptr, nullptr);

SDL_DestroyTexture(temp_tex);

SDL_SetRenderTarget(renderer, nullptr); // 将渲染目标重置回默认（窗口）

SDL_FreeSurface(new_text_surface);

// 更新文字的位置矩形

text_rect.w = new_text_surface->w;

text_rect.h = new_text_surface->h;

}

在主渲染循环中，在绘制完视频纹理后，绘制文字纹理：

CPP

SDL_RenderCopy(renderer, static_text_texture, nullptr, &static_text_rect);

SDL_RenderCopy(renderer, dynamic_text_texture, nullptr, &dynamic_text_rect);

实操心得：TTF_RenderUTF8_Blended 渲染质量高，支持抗锯齿和 Alpha 混合，但性能稍低。如果对性能要求极高且文字背景不透明，可以考虑 TTF_RenderUTF8_Solid。另外，频繁创建和销毁 SDL_Surface 和 SDL_Texture 会导致内存碎片和性能下降，对于高速变化的动态文字，上述复用纹理的方法至关重要。同时，将纹理设置为渲染目标（SDL_SetRenderTarget）来进行更新，比每帧 SDL_LockTexture 再拷贝像素数据要更高效，因为驱动可能对其进行优化。

4.3 音视频同步与主循环控制

一个健壮的播放器必须处理音视频同步。这里我们实现一个简单的视频同步到系统时钟的方案（“同步到音频”是更佳体验，但更复杂）。

核心思想是：每个视频帧都有一个基于其时间戳（PTS）的理想呈现时间。我们根据帧率计算出下一帧应该显示的时间，然后让主循环等待直到那个时刻。

CPP

double frame_delay = 1.0 / frame_rate; // 每帧应持续的秒数

double next_frame_time = av_gettime() / 1000000.0; // 当前系统时间（秒）

while (!quit) {

// 处理事件、解码得到一帧 video_frame ...

// 计算该帧的显示时间

double pts = video_frame->pts * av_q2d(time_base); // 转换为秒

// 简单的同步：如果解码太快，就延迟

double current_time = av_gettime() / 1000000.0;

double delay = pts - current_time;

if (delay > 0) {

// 使用 SDL_Delay 会阻塞整个线程，可能影响事件响应。

// 更精细的控制可以使用高精度睡眠或在一个独立计时循环中处理。

SDL_Delay((Uint32)(delay * 1000)); // 转换为毫秒

} else if (delay < -0.1) {

// 如果落后超过0.1秒，可以考虑丢帧追赶

continue;

}

// 渲染这一帧

render_video_frame(video_frame);

render_text();

// 更新下一帧的理想时间

next_frame_time += frame_delay;

// 防止时间漂移，可以偶尔根据系统时间重新校准 next_frame_time

}

主循环还必须高效响应 SDL 事件（如退出、窗口大小调整、暂停等）：

CPP

SDL_Event event;

while (SDL_PollEvent(&event)) {

switch (event.type) {

case SDL_QUIT:

quit = true;

break;

case SDL_KEYDOWN:

if (event.key.keysym.sym == SDLK_ESCAPE) quit = true;

else if (event.key.keysym.sym == SDLK_SPACE) paused = !paused; // 暂停/继续

break;

case SDL_WINDOWEVENT:

if (event.window.event == SDL_WINDOWEVENT_RESIZED) {

// 窗口大小改变，可以更新渲染视口或调整绘制比例

int new_width = event.window.data1;

int new_height = event.window.data2;

// 可能需要重新计算文字位置等

}

break;

}

if (paused) {

// 暂停时，可以继续处理事件但不解码渲染，或者渲染一个暂停画面

SDL_Delay(10);

continue;

}

5. 性能优化与高级特性实现

5.1 利用硬件加速与纹理流

我们之前创建的纹理是 SDL_TEXTUREACCESS_STREAMING，这表示 CPU 可以更新它。SDL 渲染器在创建时如果指定了 SDL_RENDERER_ACCELERATED，它会尝试使用 GPU。为了进一步利用硬件，我们可以探索 SDL_TEXTUREACCESS_TARGET。我们可以将视频纹理也创建为渲染目标，然后通过一个离屏的渲染操作（例如使用着色器，如果 SDL 支持的话）来绘制，但这通常需要更复杂的设置。对于简单的视频播放，流式纹理配合 SDL_UpdateTexture 有时比 Lock/Unlock 更高效，因为它可能由驱动进行内部优化。

CPP

// 替代 Lock/Unlock 的方式

SDL_UpdateTexture(video_texture, nullptr, rgb_frame->data[0], rgb_frame->linesize[0]);

对于高分辨率视频，每帧的 YUV 到 RGB 转换（sws_scale）是 CPU 上的一个热点。一个高级优化是使用支持 GPU 加速的缩放器，或者直接创建 YUV 格式的 SDL 纹理（如 SDL_PIXELFORMAT_IYUV），让 SDL 和驱动在渲染时进行转换。这需要解码器输出 YUV 数据，并创建对应格式的纹理：

CPP

// 检查渲染器是否支持 YUV 纹理格式

SDL_RendererInfo info;

SDL_GetRendererInfo(renderer, &info);

bool supports_yuv = false;

for (Uint32 i = 0; i < info.num_texture_formats; i++) {

if (info.texture_formats[i] == SDL_PIXELFORMAT_IYUV) {

supports_yuv = true;

break;

}

if (supports_yuv) {

// 创建 YUV 纹理

video_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_IYUV,

SDL_TEXTUREACCESS_STREAMING, width, height);

// 更新纹理时需要分别提供 Y、U、V 平面的数据

SDL_UpdateYUVTexture(video_texture, nullptr,

video_frame->data[0], video_frame->linesize[0], // Y

video_frame->data[1], video_frame->linesize[1], // U

video_frame->data[2], video_frame->linesize[2]); // V

}

这样可以完全避免 CPU 端的色彩空间转换，显著降低 CPU 占用，特别是在播放高清视频时。

5.2 多行文字、富文本与渲染批处理

现实中的需求往往不只是显示一行文字。可能需要显示多行日志、带背景框的文字、或者不同颜色大小的文字混合。

多行文字：SDL_ttf 不直接支持自动换行。你需要自己实现：计算字符串宽度，在超过边界时手动插入换行符 \n，然后对每一行分别调用 TTF_RenderText_Blended。或者，你可以使用一个更高级的库，如 Pango（但集成复杂度会增加）。

文字背景与边框：这需要在渲染文字纹理后，再在其外围绘制矩形。一种方法是先创建一个稍大的纹理作为背景，将文字纹理渲染到它的中间。更简单的方法是在渲染到窗口时，先画一个填充矩形，再画文字：

CPP

// 绘制半透明黑色背景

SDL_Rect bg_rect = {text_rect.x - 5, text_rect.y - 2, text_rect.w + 10, text_rect.h + 4};

SDL_SetRenderDrawColor(renderer, 0, 0, 0, 180); // 黑色，70%透明度

SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);

SDL_RenderFillRect(renderer, &bg_rect);

// 然后绘制文字纹理

SDL_RenderCopy(renderer, text_texture, nullptr, &text_rect);

渲染批处理：当屏幕上需要显示大量独立的文字元素（如游戏中的大量伤害数字）时，每元素一个纹理和一次 SDL_RenderCopy 调用会造成性能瓶颈。一个优化策略是将多个文字渲染到同一张大纹理（图集）上，然后只对这张大纹理进行一次绘制。这需要自己管理图集的分配和更新，类似于游戏引擎中的字体图集（Font Atlas）技术。对于 SDL_ttf，你可以预先将常用字符渲染到一张大纹理上，使用时只拷贝对应的矩形区域。

6. 常见问题排查与调试技巧

6.1 编译与链接问题

**“undefined reference to TTF_Init'” 等链接错误**：这是最典型的问题。确保你的链接命令包含了 -lSDL2_ttf，并且库文件路径正确。在 CMake 中，检查 find_package(SDL2_ttf REQUIRED)是否成功，并且target_link_libraries包含了${SDL2_TTF_LIBRARIES}。在 Windows 上，确保将 SDL2_ttf.dll` 放在可执行文件同级目录或系统路径下。
“Failed to load font”：字体路径错误或文件损坏。使用绝对路径进行测试。检查程序的工作目录是否是你认为的那个目录。在 IDE 中运行时，工作目录通常是项目目录，而不是可执行文件所在目录。
FFmpeg 函数未定义：确保链接了所有必要的 FFmpeg 库（avcodec, avformat, avutil, swscale），并且它们的版本与头文件匹配。注意 FFmpeg 4.x 和 5.x 的 API 可能有变化。

6.2 运行时渲染问题

视频显示为绿色或颜色错乱：这几乎总是 YUV 到 RGB 转换环节的问题。首先确认你的 AVFrame 的 pix_fmt 是什么（比如 AV_PIX_FMT_YUV420P）。然后确认你创建的 SDL 纹理格式与之匹配。如果你用 RGB 纹理，却传入了 YUV 数据，或者 sws_scale 转换的参数不对，就会出问题。使用 printf 打印出 frame->format, frame->width, frame->height 以及你创建的纹理格式进行核对。
文字显示为黑色方块或不显示：
1. 检查字体加载：TTF_OpenFont 的返回值是否为 NULL？用 TTF_GetError() 获取错误信息。
2. 检查颜色格式：确保你渲染文字表面时使用的颜色（SDL_Color）的 Alpha 值不是 0（完全透明）。{255,255,255,255} 是纯白不透明。
3. 检查渲染顺序和混合模式：确保你在绘制视频纹理之后绘制文字纹理。如果文字纹理有透明通道，确保其混合模式为 SDL_BLENDMODE_BLEND，并且渲染器也启用了混合（默认是启用的）。
4. 检查矩形位置：确保你传递给 SDL_RenderCopy 的 SDL_Rect 的 x, y 坐标在窗口可视范围内，并且 w, h 是正数。
程序卡顿或帧率很低：
1. 性能分析：在解码循环和渲染循环中加入简单的帧率计算，定位瓶颈。是解码慢（CPU 占用高）还是渲染慢？
2. 解码优化：尝试使用 FFmpeg 的硬件解码（如 hwaccel），但这需要额外的配置和平台支持。
3. 渲染优化：确保使用了 SDL_RENDERER_ACCELERATED。避免在每帧中创建/销毁 SDL 表面和纹理。对于动态文字，使用前面提到的纹理复用方法。检查 SDL_RenderPresent 是否在循环中只调用了一次。
4. 同步问题：如果没有正确的音视频同步，解码线程可能会以最大速度跑满 CPU。实现一个简单的基于时钟的同步机制，如第 4.3 节所述。

6.3 内存与资源泄漏

SDL 和 FFmpeg 的对象都需要手动管理内存。一个稳健的做法是使用 RAII（资源获取即初始化）思想，用 C++ 的类来封装这些资源，在析构函数中释放。至少，要确保在程序退出前，按顺序释放：

CPP

// 关闭时清理

SDL_DestroyTexture(text_texture);

SDL_DestroyTexture(video_texture);

TTF_CloseFont(font);

SDL_DestroyRenderer(renderer);

SDL_DestroyWindow(window);

// FFmpeg 清理

av_frame_free(&rgb_frame);

av_frame_free(&video_frame);

sws_freeContext(sws_ctx);

avcodec_free_context(&video_codec_ctx);

avformat_close_input(&format_ctx);

TTF_Quit();

SDL_Quit();

使用 Valgrind（Linux/macOS）或 Visual Studio 的内存诊断工具来检查是否有未释放的内存。特别是 av_frame_alloc() 和 sws_getContext() 分配的资源，很容易被遗忘。

7. 项目扩展与实践建议

掌握了基础之后，这个项目可以朝多个方向扩展，变成一个功能更强大的工具：

支持更多视频源：不止是本地文件，可以扩展支持网络流（RTSP、HTTP-FLV）、摄像头采集（通过 libavdevice 或平台特定 API）。
添加音频播放：使用 SDL_audio 或 FFmpeg 解码音频，实现音视频同步播放，这才是完整的播放器。
实现交互式文字：响应鼠标点击，让文字可拖动；或者根据视频内容（通过 OpenCV 分析）动态改变文字位置和内容。
更复杂的图形叠加：除了文字，还可以叠加几何图形、图片水印、甚至简单的动画。
录制与输出：将叠加了文字的最终画面重新编码成视频文件，这需要用到 FFmpeg 的编码器。

从实践角度，我建议在项目初期就建立清晰的模块边界，比如将“视频解码与管理”、“文字渲染与管理”、“主循环与事件处理”分离成不同的类或模块。这样代码更易维护和调试。另外，一定要多写日志，记录关键步骤的成功与失败，这对于排查复杂的多媒体问题至关重要。最后，不要试图一开始就做出完美的播放器，先让最基本的流程跑起来，再逐个添加功能和优化，每完成一个步骤都进行充分的测试。