音视频技术应用(17)- 开启DXVA2硬件加速, 并使用SDL显示
实现了使用DXVA2 进行硬件加速，并且使用SDL渲染h264格式的视频, 视频大小为400x300。
一. 示例Code
test_decode_view_hw.cpp
#include <iostream> #include <fstream> #include <string> #include "xvideo_view.h" using namespace std; extern "C" { // 指定函数是C语言函数，以C语言的方式去编译 #include <libavcodec/avcodec.h> #include <libavutil/opt.h> } // 以预处理指令的方式导入库 #pragma comment(lib, "avcodec.lib") #pragma comment(lib, "avutil.lib") int main(int argc, char* argv[]) { // 创建一个XVideoView auto view = XVideoView::Create(); // 分割H264存入AVPacket string filename = "test.h264"; ifstream ifs(filename, ios::binary); if (!ifs) return -1; unsigned char inbuf[4096] = {0}; AVCodecID codec_id = AV_CODEC_ID_H264; // 1. 查找解码器 auto codec = avcodec_find_decoder(codec_id); // 2. 根据解码器创建解码器上下文 auto c = avcodec_alloc_context3(codec); ////////////////////////////////////////////////// /// 硬件加速部分 auto hw_type = AV_HWDEVICE_TYPE_DXVA2; // 打印所有支持的硬件加速方式 for (int i = 0;; i++) { auto config = avcodec_get_hw_config(codec, i); if (!config) break; if (config->device_type) cout << av_hwdevice_get_type_name(config->device_type) << endl; } // 初始化硬件加速上下文 AVBufferRef* hw_ctx = nullptr; av_hwdevice_ctx_create(&hw_ctx, hw_type, nullptr, nullptr, 0); // 开启硬件加速 c->hw_device_ctx = av_buffer_ref(hw_ctx); // 开启多线程解码 c->thread_count = 16; // 3. 打开解码器 avcodec_open2(c, nullptr, nullptr); // 分割上下文 auto parser = av_parser_init(codec_id); auto pkt = av_packet_alloc(); auto frame = av_frame_alloc(); auto hw_frame = av_frame_alloc(); // 硬解码转换用，未来会把显存中的数据转换到此frame中 auto begin = NowMs(); int count = 0; // 当前解码的帧数 bool is_init_window = false; // 标志位，用于标识窗口是否已经初始化 while (!ifs.eof()) { ifs.read((char *)inbuf, sizeof(inbuf)); if (ifs.eof()) { ifs.clear(); ifs.seekg(0, ios::beg); } int data_size = ifs.gcount(); // 读取的字节数 if (data_size <= 0) break; auto data = inbuf; while (data_size > 0) // 一次可能有多帧数据 { // 通过0001 截断输出到AVPacket 返回值代表帧的大小 int ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size, // 输出数据 data, data_size, // 输入数据 AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0 ); // 移动指针位置 data += ret; data_size -= ret; // 已处理数据 if (pkt->size) { // cout << pkt->size << " " << flush; ret = avcodec_send_packet(c, pkt); if (ret < 0) break; // 获取多帧解码数据 while (ret >= 0) { // 每次都会调用av_frame_unref; ret = avcodec_receive_frame(c, frame); if (ret < 0) break; auto pframe = frame; if (c->hw_device_ctx) // 如果设置了 hw_device_ctx 成员，则认为是硬件解码 { // 硬解码出来的数据转换 GPU->CPU (从显存复制到内存，不想复制的话可以直接使用DX渲染) av_hwframe_transfer_data(hw_frame, frame, 0); // 注意转换后的数据格式会变成NV12格式 (AV_PIX_FMT_NV12) pframe = hw_frame; } cout << pframe->format << " " << flush; if (!is_init_window) { // 根据第一帧的宽高来初始化窗口，若窗口已初始化，则将此标志位置为true is_init_window = true; view->Init(pframe->width, pframe->height, (XVideoView::Format)pframe->format); } view->DrawFrame(pframe); // 解码成功后累积帧数 count++; auto cur = NowMs(); if (cur - begin > 1000) // 每1秒计算一次 { cout << "\nfps = " << count << endl; // 重置起始时间 count = 0; begin = cur; } } } } } // 取出缓存数据，确保所有数据都能够得到解码 int ret = avcodec_send_packet(c, NULL); while (ret >= 0) { ret = avcodec_receive_frame(c, frame); if (ret < 0) break; cout << frame->format << "-" << flush; } av_parser_close(parser); avcodec_free_context(&c); av_frame_free(&frame); av_packet_free(&pkt); return 0; }
xvideo_view.h
#ifndef XVIDEO_VIEW_H #define XVIDEO_VIEW_H #include <mutex> #include <fstream> /** * @brief 自定义休眠函数 * @param ms 休眠时间 */ void MSleep(unsigned int ms); /** * @brief 获取当前时间戳(单位是毫秒) * @return 当前时间戳 */ long long NowMs(); struct AVFrame; class XVideoView { public: /** * @brief 定义所有支持的图像的像素格式 */ enum Format // 枚举中的值与FFmpeg中像素格式定义的值保持一致 { YUV420P = 0, NV12 = 23, ARGB = 25, RGBA = 26, BGRA = 28 }; enum RenderType { SDL = 0 }; static XVideoView* Create(RenderType type = SDL); /** * @brief 初始化渲染接口(线程安全) 可以多次调用 * @param w 窗口宽度 * @param h 窗口高度 * @param fmt 绘制的像素格式(要绘制的图像的像素格式) * @param win_id 窗口句柄，如果为空，则创建窗口 * @return 是否创建成功 */ virtual bool Init(int w, int h, Format fmt = RGBA) = 0; /** * @brief 清理所有申请的资源，包括关闭窗口 线程安全 */ virtual void Close() = 0; /** * @brief 渲染图像, 这里渲染的一帧完整的图像(线程安全) * @param data 渲染的二进制数据 * @param linesize 一行数据的字节数，对于YUV420P的数据格式，就是Y一行的字节数, 如果linesize <= 0, 则根据宽度和像素格式自动算出大小 * @return 是否渲染成功 */ virtual bool Draw(const unsigned char *data, int linesize = 0) = 0; /** * @brief 渲染图片，这里是对Y/U/V数据分别进行渲染(线程安全) * @param y Y分量的数据 * @param y_pitch Y 的个数 * @param u U分量的数据 * @param u_pitch U的个数 * @param v V分量的数据 * @param v_pitch V的个数 * @return 绘制的结果 */ virtual bool Draw(const unsigned char *y, int y_pitch, const unsigned char *u, int u_pitch, const unsigned char *v, int v_pitch ) = 0; /** * @brief 提供一个接口用于显示缩放 * @param w 实际显示的宽度 * @param h 实际显示的高度 */ void Scale(int w, int h) { scale_w_ = w; scale_h_ = h; } /** * @brief 绘制AVFrame中的数据 * @param frame AVFrame对象 * @return 绘制结果 */ bool DrawFrame(AVFrame *frame); /** * @brief 处理窗口退出事件 * @return 是否已退出 */ virtual bool isExit() = 0; /** * @brief 返回当前视频帧率 * @return 当前视频帧率 */ int render_fps() { return render_fps_; } /** * @brief 打开文件 * @param filepath 文件路径 * @return 打开结果 */ bool Open(std::string filepath); /** * @brief 读取一帧数据并返回AVFrame空间 * @return 新读取的AVFrame数据，读取失败则返回nullptr */ AVFrame* Read(); /** * @brief 设置当前关联的窗口句柄 * @param win 设置的窗口句柄 */ void set_win_id(void* win) { win_id_ = win; } // 注意，父类的析构函数必须定义成虚函数，避免父类指向子类对象时, 子类的析构不会调用 virtual ~XVideoView(); protected: void* win_id_ = nullptr; // 当前关联的窗口句柄 int render_fps_ = 0; // 当前视频帧率 int width_ = 0; // 材质的宽度 int height_ = 0; // 材质的高度 Format fmt_ = RGBA; // 像素格式 std::mutex mtx_; // 用于确保线程安全 int scale_w_ = 0; // 实际显示的宽度 int scale_h_ = 0; // 实际显示的高度 long long beg_ms_ = 0; // 计时的开始时间 int count_ = 0; // 统计显示次数 private: std::ifstream ifs_; // 读取文件的流 AVFrame* frame_ = nullptr; // 读取的AVFrame数据 unsigned char* cache_ = nullptr; // 复制NV12数据的缓冲 }; #endif
xvideo_view.cpp
#include "xvideo_view.h" #include "xsdl.h" #include <iostream> using namespace std; extern "C" { #include <libavcodec/avcodec.h> } #pragma comment(lib, "avutil.lib") XVideoView* XVideoView::Create(RenderType type) { switch (type) { case XVideoView::SDL: return new XSDL(); break; default: break; } // 如果不支持的话，就直接返回nullptr return nullptr; } XVideoView::~XVideoView() { if (cache_) delete cache_; cache_ = nullptr; } bool XVideoView::DrawFrame(AVFrame* frame) { if (!frame) { cout << "input frame can not be null" << endl; return false; } // 累积显示次数 count_++; if (beg_ms_ <= 0) { beg_ms_ = clock(); // 开始计时 } else if ((clock() - beg_ms_) / (CLOCKS_PER_SEC / 1000) >= 1000) // 1s 计算一次fps { render_fps_ = count_; count_ = 0; beg_ms_ = clock(); // 重新计时 } int linesize = 0; switch (frame->format) { case AV_PIX_FMT_YUV420P: return Draw(frame->data[0], frame->linesize[0], // Y frame->data[1], frame->linesize[1], // U frame->data[2], frame->linesize[2] // V ); case AV_PIX_FMT_NV12: if (!cache_) { // 若空间尚未分配，则申请一块较大的空间(4K的一幅图像的大小) cache_ = new unsigned char[4096 * 2160 * 1.5]; } // PS: 注意！这里面涉及到一个内存对齐的问题！ // 如果是400x300的YUV420P/NV12格式，它的linesize很可能会被FFmpeg自动进行字节对齐, 即当图像尺寸为400x300时，它的linesize可能 // 不是400，而是416(假设ffmpeg是以16字节进行对齐) // 而在使用SDL进行渲染时，linesize若传递416，很可能导致渲染出现问题，为了避免出现这种情况，下面提供了一种逐行复制的策略。 // 下面的内存拷贝主要目的是为了让数据是连续的 linesize = frame->width; if (frame->linesize[0] == frame->width) { // ---------------- 若linesize与图像的宽度一致，说明未发生字节对齐 --------------- // 拷贝所有Y分量 memcpy(cache_, frame->data[0], frame->linesize[0] * frame->height); // 拷贝所有的UV分量 memcpy(cache_ + frame->linesize[0] * frame->height, frame->data[1], frame->linesize[1] * frame->height / 2); } else { // ---------------- 若linesize与图像的宽度一致，说明发生了字节对齐 --------------- // 使用逐行拷贝的方式 // 拷贝所有的Y分量 for (int i = 0; i < frame->height; i++) { memcpy(cache_ + i * frame->width, frame->data[0] + i * frame->linesize[0], frame->width // 注意只需要拷贝frame->width个数即可，丢弃因为对齐产生的多余数据 ); } // 拷贝所有UV分量 for (int i = 0; i < frame->height / 2; i++) { // 将指针定位到所有Y分量数据的结尾处，从所有Y分量数据的结尾处开始拷贝UV分量 auto p = cache_ + frame->width * frame->height; memcpy(p + i * frame->width, frame->data[1] + i * frame->linesize[1], frame->width // 注意只需要拷贝frame->width个数即可，丢弃因为对齐产生的多余数据 ); } } return Draw(cache_, linesize); case AV_PIX_FMT_RGBA: case AV_PIX_FMT_BGRA: case AV_PIX_FMT_ARGB: return Draw(frame->data[0], frame->linesize[0]); default: break; } return false; } /** * @brief 返回当前时间戳 * @return 当前时间戳 */ long long NowMs() { // 注意!!! 这里不要直接返回clock(), 这样的话只能在windows中当中使用，因为这个函数在windows当中返回的是毫秒数 // 但是在linux当中这个值返回的是微秒数，所以需要除以 (CLOCKS_PER_SEC / 1000) // 因为在linux当中 CLOCKS_PER_SEC 这个值返回的是1000000, 但是在windows当中这个值返回的是1000. // 这样可以最大限度地保证兼容性和跨平台 return clock() / (CLOCKS_PER_SEC / 1000); } AVFrame* XVideoView::Read() { // 如果宽度小于0，高度小于0，且文件未成功打开，则直接返回 if (width_ <= 0 || height_ <= 0 || !ifs_) return nullptr; // 若AVFrame内存空间已申请，但参数发生变化，则需要释放空间 // 因为用户可能通过界面上的文本输入框重新设定图像大小 if (frame_) { if (frame_->width != width_ || frame_->height != height_ || frame_->format != fmt_) { // 说明用户重新选择了界面参数(宽，高，像素格式)，需要释放AVFrame空间 av_frame_free(&frame_); } } // 若frame为空，则重新申请 if (!frame_) { frame_ = av_frame_alloc(); frame_->width = width_; frame_->height = height_; frame_->format = fmt_; frame_->linesize[0] = width_ * 4; // 默认像素格式为RGBA if (frame_->format == AV_PIX_FMT_YUV420P) { frame_->linesize[0] = width_; // Y frame_->linesize[1] = width_ / 2; // U frame_->linesize[2] = width_ / 2; // V } // 生成AVFrame的buff空间，使用默认对齐方式 auto re = av_frame_get_buffer(frame_, 0); if (re != 0) { char buf[1024] = { 0 }; av_strerror(re, buf, sizeof(buf) - 1); cout << buf << endl; av_frame_free(&frame_); return nullptr; } } if (!frame_) return nullptr; // 读取一帧数据 if (frame_->format == AV_PIX_FMT_YUV420P) { ifs_.read((char*)frame_->data[0], frame_->linesize[0] * height_); // 读取Y ifs_.read((char*)frame_->data[1], frame_->linesize[1] * height_ / 2); // 读取U ifs_.read((char*)frame_->data[2], frame_->linesize[2] * height_ / 2); // 读取V } else { ifs_.read((char *)frame_->data[0], frame_->linesize[0] * height_); } // 如果读取到文件末尾，则直接返回 if (ifs_.gcount() == 0) return nullptr; // 否则返回读取后的AVFrame数据 return frame_; } bool XVideoView::Open(std::string filepath) { if (ifs_.is_open()) { ifs_.close(); } ifs_.open(filepath, ios::binary); return ifs_.is_open(); }
xsdl.h
#ifndef XSDL_H #define XSDL_H #include "xvideo_view.h" struct SDL_Window; struct SDL_Renderer; struct SDL_Texture; class XSDL : public XVideoView { public: /** * @brief 初始化渲染接口(线程安全) * @param w 窗口宽度 * @param h 窗口高度 * @param fmt 绘制的像素格式(要绘制的图像的像素格式) * @param win_id 窗口句柄，如果为空，则创建窗口 * @return 是否创建成功 */ bool Init(int w, int h, Format fmt = RGBA) override; /** * @brief 清理的接口 */ void Close() override; /** * @brief 渲染图像(线程安全) * @param data 渲染的二进制数据 * @param linesize 一行数据的字节数，对于YUV420P的数据格式，就是Y一行的字节数, 如果linesize <= 0, 则根据宽度和像素格式自动算出大小 * @return 是否渲染成功 */ bool Draw(const unsigned char* data, int linesize = 0) override; /** * @brief 渲染图片，这里是对Y/U/V数据分别进行渲染(线程安全) * @param y Y分量的数据 * @param y_pitch Y 的个数 * @param u U分量的数据 * @param u_pitch U的个数 * @param v V分量的数据 * @param v_pitch V的个数 * @return 绘制的结果 */ bool Draw(const unsigned char* y, int y_pitch, const unsigned char* u, int u_pitch, const unsigned char* v, int v_pitch ) override; /** * @brief 处理窗口退出事件 * @return 是否已退出 */ bool isExit() override; private: SDL_Window* win_ = nullptr; SDL_Renderer* render_ = nullptr; SDL_Texture* texture_ = nullptr; }; #endif
xsdl.cpp
#include "xsdl.h" #include <iostream> #include <thread> #include <sdl/SDL.h> #pragma comment(lib, "SDL2.lib") using namespace std; void MSleep(unsigned int ms) { auto beg = clock(); for (int i = 0; i < ms; i++) { this_thread::sleep_for(1ms); if ((clock() - beg) / (CLOCKS_PER_SEC / 1000) >= ms) break; } } /** * @brief 初始化视频库 * @return 初始化结果 */ static bool InitVideo() { static bool is_first = true; // 这里使用的是静态变量，表示多次进来使用的是同一个对象 static mutex mux; unique_lock<mutex> sdl_lock(mux); // 表示已经初始化过了 if (!is_first) return true; if (SDL_Init(SDL_INIT_VIDEO)) { cout << SDL_GetError() << endl; return false; } // 设定缩放算法， 解决锯齿问题，这里采用的是线性插值算法 // "0": 临近插值算法 // "1": 线性插值算法 // "2"：目前与线性插值算法一致 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1"); return true; } bool XSDL::Init(int w, int h, Format fmt) { // 判断输入的参数是否合法 if (w <= 0 || h <= 0) { cout << "input width or height is error " << endl; return false; } // 初始化SDL Video 库 if (!InitVideo()) { cout << "init video failed" << endl; return false; } // 确保线程安全 // unique_lock 相当于是在栈中分配了一个对象 sdl_lock, 只要这个对象一出栈， // 就会自动调用析构函数，它在析构函数中会调用 mtx_的 unlock()方法 unique_lock<mutex> sdl_lock(mtx_); width_ = w; height_ = h; fmt_ = fmt; // 如果再次初始化时发现材质和渲染器已存在，则先对其进行销毁 // 这样做的目的是为了保证多次初始化能够成功 if (texture_) { SDL_DestroyTexture(texture_); } if (render_) { SDL_DestroyRenderer(render_); } // 1. 创建SDL窗口 if (!win_) { if (!win_id_) { // 如果用户没有给出创建窗口的句柄，那我们就自行创建一个新的窗口 win_ = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width_, height_, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE ); } else { // 如果用户给定了创建窗口的句柄，则将画面渲染到用户的给定的控件窗口 win_ = SDL_CreateWindowFrom(win_id_); } } if (!win_) { cerr << SDL_GetError() << endl; return false; } // 2. 创建渲染器 render_ = SDL_CreateRenderer(win_, -1, SDL_RENDERER_ACCELERATED); if (!render_) { cerr << SDL_GetError() << endl; return false; } // 3. 创建材质 (存在于显存当中) unsigned int sdl_fmt = SDL_PIXELFORMAT_RGBA8888; switch (fmt) { case XVideoView::RGBA: sdl_fmt = SDL_PIXELFORMAT_RGBA32; break; case XVideoView::BGRA: sdl_fmt = SDL_PIXELFORMAT_BGRA32; break; case XVideoView::ARGB: sdl_fmt = SDL_PIXELFORMAT_ARGB32; break; case XVideoView::NV12: sdl_fmt = SDL_PIXELFORMAT_NV12; break; case XVideoView::YUV420P: sdl_fmt = SDL_PIXELFORMAT_IYUV; break; default: break; } texture_ = SDL_CreateTexture(render_, sdl_fmt, // 像素格式 SDL_TEXTUREACCESS_STREAMING, // 频繁修改的渲染 w, h // 材质的宽高 ); if (!texture_) { cerr << SDL_GetError() << endl; return false; } // cout << "XSDL init success" << endl; return true; } bool XSDL::Draw(const unsigned char* data, int linesize) { if (!data) { cout << "input data is null" << endl; return false; } // 保证线程同步 unique_lock<mutex> sdl_lock(mtx_); if (!texture_ || !render_ || !win_ || width_ <= 0 || height_ <= 0) { cout << "draw failed, param error" << endl; return false; } if (linesize <= 0) { switch (fmt_) { case XVideoView::RGBA: case XVideoView::ARGB: linesize = width_ * height_ * 4; break; case XVideoView::YUV420P: linesize = width_; break; default: break; } } if (linesize <= 0) { cout << "linesize is error" << endl; return false; } // 复制内存到显存 auto re = SDL_UpdateTexture(texture_, NULL, data, linesize); if (re) { cout << "update texture failed" << endl; return false; } // 清理渲染器 SDL_RenderClear(render_); // 如果用户手动设置了缩放，就按照用户设置的大小显示 // 如果用户没有设置，就传递null, 采用默认的窗口大小 SDL_Rect *prect = nullptr; if (scale_w_ > 0 || scale_h_ > 0) { SDL_Rect rect; rect.x = 0; rect.y = 0; rect.w = scale_w_; rect.h = scale_h_; prect = ▭ } // 拷贝材质到渲染器 re = SDL_RenderCopy(render_, texture_, NULL, prect); if (re) { cout << "copy texture failed" << endl; return false; } // 显示 SDL_RenderPresent(render_); return true; } bool XSDL::Draw(const unsigned char* y, int y_pitch, const unsigned char* u, int u_pitch, const unsigned char* v, int v_pitch ) { if (!y || !u || !v) { cout << "input y, u, v data can not be null" << endl; return false; } // 保证线程同步 unique_lock<mutex> sdl_lock(mtx_); if (!texture_ || !render_ || !win_ || width_ <= 0 || height_ <= 0) { cout << "draw failed, param error" << endl; return false; } // 复制内存到显存 auto re = SDL_UpdateYUVTexture(texture_, NULL, y, y_pitch, // Y u, u_pitch, // U v, v_pitch // V ); if (re) { cout << "update texture failed" << endl; return false; } // 清理渲染器 SDL_RenderClear(render_); // 如果用户手动设置了缩放，就按照用户设置的大小显示 // 如果用户没有设置，就传递null, 采用默认的窗口大小 SDL_Rect* prect = nullptr; if (scale_w_ > 0 || scale_h_ > 0) { SDL_Rect rect; rect.x = 0; rect.y = 0; rect.w = scale_w_; rect.h = scale_h_; prect = ▭ } // 拷贝材质到渲染器 re = SDL_RenderCopy(render_, texture_, NULL, prect); if (re) { cout << "copy texture failed" << endl; return false; } // 显示 SDL_RenderPresent(render_); return true; } void XSDL::Close() { // 保证线程安全 unique_lock<mutex> sdl_lock(mtx_); // 注意!!! 一定要先清理Texture, 再清理Render, 因为Texture是绑定在Render当中的， // 如果先清理render, 再清理Texture, 可能会有问题 if (texture_) { SDL_DestroyTexture(texture_); texture_ = nullptr; } if (render_) { SDL_DestroyRenderer(render_); render_ = nullptr; } if (win_) { SDL_DestroyWindow(win_); win_ = nullptr; } // cout << "do Close()" << endl; } bool XSDL::isExit() { // 创建一个event用于接收事件 SDL_Event ev; SDL_WaitEventTimeout(&ev, 1); // 等待1ms, 避免阻塞 if (ev.type == SDL_QUIT) { return true; } return false; }
二. 需要注意的地方
1. 开启硬件加速的方法
只需要设置解码器的 hw_device_ctx 成员的值即可，比如我这里将该成员的值设置为：
// 开启硬件加速 c->hw_device_ctx = av_buffer_ref(hw_ctx);
2. 硬解码出来的数据可能不是常规的格式
使用DXVA2硬解码出来的数据可能不是常规的YUV420格式，实际测试，硬解码出来的数据格式是： AV_PIX_FMT_DXVA2_VLD 这种格式。比如我在下面的code位置添加了一个断点，可以清楚地看到该数据格式：
注意到解码后的AVFrame中的format的值为53，而53是 AV_PIX_FMT_DXVA2_VLD 这种格式：
3. 从显存复制到内存后,frame的像素格式会变成NV12格式
从显存复制到内存后，像素格式会变成NV12格式：
注意此时的AVFrame中的format的值为23，而23是 AV_PIX_FMT_NV12 格式。
4. 图像的linesize可能在解码后发生改变
图像的linesize在解码后可能会发生改变，这样可能会导致SDL在渲染时发生异常，所以需要额外处理：
switch (frame->format) { case AV_PIX_FMT_YUV420P: return Draw(frame->data[0], frame->linesize[0], // Y frame->data[1], frame->linesize[1], // U frame->data[2], frame->linesize[2] // V ); case AV_PIX_FMT_NV12: if (!cache_) { // 若空间尚未分配，则申请一块较大的空间(4K的一幅图像的大小) cache_ = new unsigned char[4096 * 2160 * 1.5]; } // PS: 注意！这里面涉及到一个内存对齐的问题！ // 如果是400x300的YUV420P/NV12格式，它的linesize很可能会被FFmpeg自动进行字节对齐, 即当图像尺寸为400x300时，它的linesize可能 // 不是400，而是416(假设ffmpeg是以16字节进行对齐) // 而在使用SDL进行渲染时，linesize若传递416，很可能导致渲染出现问题，为了避免出现这种情况，下面提供了一种逐行复制的策略。 // 下面的内存拷贝主要目的是为了让数据是连续的 linesize = frame->width; if (frame->linesize[0] == frame->width) { // ---------------- 若linesize与图像的宽度一致，说明未发生字节对齐 --------------- // 拷贝所有Y分量 memcpy(cache_, frame->data[0], frame->linesize[0] * frame->height); // 拷贝所有的UV分量 memcpy(cache_ + frame->linesize[0] * frame->height, frame->data[1], frame->linesize[1] * frame->height / 2); } else { // ---------------- 若linesize与图像的宽度一致，说明发生了字节对齐 --------------- // 使用逐行拷贝的方式 // 拷贝所有的Y分量 for (int i = 0; i < frame->height; i++) { memcpy(cache_ + i * frame->width, frame->data[0] + i * frame->linesize[0], frame->width // 注意只需要拷贝frame->width个数即可，丢弃因为对齐产生的多余数据 ); } // 拷贝所有UV分量 for (int i = 0; i < frame->height / 2; i++) { // 将指针定位到所有Y分量数据的结尾处，从所有Y分量数据的结尾处开始拷贝UV分量 auto p = cache_ + frame->width * frame->height; memcpy(p + i * frame->width, frame->data[1] + i * frame->linesize[1], frame->width // 注意只需要拷贝frame->width个数即可，丢弃因为对齐产生的多余数据 ); } } return Draw(cache_, linesize); case AV_PIX_FMT_RGBA: case AV_PIX_FMT_BGRA: case AV_PIX_FMT_ARGB: return Draw(frame->data[0], frame->linesize[0]); default: break; } return false; }
