Qt6 屏幕录相(包括音频视频)

最新推荐文章于 2024-05-10 10:44:06 发布
最新推荐文章于 2024-05-10 10:44:06 发布
阅读量2.3k 收藏 17
点赞数 1
分类专栏： Qt 学习 Qt ffmpeg 学习 文章标签： 音视频 opencv 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TM1695648164/article/details/121391769
版权
Qt 学习 同时被 3 个专栏收录
116 篇文章 15 订阅
订阅专栏
Qt
71 篇文章 4 订阅
订阅专栏
ffmpeg 学习
13 篇文章 2 订阅
订阅专栏

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTimerEvent>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
    void timerEvent(QTimerEvent *e) override;
public slots:
    void Record();
signals:
    
private:
    Ui::Widget *ui;
    bool isRecord = false;
};
#endif // WIDGET_H

widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
#include <QElapsedTimer>
#include <QDateTime>
#include <iostream>
#include "XScreenRecord.h"
using namespace std;

#define RECORDQSS                                          "\
QPushButton:!hover{                                        \
background-image: url(:/Resources/record_normal.png);      \
}                                                          \
QPushButton:hover{                                         \
    background-image: url(:/Resources/record_hot.png);     \
}                                                          \
QPushButton:press{                                         \
    background-image: url(:/Resources/record_pressed.png); \
}                                                          \
QPushButton{                                               \
    background-color: rgba(255, 255, 255, 0);              \
    background-image: url(:/Resources/record_normal.png);  \
}                                                          \
"

static QElapsedTimer timer;
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    ui->timelabel->setText("000:00");
    //隐藏标题
    setWindowFlags(Qt::FramelessWindowHint);
    setAttribute(Qt::WA_TranslucentBackground);
    startTimer(100);
}

Widget::~Widget()
{
    delete ui;
}

void Widget::Record()
{
    isRecord = !isRecord;
    std::cout<<"00000000000000000000000000000"<<std::endl;
    std::cout<<"Record = "<<isRecord<<std::endl;
    if(isRecord)
    {
        timer.restart();
        ui->recordButton->setStyleSheet("background-image: url(:/Resources/stop.png);background-color: rgba(255, 255, 255, 0)");
        QDateTime t = QDateTime::currentDateTime();
        QString filename = t.toString("yyyyMMdd_hhmmss");
        filename = "xscreen_"+ filename;
        filename += ".mp4";
       // filename = ui->urlEdit->text()+"\\" + filename;
        XScreenRecord::Get()->outWidth = ui->widthEdit->text().toInt();
        XScreenRecord::Get()->outHeight = ui->heighEdit->text().toInt();
        XScreenRecord::Get()->fps = ui->fpsEdit->text().toInt();
        if(!XScreenRecord::Get()->Start(filename.toLocal8Bit()))
        {
            ui->recordButton->setStyleSheet(RECORDQSS);
            isRecord = false;
            return;
        }
    }
    else
    {
        ui->recordButton->setStyleSheet(RECORDQSS);
        XScreenRecord::Get()->Stop();
    }
}

void Widget::timerEvent(QTimerEvent *e)
{
   // qDebug()<<"timerEvent";
    if(isRecord)
    {
        int es = timer.elapsed() / 1000;
        char buf[1024] = {0};
        sprintf(buf,"%03d:%02d",es/60,es%60);
        ui->timelabel->setText(buf);
    }
}

XAudioThread.h

#pragma once
#include <QThread>
#include <QMutex>
#include <QAudioDevice>
#include <QAudioSource>
#include <QIODevice>

class XAudioThread : public QThread
{
	Q_OBJECT
public:
	int sampleRate = 44100;
	int channels = 2;
	int sampleByte = 2;
	int nbSample = 1024;

	int cacheSize = 10;
	char *GetPCM();
	virtual ~XAudioThread();
	//out

	
	void Start();	
	void Stop();
	void run();

	static XAudioThread *Get()
	{
		static XAudioThread ct;
		return &ct;
	}
protected:
	bool isExit = false;
	std::list<char *> pcms;
	QMutex mutex;
	QAudioDevice audioInput;
	QAudioSource *audio = NULL;
	QIODevice *io =  NULL;
	QAudioFormat format;
	XAudioThread();
};

XAudioThread.cpp

#include "XAudioThread.h"
#include <iostream>
#include <QMediaDevices>
#include <QDebug>

using namespace std;

void XAudioThread::Start()
{
	std::cout<<"XAudioThread::Start"<<std::endl;
	//Stop();
	mutex.lock();
	std::cout<<"set isExit = false"<<std::endl;
	isExit = false;

	QAudioFormat format;
	format.setSampleRate(sampleRate);
	format.setChannelCount(channels);
	format.setSampleFormat(QAudioFormat::Int16);
	
    audioInput = QMediaDevices::defaultAudioInput();
    if (!audioInput.isFormatSupported(format))
    {
        qWarning() << "Default format not supported, trying to use the nearest.";
    }
    audio = new QAudioSource(format);
    //开始录制音频
    io = audio->start();
	mutex.unlock();
	start();
}

void XAudioThread::Stop()
{
	std::cout<<"XAudioThread::Stop"<<std::endl;
	isExit = true;	
	mutex.lock();	
	std::cout<<"set isExit = true"<<std::endl;
	while(!pcms.empty())
	{
		delete pcms.front();
		pcms.pop_front();
	}
	if(audio)
	{
		io->close();
		audio->stop();
		delete audio;
		audio = NULL;
		io = NULL;
	}
	mutex.unlock();
	std::cout<<"isExit = "<<isExit<<std::endl;
	wait();
}


char *XAudioThread::GetPCM()
{
	mutex.lock();
	if(pcms.empty())
	{
		mutex.unlock();
		return NULL;
	}	
	char *re = pcms.front();
	pcms.pop_front();
	mutex.unlock();
	cout<<"A"<<flush;
	return re;
}


void XAudioThread::run()
{
//	std::cout<<"---------------------------run------------"<<isExit<<endl;
	int size = nbSample*channels*sampleByte;
	
//	std::cout<<"XAudioThread::run()"<<std::endl;
	while(!isExit)
	{

		//std::cout<<"-----------------while(!isExit)----------run------------"<<isExit<<endl;
		mutex.lock();
		if(pcms.size() > cacheSize)
		{
		//	std::cout<<"--------------------pcms.size() > cacheSize-------run------------"<<isExit<<endl;
			mutex.unlock();
			msleep(5);
			continue;
		}
		//char data[size];
		char *data = new char[size];
		int readedSize = 0;
		//1.qt音频开始录制
	   	//音频重采样
		while(readedSize < size && !isExit)
		{
	    	if(!io || isExit)
			{
				mutex.unlock();
				cout<<"quit run"<<endl;
				return;
			}
	        qint64 rev_len = io->bytesAvailable();
		
		   // std::cout<<"rev_len = "<<rev_len<<" "<<endl;
	        if (rev_len < 1024)
	        {
	        	msleep(1);
	        	continue;
	        }
	        int read_len = 1024;
	    	//最后一帧
	    	if(size - readedSize < 1024)
	    	{
	    		read_len = size - readedSize;
	    	}
	    	//std::cout<<"size - readedSize = "<<size - readedSize<<endl;
	        qint64 readedLen = io->read(data + readedSize, read_len);
	      //  std::cout<<"read_len "<<read_len<<" readedLen = "<<readedLen<<endl;
	        readedSize += readedLen;
	    }
//	    std::cout<<"push_back------------------------"<<endl;
		pcms.push_back(data);
		mutex.unlock();
	}
	cout<<"quit run"<<endl;
	
}

XAudioThread::XAudioThread()
{

}

XAudioThread::~XAudioThread()
{

}

XCaptureThread.h

#pragma once

#include <QThread>
#include <QMutex>


class XCaptureThread : protected QThread
{
	Q_OBJECT
public:
	//out

	int width = 1280;
	int height = 720;
	
	//in
	int fps = 10;
	int cacheSize = 3;
	
	char *GetRGB();
	void Start();	
	void Stop();
	void run();

	static XCaptureThread *Get()
	{
		static XCaptureThread ct;
		return &ct;
	}
	virtual ~XCaptureThread();
private:
	bool isExit = false;
	std::list<char *> rgbs;
	QMutex mutex;
	XCaptureThread();
};

XCaptureThread.cpp

#include "XCaptureThread.h"
#include <QScreen>
#include <iostream>
#include <QGuiApplication>
#include <QWidget>
#include <QElapsedTimer>

using namespace std;
//截取全屏
void CaptureScreen(char *data)
{
	QRect rect =  QGuiApplication::primaryScreen()->geometry();
	int width = rect.width();
	int height = rect.height();
	 //获取QScreen
    static QScreen *scr = nullptr;
    if(!scr)
    {
        scr = QGuiApplication::primaryScreen();
        // if (const QWindow *window = windowHandle())
        //     scr = window->screen();
        if (!scr)
        return;
    }
    //截取全屏
//    QPixmap pix = scr->grapWindow(windowHandle()); //HWND
    QPixmap pix = scr->grabWindow(0);
    int size = width * height * 4;
    memcpy(data,pix.toImage().bits(),size);
    std::cout<<"pix.width() = "<<pix.width()<<" pix.height ="<<pix.height();
}



XCaptureThread::XCaptureThread()
{
	QRect rect =  QGuiApplication::primaryScreen()->geometry();
	width = rect.width();
	height = rect.height();
	std::cout<<"width = "<<width<<"height = "<<height<<std::endl;
}

XCaptureThread::~XCaptureThread()
{
	
}

void XCaptureThread::Start()
{
	std::cout<<"XCaptureThread::Start"<<std::endl;
	//Stop();
	mutex.lock();
	std::cout<<"set isExit = false"<<std::endl;
	isExit = false;
	mutex.unlock();
	start();
}

void XCaptureThread::Stop()
{
	std::cout<<"XCaptureThread::Stop"<<std::endl;
	mutex.lock();
	std::cout<<"set isExit = true"<<std::endl;
	isExit = true;
	while(!rgbs.empty())
	{
		delete rgbs.front();
		rgbs.pop_front();
	}
	mutex.unlock();
	std::cout<<"isExit = "<<isExit<<std::endl;
	wait();
}

//内存需要用户释放
char *XCaptureThread::GetRGB()
{
	mutex.lock();
	if(rgbs.empty())
	{
		mutex.unlock();
		return NULL;
	}	
	char *re = rgbs.front();
	rgbs.pop_front();
	mutex.unlock();
	cout<<"V"<<flush;
	return re;
}

void XCaptureThread::run()
{
	QElapsedTimer  t;
	while(!isExit)
	{
		t.restart();
		mutex.lock();
		int s = 1000 / fps;
		if(rgbs.size() < cacheSize)
		{
			char *data = new char[width*height*4];
			CaptureScreen(data);
			rgbs.push_back(data);
		}
		mutex.unlock();
		s = s - t.restart();
		if(s <= 0 || s > 10000)
		{
			s = 10;
		}
		//cout<<s<<" "<<flush;
		msleep(s);		
	}
}

XScreenRecord.h

#pragma once
#include <QThread>
#include <QMutex>

class XScreenRecord : protected QThread
{
	Q_OBJECT
public:
	//in
	int fps = 10;
	int outWidth = 1280;
	int outHeight = 720;
	
	bool Start(const char *filename);
	void Stop();
	void run();
	static XScreenRecord *Get()
	{
		static XScreenRecord ct;
		return &ct;
	}
	virtual ~XScreenRecord();
protected:
	bool isExit = false;
	QMutex mutex;
	XScreenRecord();
};
``
XScreenRecord.cpp`
````cpp
#include "XScreenRecord.h"
#include "XCaptureThread.h"
#include "XAudioThread.h"
#include "XVideoWriter.h"
#include <iostream>
using namespace std;

bool XScreenRecord::Start(const char *filename)
{
	if(!filename) return false;
	//Stop();
	mutex.lock();
	isExit = false;
	//初始化屏幕录制
	XCaptureThread::Get()->fps = fps;
	XCaptureThread::Get()->Start();

	//初始化音频的录制
	XAudioThread::Get()->Start();

	//初始化编码器
	XVideoWriter::Get()->inWidth = XCaptureThread::Get()->width;
	XVideoWriter::Get()->inHeight = XCaptureThread::Get()->height;
	XVideoWriter::Get()->outWidth = XCaptureThread::Get()->width;;
	XVideoWriter::Get()->outHeight = XCaptureThread::Get()->height;
	std::cout<<"outWidth = "<<XCaptureThread::Get()->width<<" outHeight = "<<XCaptureThread::Get()->height<<std::endl;
	XVideoWriter::Get()->outFPS = fps;
	XVideoWriter::Get()->Init(filename);
	XVideoWriter::Get()->AddVideoStream();
	XVideoWriter::Get()->AddAudioStream();
	if(!XVideoWriter::Get()->WriteHead())
	{
		mutex.unlock();
		Stop();
		return false;
	}
	std::cout<<"=--------------------------------"<<std::endl;
	mutex.unlock();
	start();
	return true;
}

void XScreenRecord::Stop()
{
	std::cout<<"XScreenRecord::Stop"<<std::endl;

	mutex.lock();
	isExit = true;
	mutex.unlock();

	mutex.lock();

	XVideoWriter::Get()->WriteEnd();
	std::cout<<"=========================="<<endl;
	XVideoWriter::Get()->Close();
	std::cout<<"=========================="<<endl;
	XAudioThread::Get()->Stop();
	std::cout<<"=========================="<<endl;
	XCaptureThread::Get()->Stop();
	std::cout<<"=========================="<<endl;

	mutex.unlock();
	wait();
}

void XScreenRecord::run()
{
	mutex.lock();
	while(!isExit)
	{
		//写入视频
		char *rgb = XCaptureThread::Get()->GetRGB();
		if(rgb)
		{
			AVPacket *p = XVideoWriter::Get()->EncodeVideo((unsigned char*)rgb);
			delete rgb;
			XVideoWriter::Get()->WriteFrame(p);
			cout<<"@";			
		}

		//写入音频
		char *pcm = XAudioThread::Get()->GetPCM();
		if(pcm)
		{
			AVPacket *p = XVideoWriter::Get()->EncodeAudio((unsigned char*)pcm);
			delete pcm;
			XVideoWriter::Get()->WriteFrame(p);
			cout<<"#";			
		}

		msleep(10);
		mutex.unlock();
	}
}

XScreenRecord::XScreenRecord()
{

}

XScreenRecord::~XScreenRecord()
{

}

XVideoWriter.h

#pragma once
#include <string>

class AVPacket;
enum XSAMPLEFMT
{
	X_S16 = 1,
	X_FLATP = 8
};

enum pixelFormat
{
    PIX_FMT_ARGB = 23,      ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
    PIX_FMT_RGBA = 26,      ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
    PIX_FMT_ABGR = 27,      ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
    PIX_FMT_BGRA = 28,      ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
};

class XVideoWriter
{
public:
	//视频输入参数
	int inWidth = 848;
	int inHeight = 480;
	int inPixFmt = PIX_FMT_BGRA;//28;//30 //AV_PIX_FMT_BGRA

	//音频的输入参数
	int inSampleRate = 44100;
	int inChannels = 2;
	XSAMPLEFMT inSampleFmt = X_S16;

	//视频输出参数
	int vBitrate = 4000000;
	int outWidth = 848;
	int outHeight = 480;
	int outFPS = 25;

	//音频输出参数
	int aBitrate = 64000;
	int outChannels = 2;
	int outSampleRate = 44100;
	XSAMPLEFMT outSampleFmt = X_FLATP;

	int nb_sample = 1024; //输入输出的每帧数据每通道样本数量

	virtual bool Init(const char* file) = 0;
	virtual void Close() = 0;
	virtual bool AddVideoStream() = 0;
	virtual bool AddAudioStream() = 0;
	//把转yuv和编码放在一起做
	virtual AVPacket *EncodeVideo(const unsigned char *rgb) = 0;
	virtual AVPacket *EncodeAudio(const unsigned char *pcm) = 0;
	virtual bool WriteHead() = 0;
	//尾部文件没有写会视频不能拖动，时长不对

	//会释放pkt的空间
	virtual bool WriteFrame(AVPacket *pkt) = 0;

	virtual bool WriteEnd() = 0;

	virtual bool IsVideoBefore() = 0;

	static XVideoWriter *Get(unsigned short index = 0);
	~XVideoWriter();
	std::string filename;
protected:
	XVideoWriter();	
};

XVideoWriter.cpp

#include "XVideoWriter.h"

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

#include <iostream>
using namespace std;

class CXVideoWriter : public XVideoWriter
{
public:
	AVFormatContext *ic = NULL; //封装mp4输出上下文
	AVCodecContext *vc = NULL; //视频编码器上下文
	AVCodecContext *ac = NULL; //音频编码器山下文
	AVStream *vs =  NULL; //视频流
	AVStream *as = NULL; //音频流
	SwsContext *vsc = NULL; //像素转换的上下文
	SwrContext *asc = NULL; //音频重采样上下文

	AVFrame *yuv = NULL; //输出yuv
	AVFrame *pcm = NULL; //重采样后输出的pcm

	int vpts = 0; //视频的pts;
	int apts = 0; //音频的pts;

	void Close()
	{
		if(ic) avformat_close_input(&ic);
		
		if(vc) 
		{
			avcodec_close(vc);
			avcodec_free_context(&vc);
		}
		if(ac)
		{
			avcodec_close(ac);
			avcodec_free_context(&ac);
		}
		if(vsc)
		{
			sws_freeContext(vsc);
			vsc = NULL;
		}

		if(yuv){ av_frame_free(&yuv);}
		if(pcm){ av_frame_free(&pcm);}

		if(asc)
		{
			swr_free(&asc);
		}

	}
	bool Init(const char* file)
	{
		Close();
		//封装文件的上限文
		avformat_alloc_output_context2(&ic,NULL,NULL,file);
		if(!ic)
		{
			cerr<<"avformat_alloc_output_context2 failed!"<<endl;
			return false;
		}
		filename = file;
		return true;
 	}
	bool AddVideoStream()
	{

		if(!ic) return false;
		//1.视频编码器创建
		AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_H264);
		if(!codec)
		{
			cerr<<"avcodec_find_encoder AV_CODEC_ID_H264 failed!"<<endl;
			return false;
		}
		vc = avcodec_alloc_context3(codec);
		if(!vc)
		{
			cerr<<"avcodec_alloc_context3 failed!"<<endl;
			return false;
		}
		//比特率，压缩后每秒大小
		vc->bit_rate = vBitrate;
		vc->width = outWidth;
		vc->height = outHeight;

		//时间基数
		vc->time_base = {1,outFPS};
		vc->framerate = {outFPS,1};
		
		//画面组大小,多少帧一个关键帧
		vc->gop_size = 50;
		//两个非b帧之间的b帧数量
		vc->max_b_frames = 0;
		//像素格式
		vc->pix_fmt = AV_PIX_FMT_YUV420P;
		//编码id
		vc->codec_id = AV_CODEC_ID_H264;
		//选项的设置
		av_opt_set(vc->priv_data,"preset","superfast",0);
		//统一的封装头
		vc->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
		//打开编码器
		int ret = avcodec_open2(vc,codec,NULL);
		if(ret != 0)
		{
			cerr<<"avcodec_open2 failed!"<<endl;
			return false;
		}
		cout<<"avcodec_open2 success!"<<endl;

		//添加视频流到上下文
		vs = avformat_new_stream(ic,NULL);
		//不包含编码信息
		vs->codecpar->codec_tag = 0;
		//把编码器信息拷贝到封装流里面
		avcodec_parameters_from_context(vs->codecpar,vc);
		av_dump_format(ic,0,filename.c_str(),1);


		//像素(尺寸)转换的上下文 rgb to yuv
		vsc = sws_getCachedContext(vsc,
			inWidth,inHeight,(AVPixelFormat)inPixFmt,//输入参数
			outWidth,outHeight,AV_PIX_FMT_YUV420P,
			SWS_BICUBIC,
			NULL,NULL,NULL
			);
		if(!vsc)
		{
			cerr<<"sws_getCachedContext failed!"<<endl;
			return false;
		}

		if(!yuv)
		{
			//对对象成员初始化
			yuv = av_frame_alloc();
			yuv->format = AV_PIX_FMT_YUV420P;
			yuv->width = outWidth;
			yuv->height = outHeight;
			//需要指定pts 每一帧加1
			yuv->pts = 0;

			//创建yuv 空间
			int ret = av_frame_get_buffer(yuv,32);
			if(ret != 0)
			{
				cerr<<"sws_getCachedContext failed!"<<endl;
				return false;
			}
		}

		return true;		
	}
	AVPacket *EncodeVideo(const unsigned char *rgb)
	{
		if(!ic || !vsc || !yuv) return NULL;
		AVPacket *p = NULL;
		uint8_t *inData[AV_NUM_DATA_POINTERS] = { 0 };
		inData[0] = (uint8_t *)rgb;

		int insize[AV_NUM_DATA_POINTERS] = {0};
		insize[0] = inWidth * 4;

		//rgb to yuv
		int h = sws_scale(vsc, inData,insize,0,inHeight,
			yuv->data,yuv->linesize);
		if(h<0)
			return NULL;
		//cout<<h<<"|";
		yuv->pts = vpts;
		vpts++;
		//encode
		int ret = avcodec_send_frame(vc,yuv);
		if(ret != 0)
		{
			return NULL;
		}
		p = av_packet_alloc();
		ret = avcodec_receive_packet(vc,p);
		if(ret != 0 || p->size <= 0)
		{
			av_packet_free(&p);
			return NULL;
		}
		av_packet_rescale_ts(p,vc->time_base,vs->time_base);	
		p->stream_index = vs->index;
		return p;
	}

	bool WriteHead()
	{
		if(!ic) return false;		
		//打开io
		int ret = avio_open(&ic->pb,filename.c_str(),AVIO_FLAG_WRITE);
		if(ret != 0)
		{
			cerr<<"avio_open failed!"<<endl;
			return false;
		}
		cout<<"write "<<filename<<" head success"<<endl;

		//写入封装头
		ret = avformat_write_header(ic,NULL);
		if(ret != 0)
		{
			cerr<<"avformat_write_header failed!"<<endl;
			return false;
		}
		cout<<"write "<<filename<<" head success"<<endl;

		return true;
	}

	bool WriteFrame(AVPacket *pkt)
	{
		if(!ic || !pkt || pkt->size <= 0) return false;
		//av_write_frame
		if(av_interleaved_write_frame(ic,pkt) != 0) return false;
		return true;
	}

	virtual bool WriteEnd()
	{
		if(!ic || !ic->pb) return false;
		//写入尾部信息和索引
		if(av_write_trailer(ic) != 0)
		{
			cerr<<"av_write_trailer failed!"<<endl;
			return false;
		}

		//关闭输入io
		if(avio_closep(&ic->pb) != 0)
		{
			cerr<<"avio_close failed!"<<endl;
			return false;
		}
		cout<<"WriteEnd success!"<<endl;
		return true;
	}

	bool AddAudioStream()
	{
		if (!ic)return false;
		//1.找到音频编码
		AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
		if(!codec)
		{
			cerr<<"avcodec_find_encoder AV_CODEC_ID_AAC failed!"<<endl;
			return false;
		}
		//2.创建并打开音频编码器
		ac = avcodec_alloc_context3(codec);
		if(!ac)
		{
			cerr<<"avcodec_alloc_context3 failed!"<<endl;
			return false;
		}

		ac->bit_rate = aBitrate;
		ac->sample_rate = outSampleRate;
		ac->sample_fmt = (AVSampleFormat)outSampleFmt;
		ac->channels = outChannels;
		ac->channel_layout = av_get_default_channel_layout(outChannels);
		ac->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
		int ret = avcodec_open2(ac,codec,NULL);
		if(ret != 0)
		{
			avcodec_free_context(&ac);
			cerr<<"avcodec_open2 failed!"<<endl;
			return false;
		}
		cout<<"avcodec_open2 AV_CODEC_ID_AAC success"<<endl;
		//新曾音频流
		as = avformat_new_stream(ic,NULL);
		if(!as)
		{
			cerr<<"avformat_new_stream failed!"<<endl;
			return false;
		}
		//参数设置
		as->codecpar->codec_tag = 0;
		avcodec_parameters_from_context(as->codecpar,ac);
		av_dump_format(ic,0,filename.c_str(),1);

		//音频重采样上下文
		asc = swr_alloc_set_opts(asc,
			ac->channel_layout,ac->sample_fmt,ac->sample_rate,//输入格式
			av_get_default_channel_layout(inChannels),(AVSampleFormat)inSampleFmt,inSampleRate,
			0,0);
		ret = swr_init(asc);
		if(ret != 0)
		{
			cerr<<"swr_init failed！"<<endl;
			return false;
		}
		//音频重采样后输出AVFrame
		if(!pcm)
		{
			pcm = av_frame_alloc();
			pcm->format = ac->sample_fmt;
			pcm->channels = ac->channels;
			pcm->channel_layout = ac->channel_layout;
			pcm->nb_samples = nb_sample;//一帧音频的采样数量
			ret = av_frame_get_buffer(pcm,0);
			if(ret < 0)
			{
				cerr<<"av_frame_get_buffer failed "<<endl;
				return false;
			}
			cout<<"audio av_frame_get_buffer success"<<endl;
		}
		return true;
	}
	AVPacket* EncodeAudio(const unsigned char *d)
	{
		if(!ic || !asc || !pcm) return NULL;
		const uint8_t *data[AV_NUM_DATA_POINTERS] = {0};
		data[0] = (uint8_t *)d;
		int len = swr_convert(asc,pcm->data,pcm->nb_samples,
			data,pcm->nb_samples);
		cout<<len<<"*";

		//2音频编码
		int ret = avcodec_send_frame(ac,pcm);
		if(ret != 0)
		{
			return NULL;
		}
		//需要对pkt进行释放
		AVPacket *pkt = av_packet_alloc();
		av_init_packet(pkt);
		ret = avcodec_receive_packet(ac,pkt);
		if(ret != 0)
		{
			av_packet_free(&pkt);
			return NULL;
		}
		cout<<pkt->size<<"|";
		pkt->stream_index = as->index;
		pkt->pts = apts;
		pkt->dts = pkt->pts;
		apts += av_rescale_q(pcm->nb_samples,{1,ac->sample_rate},ac->time_base);
		return pkt;
	}

	bool IsVideoBefore()
	{	
		if(!ic || !as || !vs) 
		{
			std::cout<<"!ic || !as || !vs = false"<<std::endl;
			return false;
		}

		int ret = av_compare_ts(vpts,vc->time_base,apts,ac->time_base);
		if(ret <= 0)
		{
			std::cout<<"IsVideoBefore = true"<<std::endl;	
			return true;
		}
		std::cout<<"IsVideoBefore = false"<<std::endl;
		return false;
	}
};

XVideoWriter* XVideoWriter::Get(unsigned short index)
{
	static bool isfirst = true;
	if(isfirst)
	{
		av_register_all();
		avcodec_register_all();
		isfirst = false;
	}

	static CXVideoWriter wrs[65535];
	return &wrs[index]; 
}

XVideoWriter::XVideoWriter()
{

}

XVideoWriter::~XVideoWriter()
{

}

bool XVideoWriter::AddVideoStream()
{
	return true;
}

main.cpp

#include "widget.h"
#include "XCaptureThread.h"
#include "XAudioThread.h"
#include "XScreenRecord.h"
#include <QApplication>
#include <QDateTime>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{

    QApplication a(argc, argv);
    Widget w;
    w.show();
    return a.exec();
}

resource.qrc

<RCC>
  <qresource>
    <file>Resources/stop.png</file>
    <file>Resources/stop.png</file>
    <file>Resources/record_pressed.png</file>
    <file>Resources/record_normal.png</file>
    <file>Resources/record_hot.png</file>
    <file>Resources/mini.png</file>
    <file>Resources/logo.png</file>
    <file>Resources/logo.ico</file>
    <file>Resources/close.png</file>
    <file>Resources/record_pressed.png</file>
    <file>Resources/record_hot.png</file>
    <file>Resources/record_normal.png</file>
    <file>Resources/logo.ico</file>
    <file>Resources/mini.png</file>
    <file>Resources/close.png</file>
    <file>Resources/logo.png</file>
  </qresource>
</RCC>

widget.ui

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Widget</class>
 <widget class="QWidget" name="Widget">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>800</width>
    <height>381</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Widget</string>
  </property>
  <property name="windowIcon">
   <iconset resource="resource.qrc">
    <normaloff>:/Resources/logo.ico</normaloff>:/Resources/logo.ico</iconset>
  </property>
  <property name="styleSheet">
   <string notr="true">#back{
	background-color: rgb(46, 52, 54);
	border-radius:15px;
}

#all{
	background-color: rgb(35, 35, 35);
}

#title{
	color: rgb(78, 154, 6);
	font: 700 21pt &quot;aakar&quot;;
}


#timelabel{
	color: rgb(78, 154, 6);
	font: 700 25pt &quot;aakar&quot;;
}
</string>
  </property>
  <widget class="QWidget" name="back" native="true">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>800</width>
     <height>1000</height>
    </rect>
   </property>
   <widget class="QPushButton" name="closeButton">
    <property name="geometry">
     <rect>
      <x>735</x>
      <y>20</y>
      <width>41</width>
      <height>21</height>
     </rect>
    </property>
    <property name="styleSheet">
     <string notr="true">background-image: url(:/Resources/close.png);
background-color: rgba(255, 255, 255,0);</string>
    </property>
    <property name="text">
     <string/>
    </property>
    <property name="flat">
     <bool>true</bool>
    </property>
   </widget>
   <widget class="QPushButton" name="minButton">
    <property name="geometry">
     <rect>
      <x>684</x>
      <y>19</y>
      <width>41</width>
      <height>21</height>
     </rect>
    </property>
    <property name="styleSheet">
     <string notr="true">background-image: url(:/Resources/mini.png);
background-color: rgba(255, 255, 255,0);</string>
    </property>
    <property name="text">
     <string/>
    </property>
    <property name="flat">
     <bool>true</bool>
    </property>
   </widget>
   <widget class="QWidget" name="all" native="true">
    <property name="geometry">
     <rect>
      <x>0</x>
      <y>57</y>
      <width>801</width>
      <height>321</height>
     </rect>
    </property>
    <widget class="QPushButton" name="recordButton">
     <property name="geometry">
      <rect>
       <x>580</x>
       <y>60</y>
       <width>101</width>
       <height>101</height>
      </rect>
     </property>
     <property name="styleSheet">
      <string notr="true">QPushButton:!hover
{
background-image: url(:/Resources/record_normal.png);
}

QPushButton:hover
{
	background-image: url(:/Resources/record_hot.png);
}

QPushButton:press
{
	background-image: url(:/Resources/record_pressed.png);
}

QPushButton{
	background-color: rgba(255, 255, 255, 0);
}

</string>
     </property>
     <property name="text">
      <string/>
     </property>
     <property name="flat">
      <bool>true</bool>
     </property>
    </widget>
    <widget class="QLineEdit" name="urlEdit">
     <property name="geometry">
      <rect>
       <x>80</x>
       <y>80</y>
       <width>461</width>
       <height>61</height>
      </rect>
     </property>
     <property name="text">
      <string/>
     </property>
    </widget>
    <widget class="QLineEdit" name="widthEdit">
     <property name="geometry">
      <rect>
       <x>100</x>
       <y>200</y>
       <width>101</width>
       <height>61</height>
      </rect>
     </property>
     <property name="text">
      <string>1280</string>
     </property>
    </widget>
    <widget class="QLineEdit" name="heighEdit">
     <property name="geometry">
      <rect>
       <x>240</x>
       <y>200</y>
       <width>101</width>
       <height>61</height>
      </rect>
     </property>
     <property name="text">
      <string>720</string>
     </property>
    </widget>
    <widget class="QLabel" name="timelabel">
     <property name="geometry">
      <rect>
       <x>400</x>
       <y>160</y>
       <width>141</width>
       <height>61</height>
      </rect>
     </property>
     <property name="text">
      <string>000:00</string>
     </property>
    </widget>
    <widget class="QLabel" name="infolabel">
     <property name="geometry">
      <rect>
       <x>380</x>
       <y>240</y>
       <width>141</width>
       <height>61</height>
      </rect>
     </property>
     <property name="styleSheet">
      <string notr="true">color: rgb(188, 70, 8);
font: 15pt &quot;Ubuntu&quot;;</string>
     </property>
     <property name="text">
      <string>虾球</string>
     </property>
    </widget>
    <widget class="QLineEdit" name="fpsEdit">
     <property name="geometry">
      <rect>
       <x>620</x>
       <y>200</y>
       <width>101</width>
       <height>61</height>
      </rect>
     </property>
     <property name="text">
      <string>10</string>
     </property>
    </widget>
    <widget class="QLabel" name="label">
     <property name="geometry">
      <rect>
       <x>520</x>
       <y>220</y>
       <width>61</width>
       <height>40</height>
      </rect>
     </property>
     <property name="styleSheet">
      <string notr="true">color: rgb(164, 0, 0);
font: 20pt &quot;Ubuntu&quot;;</string>
     </property>
     <property name="text">
      <string>FPS</string>
     </property>
    </widget>
   </widget>
   <widget class="QLabel" name="title">
    <property name="geometry">
     <rect>
      <x>80</x>
      <y>0</y>
      <width>321</width>
      <height>61</height>
     </rect>
    </property>
    <property name="text">
     <string>Screen 屏幕录像机</string>
    </property>
   </widget>
   <widget class="QLabel" name="logo">
    <property name="geometry">
     <rect>
      <x>20</x>
      <y>13</y>
      <width>40</width>
      <height>40</height>
     </rect>
    </property>
    <property name="styleSheet">
     <string notr="true">border-image: url(:/Resources/logo.png);</string>
    </property>
    <property name="text">
     <string/>
    </property>
   </widget>
  </widget>
 </widget>
 <resources>
  <include location="resource.qrc"/>
 </resources>
 <connections>
  <connection>
   <sender>closeButton</sender>
   <signal>clicked()</signal>
   <receiver>Widget</receiver>
   <slot>close()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>749</x>
     <y>34</y>
    </hint>
    <hint type="destinationlabel">
     <x>714</x>
     <y>380</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>minButton</sender>
   <signal>clicked()</signal>
   <receiver>Widget</receiver>
   <slot>showMinimized()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>703</x>
     <y>37</y>
    </hint>
    <hint type="destinationlabel">
     <x>710</x>
     <y>380</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>recordButton</sender>
   <signal>clicked()</signal>
   <receiver>Widget</receiver>
   <slot>Record()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>627</x>
     <y>160</y>
    </hint>
    <hint type="destinationlabel">
     <x>626</x>
     <y>383</y>
    </hint>
   </hints>
  </connection>
 </connections>
 <slots>
  <slot>Record()</slot>
 </slots>
</ui>

CMakeLists.txt

cmake_minimum_required(VERSION 3.1)
project(opencv_example_project)

set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)


find_package(OpenCV REQUIRED)

message(STATUS "OpenCV library status:")
message(STATUS "    config: ${OpenCV_DIR}")
message(STATUS "    version: ${OpenCV_VERSION}")
message(STATUS "    libraries: ${OpenCV_LIBS}")
message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")

find_library(AVCODEC_LIBRARY avcodec)
find_library(AVFORMAT_LIBRARY avformat)
find_library(AVUTIL_LIBRARY avutil)
find_library(AVDEVICE_LIBRARY avdevice)

find_package(Qt6 COMPONENTS Core)
find_package(Qt6 COMPONENTS Gui)
find_package(Qt6 COMPONENTS Multimedia)
find_package(Qt6 COMPONENTS Widgets)


add_executable(XScreen main.cpp  resource.qrc  XAudioThread.cpp    XScreenRecord.cpp
widget.cpp  XCaptureThread.cpp  XVideoWriter.cpp)

target_link_libraries(XScreen PRIVATE 
    ${OpenCV_LIBS} 
    Qt::Core
    Qt::Gui
    Qt::Multimedia
    Qt::Widgets
    pthread 
    swresample 
    m 
    swscale 
    avformat    
    avcodec 
    avutil 
    avfilter 
    avdevice 
    postproc 
    z 
    lzma  
    rt)
虾球xz
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【Qt实现录频】
m0_45463480的博客
06-13 353
请注意，这只是一个简单的示例代码，实际应用中你可能需要处理更多的细节，如捕获不同视频格式、处理录制过程中的错误等。希望这个示例对你有所帮助，另外你也可以在Qt官方文档中找到更多关于Qt Multimedia模块的详细信息。在Qt中实现录制视频可以通过使用Qt Multimedia模块来实现。在上面的示例中，VideoRecorder类提供了一个简单的界面，其中包括一个用于录制视频的按钮。当按钮被点击时，toggleRecord()槽函数将会启动或停止录制。
Qt/C++音视频开发38-ffmpeg视频暂停录制的设计
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
04-17 1643
基本上各种播放器提供的录制视频接口，都是只有开始录制和结束录制两个，当然一般用的最多的也是这两个接口，但是实际使用过程中，还有一种可能需要中途暂停录制，暂停以后再次继续录制，将中间部分视频不需要录制，跳过这部分不需要的视频，而且录制的视频文件必须是能够正常播放的连续的。vlc和mpv都只提供了开始录制和停止录制接口，ffmpeg既然是自己解码，所以录制完全自己控制，存储的时候，每一帧的数据都要写入pts和dts，每次重新计算时间基准保证时间正确，不然不是连续的帧保存后会跳。
【QT教程】QT6音视频处理权威指南 QT音视频
QT界面开发界面美化
05-06 1997
QT6音视频处理简介QT6音视频处理简介QT6是挪威Trolltech公司（后被诺基亚收购，之后又转手给了Digia，最终由The Qt Company继续开发）开发的跨平台C++图形用户界面应用程序框架的最新版本。作为一个多功能的开发框架，QT6支持包括音视频处理在内的多种跨平台应用程序开发。QT6的发展与音视频处理QT从最初版本发展至今，一直在音视频处理领域占据重要地位。QT6在继承了之前版本的基础上，进一步增强了音视频处理能力。
【项目实战】Qt6 录制屏幕、录制声音生成MP4、AVI、MA3等（完整源码，可直接编译使用）
yegu001的博客
01-23 2523
本文将详细介绍如何利用Qt6多媒体模块中的QMediaCaptureSession、QMediaRecorder、QScreenCapture、QAudioInput、QMediaFormat等功能，实现对屏幕和声音的录制，并生成常见的媒体格式文件，如MP4、AVI、MA3等。我们将探讨如何利用这些功能来实现灵活的视频和音频参数设置，以满足不同需求下的录制和生成要求。我们将重点讨论如何配置视频和音频参数，包括分辨率、帧率、编解码器选择、音频采样率、声道设置等。
Qt/C++编写安防视频监控系统13-视频存储
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
12-16 2969
一、前言 一般视频监控行业都会选择把视频存储在本地NVR或者服务器上，而不是存储在客户端电脑，只有当用户经费预算有限的时候，或者用户特殊需求要求存储在本地客户端电脑的时候才会开启存储到本地，正常来说视频存储需要专用的硬盘来存储比较好，一个是安全性，更重要的是容量大，一般NVR可以外接8块硬盘，每个4T，一起就是32T，这个对于普通的电脑来说肯定是比不了的，尤其是现在高清视频阶段了，需要存储的视频清...
【Qt+FFmpeg】编码视频详细流程
logani的博客
10-15 1110
本文将介绍在Qt中运用ffmpeg编码视频的流程，附完整源码
Qt/C++音视频开发20-vlc内核动态保存录像文件（不需要重新编译源码）
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
03-06 1740
在vlc默认提供的保存文件方式中，通过打开的时候传入指定的参数来保存文件，直到关闭播放生成文件，这种方式简单暴力，但是不适用大部分的场景，大部分时候需要的是提供开始录制和停止录制的功能，也就是在播放过程中能够动态录制多个文件，想录制的时候就录制，要结束的时候就结束录制，很遗憾vlc并没有提供这样的函数接口。
第十四章 相机和音频录制——Qt
xiaobai06的博客
01-07 3428
一、使用相机 1.相机QCamera 使用QCameraInfo来查询系统当前可用的相机设备，一般使用其静态函数defaultCamera()来获取默认的相机设备信息，或者使用静态函数availableCameras()来获取所有可用相机列表。 使用orientation()可以获取相机的旋转角度。 QCamera类为系统相机设备提供了相应的接口，可以使用start()和stop()来开启和关闭相机。 相机拥有8种不同的状态：( 每当状态改变时都会发射statusChanged()信号 ) ————————
【QT教程】QT6音视频实战案例解析 QT音视频
最新发布
QT界面开发界面美化
05-10 850
QT6音视频概述QT6音视频概述QT6是The Qt Company发布的一款跨平台的C++图形用户界面应用程序框架，它支持多种操作系统，如Windows、Mac OS、Linux、iOS和Android等。QT框架广泛应用于软件开发领域，包括桌面应用程序、嵌入式系统、移动设备等。音视频技术在现代通信、娱乐、教育和工业等领域中扮演着重要的角色。QT6为音视频开发提供了丰富的接口和功能，使得开发者能够轻松实现音视频的采集、处理、编码、解码、播放和录制等功能。QT6音视频组件。
屏幕录像 QT+vs2015+opencv
06-30
在这个项目中，“屏幕录像 QT+vs2015+opencv”结合了三个关键组件：Qt框架、Visual Studio 2015 IDE以及OpenCV库，来实现屏幕录制功能。 首先，Qt是一个跨平台的应用程序开发框架，用C++编写，广泛用于创建图形用户...
Linux+Ubuntu+QT视频录制与保存，tcp通信。
04-27
在本项目中，我们主要关注的是使用Linux操作系统中的Ubuntu环境，结合QT库来实现视频录制与保存，并通过TCP通信协议进行数据传输。以下是对这些关键知识点的详细解释： 1. **Linux Ubuntu**: Linux Ubuntu是一个...
QT下使用ffmpeg+SDL实现音视频播放器，支持录像截图功能，提供工程源码下载
08-28
在本文中，我们将深入探讨如何在QT环境下使用ffmpeg和SDL库来开发一个功能丰富的音视频播放器，同时具备录像和截图功能。这个项目的核心在于利用这两个强大的开源工具，结合QT的图形用户界面（GUI）能力，创建出一个...
qt编写视频监控系统源码
11-07
2. **多媒体框架**：QT包含多媒体模块（QMultimedia），该模块支持音频和视频的播放、捕获和处理。在视频监控系统中，QCamera类是核心，它允许开发者访问和控制连接到系统的摄像头。 3. **视频流处理**：视频数据...
Screen-video-source-code.rar_videosource_屏幕录像_录像_视频录制C
09-24
这个"Screen-video-source-code.rar"压缩包提供的就是一个屏幕录像功能的源代码，支持多种视频和音频格式。 该源代码的核心部分可能包括以下几个关键知识点： 1. **屏幕捕获**：屏幕录像首先需要获取计算机屏幕的...
End to End GUI development with Qt5 学习笔记1---CM
虾球
07-26 2506
为什么会待审核
Qt6 tesseract-ocr 截图识字
虾球
11-14 2168
ScreenCapturer.h #ifndef SCREENCAPTURER_H #define SCREENCAPTURER_H #include "mainwindow.h" // 它是QWidget的子类 class ScreenCapturer : public QWidget { //并且在类主体的开头具有Q_OBJECT宏 Q_OBJECT public: explicit ScreenCapturer(MainWindow *w); ~ScreenCapt
QPushButton 样式设置 渐变圆角光泽按钮
虾球
11-03 1967
QPushButton 1.事件设置 2.快捷键设置 3.样式设置 QPushButton事件信号 1.click() 2.click(bool) 是否选中 3.pressed() 4.released() #include <QWidget> #include <QDebug> QT_BEGIN_NAMESPACE namespace Ui { class Widget; } QT_END_NAMESPACE class Widget : public QWidget {
Qt例子学习笔记 - Examples/Qt-6.2.0/charts/barmodelmapper
虾球
10-24 1823
//为了显示两家公司的份额偏差， //我们首先创建两个 QBoxPlotSeries 来处理月度数据。 QBoxPlotSeries *acmeSeries = new QBoxPlotSeries(); acmeSeries->setName("Acme Ltd"); QBoxPlotSeries *boxWhiskSeries = new QBoxPlotSeries(); boxWhiskSeries->setName("BoxWhisk Inc") /
视频公开课制作技术标准：音频压缩与编辑指南
"该资源主要涉及音频压缩格式和视频制作技术标准，特别是在使用EDIUS_6编辑视频的背景下。音频采用AAC(MPEG4 Part3)格式，采样率为48KHz，码流率为128Kbps，且必须是双声道并进行混音处理。视频制作标准包括课程时长...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值