FFmpeg+qt实现的播放器解析（三）

最新推荐文章于 2022-10-24 08:00:54 发布
最新推荐文章于 2022-10-24 08:00:54 发布
阅读量492 收藏 1
点赞数 1
分类专栏： 视音频 文章标签： ffmpeg qt c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42503022/article/details/103274423
版权

项目下载地址：https://download.csdn.net/download/qq_42503022/12000297

FFmpeg+qt实现的播放器解析（一）
FFmpeg+qt实现的播放器解析（二）
FFmpeg+qt实现的播放器解析（三）
FFmpeg+qt实现的播放器解析（四）

这一张主要说明如何把视音频分开来解码的，先说一下他们的基类XDecodeThread

这里使用了消息队列的方式来存储解封装的包，使用list 实现存储 主要实现了 push()入栈 ,pop()出栈，两个方法

头文件：

#pragma once
///解码和显示视频
struct AVPacket;
class XDecode;
#include <list>
#include <mutex>
#include <QThread>
class XDecodeThread:public QThread
{
public:
	XDecodeThread();
	virtual ~XDecodeThread();
	virtual void Push(AVPacket *pkt);
	//清理队列
	virtual void Clear();
	//清理资源，停止线程
	virtual void Close();
	//取出一帧数据，并出栈，如果没有返回NULL
	virtual AVPacket *Pop();
	//最大队列
    int maxList = 100;
	bool isExit = false;  
    XDecode *decode = 0;
protected:	
	std::list <AVPacket *> packs;
	std::mutex mux;
};

源文件：

#include "XDecodeThread.h"
#include "XDecode.h"

//清理资源，停止线程
void XDecodeThread::Close()
{
	Clear();
	
	//等待线程退出
	isExit = true;
	wait();
	decode->Close();

	mux.lock();
	delete decode;
	decode = NULL;
	mux.unlock();
}
void XDecodeThread::Clear()
{
	mux.lock();
	decode->Clear();
	while (!packs.empty())
	{
		AVPacket *pkt = packs.front();
		XFreePacket(&pkt);
		packs.pop_front();
	}

	mux.unlock();
}
//取出一帧数据，并出栈，如果没有返回NULL
AVPacket *XDecodeThread::Pop()
{
	mux.lock();
	if (packs.empty())
	{
		mux.unlock();
		return NULL;
	}
	AVPacket *pkt = packs.front();
	packs.pop_front();
	mux.unlock();
	return pkt;
}
void XDecodeThread::Push(AVPacket *pkt)
{
	if (!pkt)return;
	//阻塞
	while (!isExit)
	{
		mux.lock();
		if (packs.size() < maxList)
		{
			packs.push_back(pkt);
			mux.unlock();
			break;
		}
		mux.unlock();
		msleep(1);
	}
}
XDecodeThread::XDecodeThread()
{
	//打开解码器
	if (!decode) decode = new XDecode();
}
XDecodeThread::~XDecodeThread()
{	//等待线程退出
	isExit = true;
	wait();
}

XVideoThread 类视频解码线程 继承 XDecodeThread
头文件：

#pragma once

///解码和显示视频
struct AVPacket;
struct AVCodecParameters;
class XDecode;
#include <list>
#include <mutex>
#include <QThread>
#include "IVideoCall.h"
#include "XDecodeThread.h"
class XVideoThread:public XDecodeThread
{
public:

	//解码pts，如果接收到的解码数据pts >= seekpts return true 并且显示画面
	virtual bool RepaintPts(AVPacket *pkt, long long seekpts);
	//打开，不管成功与否都清理
	virtual bool Open(AVCodecParameters *para,IVideoCall *call,int width,int height);
	void run();
	XVideoThread();
	virtual ~XVideoThread();
	//同步时间，由外部传入
	long long synpts = 0;
   // long long  seeks = 0;

	void SetPause(bool isPause);
	bool isPause = false;
protected:
	IVideoCall *call = 0;
	std::mutex vmux;
};

源文件：

#include "XVideoThread.h"
#include "XDecode.h"
#include <iostream>

extern "C"
{
#include<libavcodec/avcodec.h>
}
using namespace std;
//????????????????????????????????????
bool XVideoThread::Open(AVCodecParameters *para, IVideoCall *call,int width,int height)
{
    if (!para)return false;
    Clear();

    vmux.lock();
    synpts = 0;
    //????????????????????????
    this->call = call;
    if (call)
    {
        call->Init(width, height);
    }
    vmux.unlock();
    int re = true;
    if (!decode->Open(para))
    {
        cout << "audio XDecode open failed!" << endl;
        re = false;
    }

    cout << "XAudioThread::Open :" << re << endl;
    return re;
}
void XVideoThread::SetPause(bool isPause)
{
    vmux.lock();
    this->isPause = isPause;
    vmux.unlock();
}
void XVideoThread::run()
{
    while (!isExit)
    {
        vmux.lock();
        if (this->isPause)
        {
            vmux.unlock();
            msleep(5);
            continue;
        }
        cout << "synpts = " << synpts << " dpts =" << decode->pts << endl;
        //视音频同步
        if (synpts >0 && synpts < decode->pts)
        {
            vmux.unlock();
            msleep(1);
          continue;
        }

        AVPacket *pkt = Pop();
        bool re = decode->Send(pkt);
        if (!re)
        {
            vmux.unlock();
            msleep(5);
            continue;
        }
        //接收frame
        while (!isExit)
        {
            AVFrame * frame = decode->Recv();
            if (!frame)break;
            //显示视频
            if (call)
            {
                call->Repaint(frame);
            }

        }
        vmux.unlock();
    }
}
//????????pts????????????????????????????????????????pts >= seekpts return true ??????????????????????
bool XVideoThread::RepaintPts(AVPacket *pkt, long long seekpts)
{
    vmux.lock();
    bool re = decode->Send(pkt);
    if (!re)
    {
        vmux.unlock();
        return true; //??????????????????????
    }
    AVFrame *frame = decode->Recv();
    if (!frame)
    {
        vmux.unlock();
        return false;
    }
    //????????λ????
    if (decode->pts >= seekpts)
    {
        if(call)
            call->Repaint(frame);
        vmux.unlock();
        return true;
    }
    XFreeFrame(&frame);
    vmux.unlock();
    return false;
}

XAudioThread 类音频解码线程同样继承XDecodeThread

头文件：

#pragma once
#include <QThread>
#include <mutex>
#include <list>
struct AVCodecParameters;
class XAudioPlay;
class XResample;
#include "XDecodeThread.h"
class XAudioThread:public XDecodeThread
{
public:
	//当前音频播放的pts
	long long pts = 0;
	//打开，不管成功与否都清理
	virtual bool Open(AVCodecParameters *para,int sampleRate,int channels);

	//停止线程，清理资源
	virtual void Close();

	virtual void Clear();
	void run();
	XAudioThread();
	virtual ~XAudioThread();
	void SetPause(bool isPause);
	bool isPause = false;
     double audio_clock; ///音频时钟
protected:
	std::mutex amux;
	XAudioPlay *ap = 0;
	XResample *res = 0;
};

源文件

#include "XAudioThread.h"
#include "XDecode.h"
#include "XAudioPlay.h"
#include "XResample.h"
#include <iostream>
extern "C"
{
#include<libavcodec/avcodec.h>
}
using namespace std;
void XAudioThread::Clear()
{
    XDecodeThread::Clear();
    mux.lock();
    if (ap) ap->Clear();
    mux.unlock();
}
//停止线程，清理资源
void XAudioThread::Close()
{
    XDecodeThread::Close();
    if (res)
    {
        res->Close();
        amux.lock();
        delete res;
        res = NULL;
        amux.unlock();
    }
    if (ap)
    {
        ap->Close();
        amux.lock();
        ap = NULL;
        amux.unlock();
    }
}
bool XAudioThread::Open(AVCodecParameters *para,int sampleRate, int channels)
{
    if (!para)return false;
    Clear();
    amux.lock();
    pts = 0;
    bool re = true;
    if (!res->Open(para, false))
    {
        cout << "XResample open failed!" << endl;
        re = false;
    }
    ap->sampleRate = sampleRate;
    ap->channels = channels;
    if (!ap->Open())
    {
        re = false;
        cout << "XAudioPlay open failed!" << endl;
    }
    if (!decode->Open(para))
    {
        cout << "audio XDecode open failed!" << endl;
        re = false;
    }
    amux.unlock();
    cout << "XAudioThread::Open :" << re << endl;
    return re;
}
void XAudioThread::SetPause(bool isPause)
{
    //amux.lock();
    this->isPause = isPause;
    if (ap)
        ap->SetPause(isPause);
    //amux.unlock();
}
void XAudioThread::run()
{
    unsigned char *pcm = new unsigned char[1024 * 10];
    while (!isExit)
    {
        amux.lock();
        if (isPause)
        {
            amux.unlock();
            msleep(5);
            continue;
        }

        //没有数据
        //if (packs.empty() || !decode || !res || !ap)
        //{
        //	mux.unlock();
        //	msleep(1);
        //	continue;
        //}

        //AVPacket *pkt = packs.front();
        //packs.pop_front();
        AVPacket *pkt = Pop();
        if ( pkt !=nullptr && pkt->pts != AV_NOPTS_VALUE)
        {
            audio_clock = pkt->pts;
        }

        bool re = decode->Send(pkt);
        if (!re)
        {
            amux.unlock();
            msleep(1);
            continue;
        }
        //一次send 多次recv
        while (!isExit)
        {
            AVFrame * frame = decode->Recv();
            if (!frame) break;

            //减去缓冲中未播放的时间
            pts = decode->pts - ap->GetNoPlayMs();

            cout << "audio pts = " << pts << endl;

            //重采样
            int size = res->Resample(frame, pcm);
            //播放音频
            while (!isExit)
            {
                if (size <= 0)break;
                //缓冲未播完，空间不够
                int nn=  ap->GetFree();
                if (ap->GetFree() < size || isPause)
                {
                    msleep(5);
                    continue;
                }
                ap->Write(pcm, size);
                break;
            }
        }
        amux.unlock();
    }
    delete pcm;
}

XAudioThread::XAudioThread()
{
    if (!res) res = new XResample();
    if (!ap) ap = XAudioPlay::Get();
}
XAudioThread::~XAudioThread()
{
    //等待线程退出
    isExit = true;
    wait();
}

XDemuxThread 类 对XDemux，XVideoThread，XAudioThread，的调用
头文件：

#pragma once
#include <QThread>
#include "IVideoCall.h"
#include <mutex>
class XDemux;
class XVideoThread;
class XAudioThread;

class XDemuxThread:public QThread
{
public:
	//创建对象并打开
	virtual bool Open(const char *url, IVideoCall *call);
	//启动所有线程
	virtual void Start();
	//关闭线程清理资源
	virtual void Close();
	virtual void Clear();

	virtual void Seek(double pos);
    //获取播放时长
    QString PlayTime();
	void run();
    //获取视频总时长
    int  GetTotalMs();
	XDemuxThread();
	virtual ~XDemuxThread();
 public:
	bool isExit = false;
	long long pts = 0;
	long long totalMs = 0;
	void SetPause(bool isPause);
    bool isPause = false;
    XDemux *demux = 0;
protected:
	std::mutex mux;	
    XVideoThread *vt = 0;
	XAudioThread *at = 0;
};

源文件：

#include "XDemuxThread.h"
#include "XDemux.h"
#include "XVideoThread.h"
#include "XAudioThread.h"
#include <iostream>
extern "C"
{
#include <libavformat/avformat.h>
}
#include "XDecode.h"

using namespace std;
void XDemuxThread::Clear()
{
    mux.lock();
    if (demux)demux->Clear();
    if (vt) vt->Clear();
    if (at) at->Clear();
    mux.unlock();
}

QString XDemuxThread::PlayTime()
{
    mux.lock();
    if(demux !=nullptr && demux->ic != nullptr && demux->ic->streams[demux->videoStream] != nullptr)
    { 
   double  d=av_q2d(demux->ic->streams[demux->audioStream]->time_base);
       double pts1 = at->audio_clock*d;
        int hour =(int)pts1/60/60%60;
        int min = (int)pts1/60%60;
        int sec = (int)pts1%60;
         char buf[1024] = { 0 };
         sprintf(buf, "%02d:%02d:%02d",hour, min, sec);
        mux.unlock();
        return  (QString)buf;
    }
    mux.unlock();
    return nullptr;
}

void XDemuxThread::Seek(double pos)
{
    //清理缓存
    Clear();

    mux.lock();
    bool status = this->isPause;
    mux.unlock();
    //暂停
    SetPause(true);

    mux.lock();
    if (demux)
        demux->Seek(pos);
    //实际要显示的位置pts
    long long seekPts = pos*demux->totalMs;
    while (!isExit)
    {
        AVPacket *pkt = demux->ReadVideo();
        if (!pkt) break;
        //如果解码到seekPts
        if (vt->RepaintPts(pkt, seekPts))
        {
            this->pts = seekPts;
            break;
        }          
    }
    mux.unlock();

    //seek是非暂停状态
    if(!status)
        SetPause(false);
}
void XDemuxThread::SetPause(bool isPause)
{
    mux.lock();
    this->isPause = isPause;
    if (at) at->SetPause(isPause);
    if (vt) vt->SetPause(isPause);
    mux.unlock();
}
void XDemuxThread::run()
{
    while (!isExit)
    {
        mux.lock();
        if (isPause)
        {
            mux.unlock();
            msleep(5);
            continue;
        }
        if (!demux)
        {
            mux.unlock();
            msleep(5);
            continue;
        }
        //音视频同步
        if (vt && at)
        {
            pts = at->pts;
            vt->synpts = at->pts;
        }
        AVPacket *pkt = demux->Read();
        if (!pkt)
        {
            mux.unlock();
            msleep(5);
            continue;
        }
        //判断数据是音频
        if (demux->IsAudio(pkt))
        {
            //while (at->IsFull())
            {
                //	vt->synpts = at->pts;
            }
            if(at)at->Push(pkt);
        }
        else //视频
        {
            //while (vt->IsFull())
            //{
            //	vt->synpts = at->pts;
            //}
            if (vt)vt->Push(pkt);
        }
        mux.unlock();
        msleep(1);
    }
}
bool XDemuxThread::Open(const char *url, IVideoCall *call)
{
    if (url == 0 || url[0] == '\0')
        return false;

    mux.lock();
    if (!demux) demux = new XDemux();
    if (!vt) vt = new XVideoThread();
    if (!at) at = new XAudioThread();

    //打开解封装
    bool re = demux->Open(url);
    if (!re)
    {
        mux.unlock();
        cout << "demux->Open(url) failed!" << endl;
        return false;
    }
    //打开视频解码器和处理线程
    if (!vt->Open(demux->CopyVPara(), call, demux->width, demux->height))
    {
        re = false;
        cout << "vt->Open failed!" << endl;
    }
    //打开音频解码器和处理线程
    if (!at->Open(demux->CopyAPara(), demux->sampleRate, demux->channels))
    {
        re = false;
        cout << "at->Open failed!" << endl;
    }
    totalMs = demux->totalMs;
    mux.unlock();

    cout << "XDemuxThread::Open " << re << endl;
    return re;
}
//关闭线程清理资源
void XDemuxThread::Close()
{
    isExit = true;
    wait();
    if (vt) vt->Close();
    if (at) at->Close();
    mux.lock();
    delete vt;
    delete at;
    vt = NULL;
    at = NULL;
    mux.unlock();
}
//启动所有线程
void XDemuxThread::Start()
{
    mux.lock();
    if (!demux) demux = new XDemux();
    if (!vt) vt = new XVideoThread();
    if (!at) at = new XAudioThread();
    //启动当前线程
    QThread::start();
    if (vt)vt->start();
    if (at)at->start();
    mux.unlock();
}
int XDemuxThread::GetTotalMs()
{
   return demux->totalMs;
}
XDemuxThread::XDemuxThread()
{
}
XDemuxThread::~XDemuxThread()
{
    isExit = true;
    wait();
}

FFmpeg+qt实现的播放器解析（一）
FFmpeg+qt实现的播放器解析（二）
FFmpeg+qt实现的播放器解析（三）
FFmpeg+qt实现的播放器解析（四）

利用ffmpeg在Qt环境下开发的视频播放器
02-26
Windows环境下，利用编码器ffmpeg在Qt下开发的视频播放器，里面加入了声音输出。供大家参考
(三) FFmpeg结合Qt实现视频播放器(一)
simon曦的博客
01-24 5546
目录 目录 前言 总结 参考链接 前言 总结 参考链接
学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程-夏曹俊-专题视频课程
老夏课堂-夏曹俊的技术专栏
04-27 1416
OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频培训课程概况：教程中会讲解到基于opencv视频和摄像机录制、播放和播放进度控制，多视频图像合并、多视频图像融合、剪切、视频亮度、对比度、尺寸（近邻插值（手动实现），双线性插值，图像金字塔）、颜色格式（灰度图，二值化（阈值）），旋转镜像，视频裁剪（ROI），视频水印（ROI+weight），导出处理后的视频（包含音频，使用ffmpeg工...
ffplaylist:只需使用FFMpeg即可流式播放动态播放列表
05-02
ffplaylist 只需使用FFMpeg即可流式传输动态播放列表。 例如，您有一个包含音频文件的目录。 您想将其流式传输到某些服务器。 python3 random_files.py 'music/*.m4a' | python3 ffplaylist.py -vv -p -- -vn -c:a copy -content_type audio/aac -password hackme icecast://10.0.0.2:9000/music.aac usage: ffplaylist.py [-h] [-e FFMPEG] [-v] [-p] ... FFMpeg dynamic playlist input. Feed stdin with your list of media files. positional arguments: args
【Qt+FFMPEG】 - 封装 解码音视频 线程
m0_60259116的博客
09-27 474
封装 解码音视频 线程
Qt+FFMPEG+SDL实现的视频播放器
03-08
**Qt+FFMPEG+SDL实现的视频播放器** 在软件开发中，创建一个功能完备的视频播放器是一项挑战，但结合Qt、FFmpeg和SDL（Simple DirectMedia Layer）库，我们可以构建出一个高效且跨平台的解决方案。下面将详细阐述这...
FFmpeg+qt实现的播放器工程
11-27
FFmpeg+Qt实现的播放器工程是一个集成的多媒体播放器项目，主要利用FFmpeg库进行视频和音频处理，结合Qt框架构建用户界面和媒体播放功能。这个项目涉及到多个技术领域，包括视频解封装、解码、OpenGL视频渲染、音频...
ffmpeg+QT+多线程视频播放器
06-13
通过这个项目，开发者可以深入理解多媒体处理的基本原理，以及如何在实际应用中结合 FFmpeg 和 QT 实现一个功能齐全的视频播放器。同时，多线程编程的实践经验对于提升软件开发技能也非常有帮助。
基于Qt+FFmpeg设计的视频播放器(SDL输出音频)
02-14
【标题】"基于Qt+FFmpeg设计的视频播放器(SDL输出音频)"的实现与解析 在数字媒体领域，开发一个跨平台的视频播放器是一项常见的任务。本项目使用了Qt库作为用户界面框架，结合FFmpeg进行视频解码，并利用SDL2.0处理...
qt+ffmpeg实现的视频播放器
最新发布
01-30
**Qt + FFmpeg 实现的视频播放器** 在IT领域，开发一款视频播放器是一项常见的任务，这通常涉及到多媒体处理、图形用户界面设计以及编解码技术。在本项目中，“qt+ffmpeg实现的视频播放器”就是这样一个结合了Qt...
FFMpeg-4、基于QtCreat开发使用FFMpeg解码后QTAudio和QTOpenGL播放显示
zw1996的博客
03-16 599
一、基本分析 目前实现的第一个版本 之后进行改进和优化，第一个版本主要实现内容有； 1、读取视频文件使用ffmpeg进行解码、音频重采样得到的数据 2、基于qt提供的QAudioFormat进行音频播放，QTOpenGL进行视频播放 3、qt界面管理设计了打开文件(考虑多次打开) ，暂停(考虑缓冲，音频存在三个缓冲 解码的缓冲队列，播放QAudioOutput的自带缓冲，QIODevice的硬件设备缓冲) ，以及滑动条的拖动(涉及qt自带滑动条点击每次只能移动一下进行重载实现点击在哪进度就移动到哪里) 最后
FFmpeg基础:音视频同步播放
yang1fei2的博客
10-24 2516
视频文件解复用之后视频流和音频流是独立的，也是独立播放。由于压缩方式不同，数据格式不同，在播放的时候音频流输出是线性的而视频流输出不是线程的，这就会导致视频流和音频流的时间偏差越来越大，最终导致音视频不同步。
基于ffmpeg和SDL的音视频播放器
agentky的博客
05-30 380
基于ffmpeg和SDL的音视频播放器 花了挺长时间给代码加了超级详细的注释 实现的功能：音视频同步播放 一.播放器的多线程模型 本文从播放器的多线程的模型开始分析播放器的源码 1.主线程 我们的设计思路是主线程不添加过多的业务逻辑，专注于SDL事件的响应，提高用户的响应速度 ​ 首先要介绍一个超级重要的结构体VidoeState，这里面存放了视频文件的信息（上下文、解码器、各种参数等）和写代码过程中要使用的数据结构（队列、index、锁等），这个结构体要作为函数参数把各个线程串起来。 主线程首先做了一些初
基于qt和ffmpeg视频播放器开发实战
11-09
ffmpeg是世界上应用广的开源视频处理框架，在各个平台（windows，linux，嵌入式、Android、IOS）被广泛应用，可以说是做视频相关项目技能qt是目前跨平台项目界面开发的第一选择，本课程基于这两种框架在加上VC++，给大家讲解延时如何开发出一个视频播放器，各个模块如何结合，如何考虑性能问题，如何设计封装类，如何处理各种异常情况。
【Qt学习】OpenCV帧差法 车辆识别
m0_56051805的博客
08-03 1747
【Qt学习】OpenCV帧差法 车辆识别
使用QT编写视频播放器总结
weixin_45741779的博客
12-10 1900
本文是关于基于QMediaPlayer的播放器的总结，一开始我的想法就是想用opencv做一个视频播放器，因为opencv平时用的也比较顺手，但是花了半天的时间实际一做才知道事情没那么简单，首先使用opencv加载本地视频文件到界面上就花了不少时间，在使用qt播放opencv传过来的视频的时候播放的基本原理还是没变，仍然是一帧一帧的连续输出就形成了视频。但是这个地方有好几个要注意的地方，首先，opencv自带的waikey函数在qt里面不能用，因为本身waikey函数在opencv播放视频时是用来设置帧间的
基于qt和ffmpeg视频播放器开发实战-夏曹俊-专题视频课程
老夏课堂-夏曹俊的技术专栏
11-09 2441
ffmpeg是世界上应用广的开源视频处理框架，在各个平台（windows，linux，嵌入式、Android、IOS）被广泛应用，可以说是做视频相关项目技能 qt是目前跨平台项目界面开发的第一选择，本课程基于这两种框架在加上VC++，给大家讲解延时如何开发出一个视频播放器，各个模块如何结合，如何考虑性能问题，如何设计封装类，如何处理各种异常情况。...
qt+ffmpeg+sdl
06-23
其中Qt可以提供图形用户界面的支持，FFmpeg可以处理媒体文件的编码、解码、转换等操作，SDL可以提供多媒体的播放和输入等功能，三者协同使用可以很好地实现多媒体应用程序的开发。 例如，可以利用Qt的GUI设计界面，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值