1-5、多线程控制帧率渲染

最新推荐文章于 2022-04-03 22:50:00 发布
最新推荐文章于 2022-04-03 22:50:00 发布
阅读量497 收藏 1
点赞数
分类专栏： 流媒体开发自学笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011090965/article/details/115712862
版权
这篇博客介绍了如何使用XVideoView类库进行视频渲染，该库隐藏了SDL实现并支持线程安全。文章详细展示了XVideoView的接口，包括不同格式的视频帧渲染、工厂模式创建渲染器，以及具体的SDL实现类XSDL。同时，还提供了一个使用Qt的示例，展示如何在Qt应用中集成XVideoView进行视频播放。
摘要由CSDN通过智能技术生成

xvideo_view.h

#pragma once

#include <mutex>

/// <summary>
/// 视频渲染接口
/// 1、隐藏SDL实现
/// 2、渲染方式可替代
/// 3、线程安全
/// </summary>
struct AVFrame;

void MSleep(unsigned int ms);

class XVideoView {
public:
    enum Format {
        RGBA = 0,
        ARGB,
        YUV420P
    };

    // 产品类型
    enum RenderType {
        SDL = 0
    };

    // 工厂类
    static XVideoView* Creat(RenderType type = SDL);
    bool DrawFrame(AVFrame* frame);

    // 抽象产品类
    virtual bool Init(int w, int h, Format fmt = RGBA, void* win_id = nullptr) = 0;
    virtual bool Close() = 0;
    virtual bool IsExit() = 0;
    virtual bool Draw(const unsigned char* data, int linesize = 0) = 0;
    virtual bool Draw(const unsigned char* y, int yPitch, const unsigned char* u, int uPitch, const unsigned char* v, int vPitch) = 0;
    //void Scale(int w, int h)
    //{
    //    scale_w_ = w;
    //    scale_h_ = h;
    //}

    int render_fps() {
        return render_fps_;
    }

protected:
    int width_ = 0;
    int height_ = 0;
    Format fmt_ = RGBA;
    std::mutex mtx_;    //确保线程安全（不在头文件中引入命名空间）
    int scale_w_ = 0;   //显示大小
    int scale_h_ = 0;

    int render_fps_ = 0;
    long beg_ms_ = 0;
    int count_ = 0;

};

xvideo_view.cpp

#include "xvideo_view.h"
#include "xsdl.h"
#include <thread>

using namespace std;

extern "C"
{
#include <libavcodec/avcodec.h>
}
#pragma comment(lib, "avutil.lib")

void MSleep(unsigned int ms)
{
    auto beg = clock();
    for (int i = 0; i < ms; i++) {
        this_thread::sleep_for(1ms);
        if ((clock() - beg) >= ms) {
            break;
        }       
    }
}

int CountFPS() 
{
    static int fps = 0;
    static int lastTime = clock();  // ms
    static int frameCount = 0;

    ++frameCount;

    int currTime = clock();
    if (currTime - lastTime > 1000) { // 取固定时间间隔为1秒
        fps = frameCount;
        frameCount = 0;
        lastTime = currTime;
    }

    return fps;
}

XVideoView* XVideoView::Creat(RenderType type)
{
    switch (type) {
    case XVideoView::SDL:
        return new XSDL();
        break;

    default:
        break;
    }

    return nullptr;
}

bool XVideoView::DrawFrame(AVFrame* frame)
{
    if (!frame || !frame->data[0]) {
        return false;
    }

    render_fps_ = CountFPS();   // 计算帧率

    switch (frame->format)
    {
    case AV_PIX_FMT_YUV420P:
        Draw(frame->data[0], frame->linesize[0],// Y
            frame->data[1], frame->linesize[1],	// U
            frame->data[2], frame->linesize[2]	// V
        );
        break;
    case AV_PIX_FMT_BGRA:
        Draw(frame->data[0], frame->linesize[0]);
        break;
    default:
        break;
    }

    return true;
}

xsdl.h

#pragma once

#include "xvideo_view.h"

struct SDL_Window;
struct SDL_Renderer;
struct SDL_Texture;

// 具体产品类
class XSDL :public XVideoView {
public:
    
    /// 初始化渲染窗口 线程安全
    /// @para w 窗口宽度
    /// @para h 窗口高度
    /// @para fmt 绘制的像素格式
    /// @para win_id 窗口句柄，如果为空，创建新窗口
    /// @return 是否创建成功
    bool Init(int w, int h, Format fmt = RGBA, void* win_id = nullptr) override;
    bool Close() override;
    bool IsExit() override;
    //
    /// 渲染图像 线程安全
    ///@para data 渲染的二进制数据
    ///@para linesize 一行数据的字节数，对于YUV420P就是Y一行字节数
    /// linesize<=0 就根据宽度和像素格式自动算出大小
    /// @return 渲染是否成功
    bool Draw(const unsigned char* data, int linesize = 0) override;
    bool Draw(const unsigned char* y, int yPitch,
        const unsigned char* u, int uPitch,
        const unsigned char* v, int vPitch) override;
private:
    SDL_Window* win_ = nullptr;
    SDL_Renderer* render_ = nullptr;
    SDL_Texture* texture_ = nullptr;
};

xsdl.cpp

#include "xsdl.h"
#include <sdl/SDL.h>
#include <iostream>

using namespace std;

#pragma comment(lib,"SDL2.lib")

static bool InitVideo(string& strError)
{
    static bool bOK = false;

    static mutex mux;
    unique_lock<mutex> sdl_lock(mux);

    if (!bOK) {
        if (SDL_Init(SDL_INIT_VIDEO)) {
            strError = SDL_GetError();
            return false;
        }
    }

    // 设定缩放算法(线性插值)
    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");

    bOK = true;
    return true;
}

bool XSDL::IsExit()
{
    SDL_Event ev;

    SDL_WaitEventTimeout(&ev, 1);
    if (ev.type == SDL_QUIT) {
        return true;
    }

    return false;
}

bool XSDL::Close()
{
    //确保线程安全
    unique_lock<mutex> sdl_lock(mtx_);

    // 依次清理
    if (texture_) {
        SDL_DestroyTexture(texture_);
        texture_ = nullptr;
    }

    if (render_) {
        SDL_DestroyRenderer(render_);
        render_ = nullptr;
    }

    if (win_) {
        SDL_DestroyWindow(win_);
        win_ = nullptr;
    }

    return true;
}

bool XSDL::Init(int w, int h, Format fmt, void* win_id)
{
    string strError = "";

    // 1、初始化视频库
    if (!InitVideo(strError)) {
        return false;
    }

    //确保线程安全
    unique_lock<mutex> sdl_lock(mtx_);
    width_ = w;
    height_ = h;
    fmt_ = fmt;

    if (texture_) {
        SDL_DestroyTexture(texture_);
    }
    if (render_) {
        SDL_DestroyRenderer(render_);
    }

    // 2、创建窗口
    if (!win_) {
        if (win_id) {
            win_ = SDL_CreateWindowFrom(win_id);
            if (!win_) {
                cout << SDL_GetError() << endl;
                return false;
            }
        }
        else {
            win_ = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
                w, h, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
            if (!win_) {
                cout << SDL_GetError() << endl;
                return false;
            }
        }
    }
    // 3、创建渲染器
    render_ = SDL_CreateRenderer(win_, -1, SDL_RENDERER_ACCELERATED);
    if (!render_) {
        cout << SDL_GetError() << endl;
        return false;
    }

    // 4、创建材质
    unsigned int sdl_fmt = SDL_PIXELFORMAT_RGBA8888;
    switch (fmt)
    {
    case XVideoView::RGBA:
        break;
    case XVideoView::ARGB:
        sdl_fmt = SDL_PIXELFORMAT_ARGB32;
        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_) {
        cout << SDL_GetError() << endl;
        return false;
    }

    return true;
}

bool XSDL::Draw(const unsigned char* y, int yPitch, const unsigned char* u, int uPitch, const unsigned char* v, int vPitch)
{
    if (!y || !u || !v) {
        cout << "Data Is Empty!" << endl;
        return false;
    }

    unique_lock<mutex> sdl_lock(mtx_);
    if (!win_ || !render_ || !texture_ || width_ <= 0 || height_ <= 0) {
        cout << "Init Is Fail!" << endl;
        return false;
    }

    // 5、渲染
    if (SDL_UpdateYUVTexture(texture_, NULL,
        y, yPitch, u, uPitch, v, vPitch)) {   // 复制内存数据到显存
        cout << SDL_GetError() << endl;
        return false;
    }

    SDL_RenderClear(render_);

    //材质复制到渲染器
    //if (scale_w_ <= 0)scale_w_ = width_;
    //if (scale_h_ <= 0)scale_h_ = height_;

    SDL_Rect sdl_rect;              // 目标尺寸
    sdl_rect.x = 0;
    sdl_rect.y = 0;
    sdl_rect.w = width_;
    sdl_rect.h = height_;
    if (SDL_RenderCopy(render_, texture_, NULL, &sdl_rect)) {
        cout << SDL_GetError() << endl;
        return false;
    }

    SDL_RenderPresent(render_); // 渲染

    return true;
}

bool XSDL::Draw(const unsigned char* data, int linesize)
{
    if (!data) {
        cout << "Data Is Empty!" << endl;
        return false;
    }

    unique_lock<mutex> sdl_lock(mtx_);
    if (!win_ || !render_ || !texture_ || width_ <= 0 || height_ <= 0) {
        cout << "Init Is Fail!" << endl;
        return false;
    }

    if (linesize <= 0) {
        switch (fmt_)
        {
        case XVideoView::RGBA:
        case XVideoView::ARGB:
            linesize = width_ * 4;
            break;
        case XVideoView::YUV420P:
            linesize = width_ * 1;
            break;
        default:
            break;
        }
    }

    // 5、渲染
    if (SDL_UpdateTexture(texture_, NULL, data, linesize)) {   // 复制到显存
        cout << SDL_GetError() << endl;
        return false;
    }

    SDL_RenderClear(render_);

    //材质复制到渲染器
    //if (scale_w_ <= 0)scale_w_ = width_;
    //if (scale_h_ <= 0)scale_h_ = height_;

    SDL_Rect sdl_rect;              // 目标尺寸
    sdl_rect.x = 0;
    sdl_rect.y = 0;
    sdl_rect.w = width_;
    sdl_rect.h = height_;
    if (SDL_RenderCopy(render_, texture_, NULL, &sdl_rect)) {
        cout << SDL_GetError() << endl;
        return false;
    }

    SDL_RenderPresent(render_); // 渲染

    return true;
}

sdlqtrgb.h

#pragma once

#include <QtWidgets/QWidget>
#include "ui_sdlqtrgb.h"
#include <thread>

class SdlQtRgb : public QWidget
{
    Q_OBJECT

public:
    SdlQtRgb(QWidget* parent = Q_NULLPTR);
    ~SdlQtRgb()
    {
        is_exit_ = true;
        //等待渲染线程退出
        th_.join();
    }
    void timerEvent(QTimerEvent* ev) override;  // 重载定时器
    //void resizeEvent(QResizeEvent* ev) override;

    void threadMain(); // 线程函数，用于刷新视频

private:
    Ui::SdlQtRgbClass ui;
    bool is_exit_ = false;
    std::thread th_;


signals:
    void ViewS();

public slots:
    void View();
};

sdlqtrgb.cpp

#include "sdlqtrgb.h"
#include <fstream>
#include <iostream>
#include <QMessageBox>
#include <thread>
#include <sstream>

#include "xvideo_view.h"

extern "C"
{
#include <libavcodec/avcodec.h>
}

using namespace std;

static int sdl_width = 0;
static int sdl_height = 0;
static int pix_size = 2;

static ifstream yuv_file;
static XVideoView* view = nullptr;
static AVFrame* frame = nullptr;
static long long int fileSize = 0;
static QLabel* view_fps = nullptr;

void SdlQtRgb::timerEvent(QTimerEvent* ev)
{
    //yuv_file.read((char*)yuv, sdl_width * sdl_height * 1.5);
    yuv_file.read((char*)frame->data[0], sdl_width * sdl_height); // Y
    yuv_file.read((char*)frame->data[1], sdl_width * sdl_height / 4); // U
    yuv_file.read((char*)frame->data[2], sdl_width * sdl_height / 4); // U

    if (view->IsExit()) {
        view->Close();
        exit(0);
    }

    view->DrawFrame(frame);
}

void SdlQtRgb::View()
{
    //yuv_file.read((char*)yuv, sdl_width * sdl_height * 1.5);
    yuv_file.read((char*)frame->data[0], sdl_width * sdl_height); // Y
    yuv_file.read((char*)frame->data[1], sdl_width * sdl_height / 4); // U
    yuv_file.read((char*)frame->data[2], sdl_width * sdl_height / 4); // U

    if (fileSize == yuv_file.tellg()) {
        yuv_file.seekg(0, ios::beg);
    }

    if (view->IsExit()) {
        view->Close();
        exit(0);
    }

    view->DrawFrame(frame);

    stringstream s;
    s << "fps:" << view->render_fps();
    view_fps->setText(s.str().c_str());

}

void SdlQtRgb::threadMain()
{
    while(!is_exit_) {
        ViewS();
        MSleep(10);
    }
}

//void SdlQtRgb::resizeEvent(QResizeEvent* ev)
//{
//    ui.label->resize(ui.label->size());
//    ui.label->move(0, 0);
//    view->Scale(ui.label->width(), ui.label->height());
//}

SdlQtRgb::SdlQtRgb(QWidget* parent)
    : QWidget(parent)
{
    // 打开yuv文件
    string file = "400_300_25.yuv";
    yuv_file.open(file.c_str(), ios::binary);
    if (!yuv_file) {
        QMessageBox::information(this, "", "Open yuv failed!");
        return;
    }
    
    yuv_file.seekg(0, ios::end);    // 移动到文件末尾
    fileSize = yuv_file.tellg();
    yuv_file.seekg(0, ios::beg);

    ui.setupUi(this);
    connect(this, SIGNAL(ViewS()), this, SLOT(View()));
    view_fps = new QLabel(this);
    view_fps->setText("fps:100");

    sdl_width = ui.label->width();
    sdl_height = ui.label->height();
    ui.label->resize(sdl_width, sdl_height);

    view = XVideoView::Creat();
    view->Init(sdl_width, sdl_height, XVideoView::YUV420P, (void*)ui.label->winId());

    // 创建YUV空间
    frame = av_frame_alloc();
    frame->width = sdl_width;
    frame->height = sdl_height;
    frame->format = AV_PIX_FMT_YUV420P;

    frame->linesize[0] = sdl_width;       //Y
    frame->linesize[1] = sdl_width / 2;   //U
    frame->linesize[2] = sdl_width / 2;   //V

    int err = av_frame_get_buffer(frame, 0);
    if (err) {
        char* buf = { 0 };
        av_strerror(err, buf, sizeof(buf));
        cerr << buf << endl;
    }

    //startTimer(20);

    th_ = std::thread(&SdlQtRgb::threadMain, this);
}
大张宇
关注
专栏目录
Android图像处理系列：渲染性能优化——GL多线程的使用
邢雪源的专栏
05-28 2457
对于一个相机类应用来说，帧率或者流畅度是最关键的性能指标之一。一般来说，相机类应用因为要对图像数据做美颜、滤镜等处理，对每一帧数据的处理流程都比较长。天天P图的相机滤镜链处理过程也很长，中间包含了非常多步的计算和渲染，相机流处理流程中一帧要经过10~20个滤镜处理，即要调用OpenGL draw call10~20次，还包括了很多CPU阻塞操作，包括CPU计算（人脸检测、手势检测等）、纹理上传和下载等，而且滤镜处理数据还在随着产品需求增加而不断增加。如何在保证产品效果需求不断增加渲染和计算的情况下保证用户使
SDL封装（SDL：二维图形类库）
11-12
SDL 封装 代码 SDL是一个二维图形类库，它跨平台，在LINUX和WINDOWS都能使用
1-4、封装SDL
大张宇的博客
04-14 433
用简单工厂模式封装SDL 1、隐藏SDL的实现 2、渲染方式可替代 3、线程安全 xvideo_view.h #pragma once #include <mutex> /// <summary> /// 视频渲染接口 /// 1、隐藏SDL实现 /// 2、渲染方式可替代 /// 3、线程安全 /// </summary> class XVideoView { public: enum Format { RGBA = 0, A
SDL游戏开发教程04(C++封装SDL)
iteye_1667的博客
12-12 627
    前面的章节介绍了一个简单窗口的开发，这节将介绍如何把前面用到的东西用C++封装起来。       为什么用C++封装起来： 1、C语言没有异常机制，每次调用一个函数都需要通过检查返回值来判断是否成功，比较麻烦。 2、对我个人而言，开发效率上C++要优于C语言，并且C++的代码要容易组织管理，写出来的代码也更容易理解。       封装的主要部分： 1、将所有的SDL函数都用类包装起来，对于...
[笔记]音视频学习之SDL篇《七》用类封装SDL
二次元怪兽的博客
05-21 282
第七节：充分利用类 文章目录
大恒-双相机开发-C#-多线程-项目开源
08-22
本项目"大恒-双相机开发-C#-多线程"正是这样的一个实例，它利用C#语言进行编程，实现了对两台大恒相机的同时控制和数据采集，同时运用了多线程技术，极大地提高了系统的响应速度和处理能力。下面我们将详细探讨该...
网络游戏-一种动态控制游戏帧率的方法.zip
09-20
8. **多线程优化**：游戏引擎可能利用多线程技术，将计算任务分散到多个处理器核心，以提高帧率并保持游戏流畅。 9. **渲染优化**：通过降低渲染质量、减少特效等方式，可以在保证游戏基本视觉效果的同时，降低帧率...
cocos2d-x多线程
06-18
多线程允许开发者同时执行多个任务，如更新游戏逻辑、渲染图形以及处理用户输入，这有助于避免程序阻塞，提高用户体验。 在Cocos2d-x中，多线程的使用主要有以下几个方面： 1. **渲染线程**：Cocos2d-x默认使用一...
Cocos2d-x 中使用多线程
08-11
在Cocos2d-x游戏引擎中，多线程的使用是一项关键的技术，它能帮助开发者实现游戏的异步处理，提高程序的响应速度和效率。本文将深入探讨Cocos2d-x中如何创建和管理多线程。 首先，我们要了解线程的基本概念。线程是...
sdl封装半成品
11-29
很好用正在做，想做的像qt一样
SDL２ c#封装库
10-24
SDL2在C#中的封装库，包含- SDL2 - SDL2_image - SDL2_mixer - SDL2_ttf
第八课：SDL的简单封装——实现一个图片旋转
OAD工作室－计算机技术的研究与分享
12-26 902
SDL2本身并没有对Window进行封装，这样的好处可以给使用者更大的灵活性，但是我们在写程序的时候，基本上都是面向对象的，所以做这种封装是很有必要的，一下是原作者对其进行的一个封装。 window07.h /* SDL Window的一个封装 */ class Window07 { public: /* 初始化SDL，并且设置标题 */ static vo
SDL2系列教程12-类封装SDL_Timer
cyf15238622067的博客
10-08 824
为方便使用SDL的定时器，实现了类封装： 代码如下 time.h: #pragma once #include &lt;map&gt; #include &lt;string&gt; #include &lt;SDL.h&gt; class timer { timer(Uint64 s, Uint64 p, bool perf); ~timer(); Ui...
SDL2源代码分析3：渲染器（SDL_Renderer）
热门推荐
雷霄骅(leixiaohua1020)的专栏
11-04 3万+
上一篇文章分析了SDL中创建窗口的函数SDL_CreateWindow()。这篇文章继续分析SDL的源代码。本文分析SDL的渲染器（SDL_Renderer）。
SDL多线程渲染YUV视频
weixin_49406295的博客
11-28 813
目录 #include <stdio.h> #include <string.h> #include <SDL.h> //自定义消息类型 #define REFRESH_EVENT (SDL_USEREVENT + 1) // 请求画面刷新事件 #define QUIT_EVENT (SDL_USEREVENT + 2) // 退出事件 //定义分辨率 // YUV像素分辨率 #define YUV_WIDTH 320 #defin
多线程控制帧率渲染AVFrame的YUV数据
qq_52484093的博客
04-03 1646
代码 XVideoView.cpp void MSleep(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; } } } bool XVideoView::drawAVFrame(AVFrame* fra
封装SDL2实现一个窗口类
weixin_45295931的博客
09-10 831
使用SDL2创建一个灵活的窗口类 接着上篇的游戏引擎设计，这一片主要讲讲实现一个灵活的窗口程序。现在桌面游戏由2D视角和3D视角两大块，通常2D游戏使用COCOS引擎来开发，而3D游戏则是使用DX或OpenGL这些图形库开发，既然我们是自己实现游戏引擎，那么我们就坑定要自己造轮子。很不错的是，SDL同时提供了2D和3D的支持。 我们创建一个2D游戏需要一个2D的渲染器，而3D游戏使用的是3D渲染器。在SDL中，2D渲染器由SDL_Renderer实现，而3D渲染器则添加OPENGL支持。为了实现灵活的窗口，
5116-微信小程序电影院订票选座系统设计及实现+ssm（源码+数据库+lun文）.zip
最新发布
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
OSG多线程渲染设计与实时图形优化
"OSG多线程设计原理介绍，含有很多框图说明；多任务，多显示，单系统绘图的传统方法" 在图形渲染领域，OpenSceneGraph (OSG) 是一个强大的开源库，用于创建复杂的3D应用程序。在多线程设计中，OSG允许开发者利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值