FFmpeg+QT5.9环境搭建,以及音频采集和视频采集示例

最新推荐文章于 2024-08-03 17:01:57 发布
最新推荐文章于 2024-08-03 17:01:57 发布
阅读量1.2k 收藏 5
点赞数
文章标签： ffmpeg 音频采集 视频采集 qt绘制yuv图片
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suoge3331/article/details/95045717
版权
  1. FFmpeg库下载,也可以自己编译,https://ffmpeg.zeranoe.com/builds/
  2. QT5.9下载,http://download.qt.io/archive/qt/5.9/

安装完成之后就可以开始编写第一个程序了
创建一个qt工程,添加头文件和库就可以了
1.在.pro中添加需要用到的库,下面是我用到的,大家可以酌情添加

INCLUDEPATH += D:\global_dev\ffmpeg\include
LIBS += -LD:\global_dev\ffmpeg\lib -lavcodec
LIBS += -LD:\global_dev\ffmpeg\lib -lavdevice
LIBS += -LD:\global_dev\ffmpeg\lib -lavfilter
LIBS += -LD:\global_dev\ffmpeg\lib -lavformat
LIBS += -LD:\global_dev\ffmpeg\lib -lavutil
LIBS += -LD:\global_dev\ffmpeg\lib -lswscale
LIBS += -LD:\global_dev\ffmpeg\lib -lswresample

2.包含对应的头文件

extern "C" {
#include "libavformat/avformat.h"
#include "libavutil/time.h"
#include "libavutil/opt.h"
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libavutil/audio_fifo.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
}

这是我用到的头文件,以为ffmpeg使用c语言开发,所以头文件需要使用extern “c”

3.音视频采集代码

AVInputStream.h

#ifndef AVINPUTSTREAM_H
	#define AVINPUTSTREAM_H
	#include "av.h"
	#include <string>
	#include <mutex>
	using namespace std;

	typedef int (* VideoCaptureCB)(AVStream * input_st, enum AVPixelFormat pix_fmt, AVFrame *pframe, __int64 lTimeStamp);
	typedef int (* AudioCaptureCB)(AVStream * input_st, AVFrame *pframe, __int64 lTimeStamp);

	class CAVInputStream
	{
	public:
   		 CAVInputStream(void);
    	~CAVInputStream(void);

	public:
    	void  SetVideoCaptureDevice(string device_name);
   	 	void  SetAudioCaptureDevice(string device_name);
    	bool  OpenInputStream();
   	 	void  CloseInputStream();
    	bool  StartCapture();
    	void  SetVideoCaptureCB(VideoCaptureCB pFuncCB);
    	void  SetAudioCaptureCB(AudioCaptureCB pFuncCB);
    	bool  GetVideoInputInfo(int & width, int & height, int & framerate, AVPixelFormat & pixFmt);
    	bool  GetAudioInputInfo(AVSampleFormat & sample_fmt, int & sample_rate, int & channels);

	protected:
    	int  ReadVideoPackets();
    	int  ReadAudioPackets();

	protected:
    	string  m_video_device;
   	 	string  m_audio_device;
    	int     m_videoindex;
    	int     m_audioindex;
    	AVFormatContext *m_pVidFmtCtx;
    	AVFormatContext *m_pAudFmtCtx;
    	AVInputFormat  *m_pInputFormat;
    	AVPacket *dec_pkt;
    	bool   m_exit_thread; //退出线程的标志变量
    	VideoCaptureCB  m_pVideoCBFunc; //视频数据回调函数指针
    	AudioCaptureCB  m_pAudioCBFunc; //音频数据回调函数指针
    	mutex m_mutex;
    	int64_t     m_start_time; //采集的起点时间
	};

	#endif

AVInputStream.cpp

    #include "AVInputStream.h"
#include <Windows.h>
#include <assert.h>
#include <QDebug>
#include <thread>

static std::string AnsiToUTF8(const char *_ansi, int _ansi_len)
{
    std::string str_utf8("");
    wchar_t* pUnicode = NULL;
    BYTE * pUtfData = NULL;
    do
    {
        int unicodeNeed = MultiByteToWideChar(CP_ACP, 0, _ansi, _ansi_len, NULL, 0);
        pUnicode = new wchar_t[unicodeNeed + 1];
        memset(pUnicode, 0, (unicodeNeed + 1)*sizeof(wchar_t));
        int unicodeDone = MultiByteToWideChar(CP_ACP, 0, _ansi, _ansi_len, (LPWSTR)pUnicode, unicodeNeed);

        if (unicodeDone != unicodeNeed)
        {
            break;
        }

        int utfNeed = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pUnicode, unicodeDone, (char *)pUtfData, 0, NULL, NULL);
        pUtfData = new BYTE[utfNeed + 1];
        memset(pUtfData, 0, utfNeed + 1);
        int utfDone = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pUnicode, unicodeDone, (char *)pUtfData, utfNeed, NULL, NULL);

        if (utfNeed != utfDone)
        {
            break;
        }
        str_utf8.assign((char *)pUtfData);
    } while (false);

    if (pUnicode)
    {
        delete[] pUnicode;
    }
    if (pUtfData)
    {
        delete[] pUtfData;
    }

    return str_utf8;
}

CAVInputStream::CAVInputStream(void)
{
    m_exit_thread = false;
    m_pVidFmtCtx = NULL;
    m_pAudFmtCtx = NULL;
    m_pInputFormat = NULL;
    dec_pkt = NULL;
    m_pVideoCBFunc = NULL;
    m_pAudioCBFunc = NULL;
    m_videoindex = -1;
    m_audioindex = -1;
    m_start_time = 0;
}

CAVInputStream::~CAVInputStream(void)
{
    CloseInputStream();
}


void  CAVInputStream::SetVideoCaptureCB(VideoCaptureCB pFuncCB)
{
    m_pVideoCBFunc = pFuncCB;
}

void  CAVInputStream::SetAudioCaptureCB(AudioCaptureCB pFuncCB)
{
    m_pAudioCBFunc = pFuncCB;
}

void  CAVInputStream::SetVideoCaptureDevice(string device_name)
{
    m_video_device = device_name;
}

void  CAVInputStream::SetAudioCaptureDevice(string device_name)
{
    m_audio_device = device_name;
}


bool  CAVInputStream::OpenInputStream()
{
    if(m_video_device.empty() && m_audio_device.empty())
    {
        qDebug("you have not set any capture device \n");
        return false;
    }

    int i;

    //打开Directshow设备前需要调用FFmpeg的avdevice_register_all函数，否则下面返回失败
    m_pInputFormat = av_find_input_format("dshow");
    assert(m_pInputFormat != NULL);

    // Set device params
    AVDictionary *device_param = 0;
    //if not setting rtbufsize, error messages will be shown in cmd, but you can still watch or record the stream correctly in most time
    //setting rtbufsize will erase those error messages, however, larger rtbufsize will bring latency
    //av_dict_set(&device_param, "rtbufsize", "10M", 0);

    if(!m_video_device.empty())
    {
        int res = 0;

        string device_name = "video=" + m_video_device;

        string device_name_utf8 = AnsiToUTF8(device_name.c_str(), device_name.length());  //转成UTF-8，解决设备名称包含中文字符出现乱码的问题

         //Set own video device's name
        if ((res = avformat_open_input(&m_pVidFmtCtx, device_name_utf8.c_str(), m_pInputFormat, &device_param)) != 0)
        {
            qDebug("Couldn't open input video stream.（无法打开输入流）\n");
            return false;
        }
        //input video initialize
        if (avformat_find_stream_info(m_pVidFmtCtx, NULL) < 0)
        {
            qDebug("Couldn't find video stream information.（无法获取流信息）\n");
            return false;
        }
        m_videoindex = -1;
        for (i = 0; i < m_pVidFmtCtx->nb_streams; i++)
        {
            if (m_pVidFmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
            {
                m_videoindex = i;
                break;
            }
        }

        if (m_videoindex == -1)
        {
            qDebug("Couldn't find a video stream.（没有找到视频流）\n");
            return false;
        }
        if (avcodec_open2(m_pVidFmtCtx->streams[m_videoindex]->codec, avcodec_find_decoder(m_pVidFmtCtx->streams[m_videoindex]->codec->codec_id), NULL) < 0)
        {
            qDebug("Could not open video codec.（无法打开解码器）\n");
            return false;
        }
    }

    //

    if(!m_audio_device.empty())
    {
        string device_name = "audio=" + m_audio_device;

        string device_name_utf8 = AnsiToUTF8(device_name.c_str(), device_name.length());  //转成UTF-8，解决设备名称包含中文字符出现乱码的问题

        //Set own audio device's name
        if (avformat_open_input(&m_pAudFmtCtx, device_name_utf8.c_str(), m_pInputFormat, &device_param) != 0){

            qDebug("Couldn't open input audio stream.（无法打开输入流）\n");
            return false;
        }

        //input audio initialize
        if (avformat_find_stream_info(m_pAudFmtCtx, NULL) < 0)
        {
            qDebug("Couldn't find audio stream information.（无法获取流信息）\n");
            return false;
        }
        m_audioindex = -1;
        for (i = 0; i < m_pAudFmtCtx->nb_streams; i++)
        {
            if (m_pAudFmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
            {
                m_audioindex = i;
                break;
            }
        }
        if (m_audioindex == -1)
        {
            qDebug("Couldn't find a audio stream.（没有找到音频流）\n");
            return false;
        }
        if (avcodec_open2(m_pAudFmtCtx->streams[m_audioindex]->codec, avcodec_find_decoder(m_pAudFmtCtx->streams[m_audioindex]->codec->codec_id), NULL) < 0)
        {
            qDebug("Could not open audio codec.（无法打开解码器）\n");
            return false;
        }
    }

    return true;
}

bool  CAVInputStream::StartCapture()
{
    if (m_videoindex == -1 && m_audioindex == -1)
    {
        qDebug("错误：你没有打开设备 \n");
        return false;
    }
    m_start_time = av_gettime();

    m_exit_thread = false;

    if(!m_video_device.empty()) {
        std::thread readVideo(&CAVInputStream::ReadVideoPackets,this);
        readVideo.detach();
    }

    if(!m_audio_device.empty()) {
        std::thread readAudio(&CAVInputStream::ReadAudioPackets,this);
        readAudio.detach();
    }
    return true;
}

void  CAVInputStream::CloseInputStream()
{
    m_exit_thread = true;
    // TODO: 线程回收

     //关闭输入流
    if (m_pVidFmtCtx != NULL)
    {
        avformat_close_input(&m_pVidFmtCtx);
        //m_pVidFmtCtx = NULL;
    }
    if (m_pAudFmtCtx != NULL)
    {
        avformat_close_input(&m_pAudFmtCtx);
        //m_pAudFmtCtx = NULL;
    }

    if(m_pVidFmtCtx)
       avformat_free_context(m_pVidFmtCtx);
    if(m_pAudFmtCtx)
       avformat_free_context(m_pAudFmtCtx);

    m_pVidFmtCtx = NULL;
    m_pAudFmtCtx = NULL;
    m_pInputFormat = NULL;

    m_videoindex = -1;
    m_audioindex = -1;
}

int  CAVInputStream::ReadVideoPackets()
{
    if(dec_pkt == NULL)
    {
        //TODO: prepare before decode and encode
        dec_pkt = (AVPacket *)av_malloc(sizeof(AVPacket));
    }

    int encode_video = 1;
    int ret;

    //TODO: start decode and encode

    while (encode_video)
    {
        if (m_exit_thread)
            break;

        AVFrame * pframe = NULL;
        if ((ret = av_read_frame(m_pVidFmtCtx, dec_pkt)) >= 0)
        {
            pframe = av_frame_alloc();
            if (!pframe)
            {
                ret = AVERROR(ENOMEM);
                return ret;
            }
            int dec_got_frame = 0;
            ret = avcodec_decode_video2(m_pVidFmtCtx->streams[dec_pkt->stream_index]->codec, pframe, &dec_got_frame, dec_pkt);
            if (ret < 0)
            {
                av_frame_free(&pframe);
                av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
                break;
            }
            if (dec_got_frame)
            {
                if(m_pVideoCBFunc)
                {
                    std::lock_guard<mutex> mu(m_mutex);
                    m_pVideoCBFunc(m_pVidFmtCtx->streams[dec_pkt->stream_index], m_pVidFmtCtx->streams[m_videoindex]->codec->pix_fmt, pframe, av_gettime() - m_start_time);
                }

                av_frame_free(&pframe);
            }
            else
            {
                av_frame_free(&pframe);
            }

            av_free_packet(dec_pkt);
        }
        else
        {
            if (ret == AVERROR_EOF)
                encode_video = 0;
            else
            {
                qDebug("Could not read video frame\n");
                break;
            }
        }
    }

    return 0;
}

int CAVInputStream::ReadAudioPackets()
{
    //TODO: audio trancoding here
    int ret;

    int encode_audio = 1;
    int dec_got_frame_a = 0;

    //TODO: start decode and encode
    while (encode_audio)
    {
        if (m_exit_thread)
           break;

        /**
        * Decode one frame worth of audio samples, convert it to the
        * output sample format and put it into the FIFO buffer.
        */
        AVFrame *input_frame = av_frame_alloc();
        if (!input_frame)
        {
            ret = AVERROR(ENOMEM);
            return ret;
        }

        /** Decode one frame worth of audio samples. */
        /** Packet used for temporary storage. */
        AVPacket input_packet;
        av_init_packet(&input_packet);
        input_packet.data = NULL;
        input_packet.size = 0;

        /** Read one audio frame from the input file into a temporary packet. */
        if ((ret = av_read_frame(m_pAudFmtCtx, &input_packet)) < 0)
        {
            /** If we are at the end of the file, flush the decoder below. */
            if (ret == AVERROR_EOF)
            {
                encode_audio = 0;
            }
            else
            {
                qDebug("Could not read audio frame\n");
                return ret;
            }
        }

        /**
        * Decode the audio frame stored in the temporary packet.
        * The input audio stream decoder is used to do this.
        * If we are at the end of the file, pass an empty packet to the decoder
        * to flush it.
        */
        if ((ret = avcodec_decode_audio4(m_pAudFmtCtx->streams[m_audioindex]->codec, input_frame, &dec_got_frame_a, &input_packet)) < 0)
        {
            qDebug("Could not decode audio frame\n");
            return ret;
        }
        av_packet_unref(&input_packet);
        /** If there is decoded data, convert and store it */
        if (dec_got_frame_a)
        {
            if(m_pAudioCBFunc)
            {
                std::lock_guard<mutex> mu(m_mutex);
                m_pAudioCBFunc(m_pAudFmtCtx->streams[m_audioindex], input_frame, av_gettime() - m_start_time);
            }
        }

        av_frame_free(&input_frame);


    }//while

    return 0;
}


bool CAVInputStream::GetVideoInputInfo(int & width, int & height, int & frame_rate, AVPixelFormat & pixFmt)
{
    if(m_videoindex != -1)
    {
        width  =  m_pVidFmtCtx->streams[m_videoindex]->codec->width;
        height =  m_pVidFmtCtx->streams[m_videoindex]->codec->height;

        AVStream *stream = m_pVidFmtCtx->streams[m_videoindex];

        pixFmt = stream->codec->pix_fmt;

        //frame_rate = stream->avg_frame_rate.num/stream->avg_frame_rate.den;//每秒多少帧

        if(stream->r_frame_rate.den > 0)
        {
          frame_rate = stream->r_frame_rate.num/stream->r_frame_rate.den;
        }
        else if(stream->codec->framerate.den > 0)
        {
          frame_rate = stream->codec->framerate.num/stream->codec->framerate.den;
        }

        return true;
    }
    return false;
}

bool  CAVInputStream::GetAudioInputInfo(AVSampleFormat & sample_fmt, int & sample_rate, int & channels)
{
    if(m_audioindex != -1)
    {
        sample_fmt = m_pAudFmtCtx->streams[m_audioindex]->codec->sample_fmt;
        sample_rate = m_pAudFmtCtx->streams[m_audioindex]->codec->sample_rate;
        channels = m_pAudFmtCtx->streams[m_audioindex]->codec->channels;

        return true;
    }
    return false;
}

这个类启动两个采集线程,分别采集视频和音频,采集到数据之后通过 VideoCaptureCB和AudioCaptureCB两个回调把数据传出去

4.获取采集到的数据并显示

在主界面分别实现回调函数

int VideoCaptureCallback(AVStream * input_st, enum AVPixelFormat pix_fmt, AVFrame *pframe, __int64 lTimeStamp)
{
    thisWindow->PlayVideo(input_st, pframe); // 本地播放
    thisWindow->m_OutputStream.write_video_frame(input_st, pix_fmt, pframe, lTimeStamp); // 写入文件和发送到网络
    return 0;
}

int AudioCaptureCallback(AVStream * input_st, AVFrame *pframe, __int64 lTimeStamp)
{
    thisWindow->PlayAudio(input_st, pframe); // 本地播放
    thisWindow->m_OutputStream.write_audio_frame(input_st, pix_fmt, pframe, lTimeStamp); // 写入文件和发送到网络
    return 0;
}

5.播放视频,这里我是将图片转换成rgb24播放的

if(m_pRgb24 == NULL || m_nRgbSize == 0)
    {
        int nRgbSize = st->codec->width * st->codec->height*4; //24位位图占用的大小理论上应为st->codec->width * st->codec->height*3， 但是考虑到每行像素宽带4字节对齐的问题，所以故意分配多一点空间
        m_pRgb24 = new BYTE[nRgbSize];
        memset(m_pRgb24, 0, nRgbSize);
        m_nRgbSize = nRgbSize;
    }

    if(st->codec->pix_fmt != AV_PIX_FMT_BGR24)
    {
        if(img_convert_ctx == NULL)
        {
            img_convert_ctx = sws_getContext(st->codec->width, st->codec->height,
            st->codec->pix_fmt,
            st->codec->width, st->codec->height,
            AV_PIX_FMT_RGB24,
            SWS_BICUBIC, NULL, NULL, NULL);

            if (img_convert_ctx == NULL)
            {
                qDebug("sws_getContext() failed \n");
                return FALSE;
            }
        }

        uint8_t *rgb_src[3]= {m_pRgb24, NULL, NULL};
        int rgb_stride[3] = {st->codec->width*3, 0, 0};

        //转成RGB格式
        sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize,  0, st->codec->height, rgb_src, rgb_stride);
    }
    // 显示到界面
    QLabel* labYours = ui->labYours;
    QImage Image = QImage((uchar *)m_pRgb24, st->codec->width,st->codec->height, QImage::Format_RGB888);
    QPixmap pixmap = QPixmap::fromImage(Image);
    int with = labYours->width();
    int height = labYours->height();
    QPixmap fitpixmapY = pixmap.scaled(with, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);  // 饱满填充
    labYours->setScaledContents(true);
    labYours->setPixmap(fitpixmapY);

6.最后效果
不熟悉csdn的编辑,以后熟悉了再详细介绍吧
在这里插入图片描述

冲动的乘法
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ubuntu下使用Qt+ffmpeg采集音频，保存音频文件，简单多线程方式
VectorAL的博客
09-13 995
ubuntu下使用Qt+ffmpeg采集音频，保存音频文件，简单多线程方式 ui界面增加按钮，按钮文本为开始录制。按钮槽函数： void MainWindow::on_btn_Open_clicked() { if (m_status) { m_status = false; ui->btn_Open->setText(tr("开始录制")); } else { m_status = true;
用FFmpeg+nginx+rtmp搭建环境实现推流.docx
06-16
FFmpeg+nginx+rtmp搭建环境实现推流 FFmpeg、nginx、rtmp三者结合可以实现一个强大且高效的流媒体服务器，下面是它们的详细介绍和搭建过程。 FFmpeg FFmpeg是一款功能强大的开源命令行工具，能够处理视频和音频...
ffmpeg 音频数据采集
06-22
ffmpeg 音频数据采集 开发环境vs2010 学习从零开始学习音视频编程技术（十七） 录屏软件开发之音频采集 源码
基于Qt+FFmpeg的摄像头视频采集及存储系统实现
Hello~~~
07-12 1万+
本文主要基于Qt的利用FFmpeg的视频库完成对网络摄像头（H.264）视频流的解码，显示，格式转换及存储。 文章的FFmpeg + Qt的实现摄像头（RTSP）显示实时实现了摄像头视频流的解码及显示工作。 接下来就是视频格式转换，主要转换思路是：视频存储（YUV420P） - &amp;gt; H.264-&amp;gt; AVI 1，视频存储 采用以下方式，将解码后的一帧帧图像（YUV格式）存储到本地...
QT使用V4L2摄像头采集数据
Norgin_1的博客
08-03 1417
完成以上操作以后，我们的QT采集摄像头数据的工程也就完成了，接下来只需要往Ubuntu插入摄像头，然后运行即可。一个最简单的Ubuntu下摄像头采集就完成了。以上便是Ubuntu下和开发板下的两种QT采集摄像头显示的代码了，这里比较关键的是QT的配置，比较细节，初学可能会踩很多的坑。
用FFmpeg和Qt实现摄像头视频采集与存储系统源码.zip
05-09
主要利用FFmpeg和Qt实现摄像头视频流的采集与本地存储，将摄像头对的视频流显示到界面上，并存储到本地为.avi格式。 主要转换思路：视频流rtsp--->yuv--->.h264--->.avi。 主要利用FFmpeg和Qt实现摄像头视频流的采集与本地存储，将摄像头对的视频流显示到界面上，并存储到本地为.avi格式。 主要转换思路：视频流rtsp--->yuv--->.h264--->.avi。 主要利用FFmpeg和Qt实现摄像头视频流的采集与本地存储，将摄像头对的视频流显示到界面上，并存储到本地为.avi格式。 主要转换思路：视频流rtsp--->yuv--->.h264--->.avi。 主要利用FFmpeg和Qt实现摄像头视频流的采集与本地存储，将摄像头对的视频流显示到界面上，并存储到本地为.avi格式。 主要转换思路：视频流rtsp--->yuv--->.h264--->.avi。 主要利用FFmpeg和Qt实现摄像头视频流的采集与本地存储，将摄像头对的视频流显示到界面上，并存储到本地为.avi格式。 主要转换思路：视频流rtsp--->yuv--->.h264-
Qt/C++编写本地摄像头综合应用示例（qcamera/ffmpeg/v4l2等）
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
11-01 3464
1. 同时支持 QCamera、ffmpeg、v4l2 三种内核解析本地摄像头。 2. 提供函数 findCamera 自动搜索环境中的所有本地摄像头设备，搜索结果信号发出。 3. 支持自动搜索和指定设备两种模式，自动搜索模式下会将搜索到的第一个设备作为当前设备打开。 4. 支持同时打开多路设备，亲测4路，受限于具体的环境比如带宽。 5. 支持自动重连，默认开启，失败后会自动重新搜索和尝试打开。 6. ffmpeg方案、v4l2方案都支持回调模式（采集后转成QImage绘制）和句柄模式（采集后YUV数据GP
ffmpeg+qt代码示例
03-13
在"ffmpeg+qt代码示例"的项目中，我们可以看到几个不同的子文件和项目： 1. **player.sln**：这是一个 Visual Studio 的解决方案文件，通常包含一个或多个项目，用于构建基于 Qt 和 FFmpeg 的多媒体播放器。打开这...
Qt+FFMPEG+SDL实现的视频播放器
03-08
**Qt+FFMPEG+SDL实现的视频播放器** 在软件开发中，创建一个功能完备的视频播放器是一项挑战，但结合Qt、FFmpeg和SDL（Simple DirectMedia Layer）库，我们可以构建出一个高效且跨平台的解决方案。下面将详细阐述这...
ffmpeg+QT+多线程视频播放器
06-13
FFmpeg 是一个强大的开源多媒体处理框架，用于处理音频和视频文件。它包含了各种工具，如 ffmpeg 命令行工具，以及库，如 libavcodec（编码库）、libavformat（容器格式处理库）和 libavfilter（过滤器库）。在本...
资源OpenCV+FFmpeg+Qt+C++视频编辑器开发视频课程带文档和源码
最新发布
09-04
资源OpenCV+FFmpeg+Qt+C++视频编辑器开发视频课程带文档和源码提取方式是百度网盘分享地址
基于QT的视频采集
07-20
基于qt的视频采集，主要是将服务端的设备虚拟化，供客户端调用。使用TCP/IP协议传输，使用V4L2实现视频采集。
QT视频采集程序
08-29
非常流畅的Qt视频采集，本地显示程序。切移植后依然流畅。
ffmpeg采集、储存视频
03-26
Linux下用ffmpeg技术通过USB摄像头一帧一帧的循环采集、储存视频
QT视频采集例子
11-09
用QT写的基于v4l的视频采集代码，包括YUV转BMP格式代码
Qt5+FFmpeg实现同时采集屏幕+麦克风+系统音频的录屏软件
热门推荐
心流剑的博客
08-11 1万+
标题
从零开始学习音视频编程技术（十二） 录屏软件开发之视频采集
qq214517703的专栏
09-28 3250
原文地址：http://blog.yundiantech.com/?log=blog&id=15 前面讲解了视频播放器的开发，初步掌握了使用FFMPEG解码音视频。 现在我们就接着讲解使用FFMPEG来编码音视频，主要是实现一个录屏软件的制作。 一个录屏软件的流程基本就是： 图像采集 图像编码 将解码好的图像封装成视频
Qt+FFmpeg录音
回头太难
03-04 1606
源码下载地址 ScreenRecordImpl.h #pragma once #include <Windows.h> #include <atomic> #include <condition_variable> #include <mutex> #include <QObject> #include <QString&gt...
用QT5实现视频采集
SteveJobws的博客
02-11 8594
学习QT也有一段时间了，对QT稍有一点感觉，第一次自己写了一个相对有点用的程序，刚写完就献给广大热爱QT的好友，望你们参考，不对的地方请多多指教。QT5 的用法我就不说了，不会的看看其他的教程。 首先建立工程，选择Widget类。在.pro文件中添加代码QT += multimedia multimediawidgetsui界面如下： 具体的控件用法我就不说了widget.h的文件如下：#i
ffmpeg+qt5开发播放器c++实战视频课程 完结
07-28
通过这门课程，学习者可以系统地学习如何使用FFmpeg和QT5构建功能强大的播放器，实现各种视频和音频处理操作，如播放、暂停、快进、音量调节等。 这门课程可能包括以下内容：首先，学习者将了解FFmpeg和QT5的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值