Qt+VS使用FFmpeg+openGLWidget播放本地视频（附源代码）

已于 2025-01-22 10:38:03 修改
阅读量274 收藏 8
点赞数 9
分类专栏： ffmpeg 文章标签： qt ffmpeg c++
于 2024-12-16 15:48:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/he1234519/article/details/144510517
版权

下面是通过ffmpeg读取本地视频，并在openGLWidget上进行播放的方法。话不多说，上代码。

首先是封装openGLwidget播放视频的类

头文件openGLWidget.h

#ifndef OPENGLWIDGETCLASS_H
#define OPENGLWIDGETCLASS_H

#include <QObject>
#include <QOpenGLWidget>
#include <GL/gl.h>
#include <GL/glu.h>
#include <QOpenGLFunctions>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QGLWidget>
#include <QImage>
#include <QWheelEvent>

class openGLWidgetClass : public QOpenGLWidget, protected QOpenGLFunctions
{
    Q_OBJECT
public:
    explicit openGLWidgetClass(QWidget *parent = 0);


public slots:
	void initializeGL() Q_DECL_OVERRIDE;
	void resizeGL(int w, int h) Q_DECL_OVERRIDE;
	void paintGL() Q_DECL_OVERRIDE;
	void setCurrentImage(const QImage &image);
	void initTextures();
	void initShaders();
private:
	QVector<QVector3D> vertices;
	QVector<QVector2D> texCoords;
	QOpenGLShaderProgram program;
	QOpenGLTexture *texture;
	QMatrix4x4 projection;

	float ratio = 1.0;
	bool m_down = false;

	QPoint m_pt;
	float m_xoff;
	float m_yoff;
	float m_angle = 0.0f;
};

#endif // OPENGLWIDGETCLASS_H

源代码openGLWidget.cpp

#include "openGLWidget.h"
#include <QDebug>
#include <QGraphicsOpacityEffect>

openGLWidgetClass::openGLWidgetClass(QWidget *parent) : QOpenGLWidget(parent)
{
}


void openGLWidgetClass::initTextures()
{
	texture = new QOpenGLTexture(QOpenGLTexture::Target2D);
	texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
	texture->setMagnificationFilter(QOpenGLTexture::Linear);
	//重复使用纹理坐标
	//纹理坐标(1.1, 1.2)与(0.1, 0.2)相同
	texture->setWrapMode(QOpenGLTexture::ClampToEdge);
	//设置纹理大小
	texture->setSize(this->width(), this->height());
	//分配储存空间
	texture->allocateStorage();
}

void openGLWidgetClass::initShaders()
{
	//纹理坐标
	texCoords.append(QVector2D(0, 1)); //左上
	texCoords.append(QVector2D(1, 1)); //右上
	texCoords.append(QVector2D(0, 0)); //左下
	texCoords.append(QVector2D(1, 0)); //右下
	//顶点坐标
	vertices.append(QVector3D(-1, -1, 1));//左下
	vertices.append(QVector3D(1, -1, 1)); //右下
	vertices.append(QVector3D(-1, 1, 1)); //左上
	vertices.append(QVector3D(1, 1, 1));  //右上

	QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
	const char *vsrc =
		"attribute vec4 vertex;\n"
		"attribute vec2 texCoord;\n"
		"varying vec2 texc;\n"
		"void main(void)\n"
		"{\n"
		"    gl_Position = vertex;\n"
		"    texc = texCoord;\n"
		"}\n";
	vshader->compileSourceCode(vsrc);//编译顶点着色器代码

	QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
	const char *fsrc =
		"uniform sampler2D texture;\n"
		"varying vec2 texc;\n"
		"void main(void)\n"
		"{\n"
		"    gl_FragColor = texture2D(texture,texc);\n"
		"}\n";
	fshader->compileSourceCode(fsrc); //编译纹理着色器代码

	program.addShader(vshader);//添加顶点着色器
	program.addShader(fshader);//添加纹理碎片着色器
	program.bindAttributeLocation("vertex", 0);//绑定顶点属性位置
	program.bindAttributeLocation("texCoord", 1);//绑定纹理属性位置
	// 链接着色器管道
	if (!program.link())
		close();
	// 绑定着色器管道
	if (!program.bind())
		close();
}

void openGLWidgetClass::initializeGL()
{
	initializeOpenGLFunctions(); //初始化OPenGL功能函数
	glClearColor(0, 0, 0, 0);    //设置背景为黑色
	glEnable(GL_TEXTURE_2D);     //设置纹理2D功能可用
	initTextures();              //初始化纹理设置
	initShaders();               //初始化shaders
}

void openGLWidgetClass::resizeGL(int w, int h)
{
	// 计算窗口横纵比
	qreal aspect = qreal(w) / qreal(h ? h : 1);
	// 设置近平面值 3.0, 远平面值 7.0, 视场45度
	const qreal zNear = 3.0, zFar = 7.0, fov = 45.0;
	// 重设投影
	projection.setToIdentity();
	// 设置透视投影
	projection.perspective(fov, static_cast<float>(aspect), zNear, zFar);
}

void openGLWidgetClass::paintGL()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕缓存和深度缓冲
	QMatrix4x4 matrix;
	matrix.translate(0.0, 0.0, -5.0);                   //矩阵变换
	program.enableAttributeArray(0);
	program.enableAttributeArray(1);
	program.setAttributeArray(0, vertices.constData());
	program.setAttributeArray(1, texCoords.constData());
	program.setUniformValue("texture", 0); //将当前上下文中位置的统一变量设置为value
	texture->bind();  //绑定纹理
	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);//绘制纹理
	texture->release(); //释放绑定的纹理
	texture->destroy(); //消耗底层的纹理对象
	texture->create();
	texture->setMipLevels(1);
}

void openGLWidgetClass::setCurrentImage(const QImage &image)
{
	if (NULL != texture)
	{
		texture->setData(image); //设置纹理图像
		//设置纹理细节
		texture->setLevelofDetailBias(0);//值越小，图像越清晰
		update();
	}
}

下面是调用ffmpeg和openGLWidget的类

ui文件videoPlayerClass.ui

头文件videoPlayerClass.h

#pragma once

#include <QWidget>
#include <QTimer>
#include <qDebug>
#include <QTime>
#include <windows.h>
#include <QOpenGLTexture>
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QOpenGLShaderProgram>

#include "ui_videoPlayerClass.h"
#include "opencv2/opencv.hpp"
#include "openGLWidget.h"

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


class videoPlayerClass : public QWidget
{
	Q_OBJECT

public:
	videoPlayerClass(QWidget *parent = nullptr);
	~videoPlayerClass();

	void openVideo(QString videoFilePath, int frequency);
	void initWidget();
private:
	QPixmap extractFirstFrame(const char *filename);
	void updateProgress();
	void closeVideo();
	void videoToPictureFrequency(QString videoPath, int frequency);
private slots:
	void on_pushButton_left_clicked();
	void on_pushButton_play_clicked();
	void on_pushButton_right_clicked();
	void on_pushButton_stop_clicked();

private:
	Ui::videoPlayerClassClass ui;
	AVFormatContext *formatContext = nullptr;
	AVCodecContext *codecContext = nullptr;
	AVFrame *frame = nullptr;
	AVPacket *packet = nullptr;
	SwsContext *swsContext = nullptr;
	int videoStreamIndex;
	bool isPlaying;
	double speedFactor = 1.0; // 播放速度因子
	QTimer *timer = nullptr;
	QImage currentFrameImage;
	int64_t duration; // 视频总时长（以微秒为单位）
	int64_t currentTime; // 当前播放时间（以微秒为单位）

	QString m_videoFilePath;
	bool	m_isPlaying = false;
	int		m_frequency = 0;
};

源文件videoPlayerClass.cpp

#include "videoPlayerClass.h"

videoPlayerClass::videoPlayerClass(QWidget *parent)
	: QWidget(parent)
{
	ui.setupUi(this);
	// 设置定时器
	timer = new QTimer(this);
	connect(timer, &QTimer::timeout, this, &videoPlayerClass::updateProgress);
}

videoPlayerClass::~videoPlayerClass()
{
	closeVideo();
}
/*加载本地视频*/
void videoPlayerClass::openVideo(QString videoFilePath, int frequency)
{
	if (m_isPlaying && timer->isActive())
	{
		m_isPlaying = false;
		ui.horizontalSlider_progressBar->setValue(0);
		ui.pushButton_play->setStyleSheet("background-color:transparent;color:#FFFFFF;background-image: url(:/style/image/play.png);");
		timer->stop(); closeVideo();
	}
	m_videoFilePath = videoFilePath;
	m_frequency = frequency;
	/*按照固定频率截取视频图片*/
	//videoToPictureFrequency(m_videoFilePath, frequency);

	/*改变视频输出区域尺寸*/
	ui.widget->setMinimumSize(ui.widget->height() * ((float)16 / 9), ui.widget->height());
	ui.widget->setMaximumSize(ui.widget->height() * ((float)16 / 9), ui.widget->height());
	// Initialize FFmpeg
	av_register_all();
	if (formatContext) avformat_close_input(&formatContext);
	avformat_open_input(&formatContext, m_videoFilePath.toStdString().c_str(), nullptr, nullptr);
	avformat_find_stream_info(formatContext, nullptr);
	// Find video stream
	for (unsigned int i = 0; i < formatContext->nb_streams; i++) {
		if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			videoStreamIndex = i;
			AVCodecParameters *codecParameters = formatContext->streams[i]->codecpar;
			AVCodec *codec = avcodec_find_decoder(codecParameters->codec_id);
			codecContext = avcodec_alloc_context3(codec);
			avcodec_parameters_to_context(codecContext, codecParameters);
			avcodec_open2(codecContext, codec, nullptr);
			frame = av_frame_alloc();
			packet = av_packet_alloc();
			duration = formatContext->duration; // 获取视频总时长
			ui.horizontalSlider_progressBar->setMaximum(duration / AV_TIME_BASE); // 设置进度条最大值
			ui.label_videoTime->setText("00:00:00/" + QTime::fromMSecsSinceStartOfDay(duration / AV_TIME_BASE * 1000).toString("HH:mm:ss"));
			break;
		}
	}
	QPixmap pixmap_orgin = extractFirstFrame(m_videoFilePath.toStdString().c_str());
	ui.widget->setCurrentImage(pixmap_orgin.toImage());
}

void videoPlayerClass::initWidget()
{
	/*改变视频输出区域尺寸*/
	ui.widget->setMinimumSize(ui.widget->height() * ((float)16 / 9), ui.widget->height());
	ui.widget->setMaximumSize(ui.widget->height() * ((float)16 / 9), ui.widget->height());
}

/*获取视频第一帧图片*/
QPixmap videoPlayerClass::extractFirstFrame(const char *filename)
{
	AVFormatContext* fmt_ctx_ = nullptr;
	//打开视频文件
	int errCode = avformat_open_input(&fmt_ctx_, filename, nullptr, nullptr);
	if (errCode != 0) {
		qDebug() << "avformat_open_input fail" << errCode;
		return QPixmap();
	}
	//读取音视频流信息
	errCode = avformat_find_stream_info(fmt_ctx_, nullptr);
	if (errCode != 0) {
		qDebug() << "avformat_find_stream_info fail" << errCode;
		avformat_close_input(&fmt_ctx_);
		return QPixmap();
	}
	//打印输出视频相关信息
	av_dump_format(fmt_ctx_, 0, filename, 0);

	AVPacket* pkt = av_packet_alloc();
	AVFrame* temp_frame = av_frame_alloc();
	SwsContext* sws_ctx = nullptr;
	int ret = 0;
	QImage preview;
	bool preview_done = false;

	for (int i = 0; i<int(fmt_ctx_->nb_streams) && !preview_done; i++) {
		//只处理视频信息
		if (fmt_ctx_->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			//查找视频解码器
			AVCodec* codec = avcodec_find_decoder(fmt_ctx_->streams[i]->codecpar->codec_id);
			AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
			//根据提供的编解码器参数的值填充编解码器上下文
			avcodec_parameters_to_context(codec_ctx, fmt_ctx_->streams[i]->codecpar);
			//打开解码器
			avcodec_open2(codec_ctx, codec, nullptr);

			//读取帧数据
			while (av_read_frame(fmt_ctx_, pkt) >= 0) {
				av_frame_unref(temp_frame);
				//对视频帧数据进行解码
				while ((ret = avcodec_receive_frame(codec_ctx, temp_frame)) == AVERROR(EAGAIN)) {
					ret = avcodec_send_packet(codec_ctx, pkt);
					if (ret < 0) {
						qCritical() << "Failed to send packet to decoder." << ret;
						break;
					}
				}

				if (ret < 0 && ret != AVERROR_EOF) {
					qDebug() << "Failed to receive packet from decoder." << ret;
					continue;
				}
				sws_ctx = sws_getContext(
					temp_frame->width,
					temp_frame->height,
					static_cast<AVPixelFormat>(temp_frame->format),
					temp_frame->width,
					temp_frame->height,
					static_cast<AVPixelFormat>(AV_PIX_FMT_RGBA),
					SWS_FAST_BILINEAR,
					nullptr,
					nullptr,
					nullptr
				);
				int linesize[AV_NUM_DATA_POINTERS];
				linesize[0] = temp_frame->width * 4;

				//生成图片
				preview = QImage(temp_frame->width, temp_frame->height, QImage::Format_RGBA8888);
				uint8_t* data = preview.bits();
				sws_scale(sws_ctx,
					temp_frame->data,
					temp_frame->linesize,
					0,
					temp_frame->height,
					&data,
					linesize);

				sws_freeContext(sws_ctx);
				avcodec_close(codec_ctx);
				avcodec_free_context(&codec_ctx);
				preview_done = true;
				break;
			}
		}
	}
	//释放资源
	av_frame_free(&temp_frame);
	av_packet_free(&pkt);
	avformat_close_input(&fmt_ctx_);
	return QPixmap::fromImage(preview);
}
/*更新视频图像显示*/
void videoPlayerClass::updateProgress()
{
	if (!m_isPlaying) return;
	// Read frames and update progress
	if (av_read_frame(formatContext, packet) >= 0)
	{
		if (packet->stream_index == videoStreamIndex) {
			avcodec_send_packet(codecContext, packet);
			if (avcodec_receive_frame(codecContext, frame) == 0) {
				// Convert frame to QImage
				int numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, codecContext->width, codecContext->height, 1);
				uint8_t *buffer = (uint8_t *)av_malloc(numBytes);
				swsContext = sws_getContext(codecContext->width, codecContext->height,
					codecContext->pix_fmt,
					codecContext->width, codecContext->height,
					AV_PIX_FMT_RGB24,
					SWS_BILINEAR, nullptr, nullptr, nullptr);
				uint8_t *dest[1] = { buffer };
				int destLinesize[1] = { 3 * codecContext->width };
				sws_scale(swsContext, frame->data, frame->linesize, 0, codecContext->height, dest, destLinesize);

				currentFrameImage = QImage(buffer, codecContext->width, codecContext->height, QImage::Format_RGB888);
				ui.widget->setCurrentImage(currentFrameImage);
				av_free(buffer);
				sws_freeContext(swsContext);
				currentTime = frame->pts * av_q2d(formatContext->streams[videoStreamIndex]->time_base);
				ui.horizontalSlider_progressBar->setValue(currentTime); // 更新进度条
				ui.label_videoTime->setText(QTime::fromMSecsSinceStartOfDay(currentTime * 1000).toString("HH:mm:ss") + "/" + QTime::fromMSecsSinceStartOfDay(duration / AV_TIME_BASE * 1000).toString("HH:mm:ss"));
				update(); // 刷新图像显示
				return; // 处理完一帧后退出
			}
		}
	}
	else
	{
		av_packet_unref(packet);
		on_pushButton_stop_clicked();
	}
}
/*关闭ffmpeg句柄*/
void videoPlayerClass::closeVideo()
{
	timer->stop();
	if (packet) av_packet_free(&packet);
	//if (swsContext) sws_freeContext(swsContext);
	if (frame) av_frame_free(&frame);
	if (codecContext) avcodec_free_context(&codecContext);
	if (formatContext) avformat_close_input(&formatContext);
}
/*按照固定频率提取图像*/
void videoPlayerClass::videoToPictureFrequency(QString videoPath, int frequency)
{
	cv::VideoCapture cap(videoPath.toStdString().c_str()); // 打开视频文件
	if (!cap.isOpened()) {
		std::cerr << "Error: Could not open video file." << std::endl;
		return;
	}

	int frameCount = 0;
	double fps = cap.get(cv::CAP_PROP_FPS); // 获取视频的帧率
	double totalcount = cap.get(cv::CAP_PROP_FRAME_COUNT); // 获取视频的帧率

	int interval = 0; // 计算提取帧的间隔
	/*小数部分大于或等于0.5，建议向上取整*/
	if (fps / frequency - std::floor(fps / frequency) >= 0.5)
	{
		interval = std::ceil(fps / frequency);
	}
	else
	{
		interval = std::floor(fps / frequency);
	}
	cv::Mat frame;
	while (cap.read(frame))
	{
		if (static_cast<int>(frameCount % interval) == 0)
		{
			std::string filename = QApplication::applicationDirPath().toStdString() +  "/data/image/output_" + std::to_string(frameCount / interval) + ".png";
			cv::imwrite(filename, frame); // 保存帧为图片
		}
		frameCount++;
	}
	cap.release();
}

void videoPlayerClass::on_pushButton_left_clicked()
{
	speedFactor /= 2.0;
	if (m_isPlaying) {
		timer->start(30 / speedFactor); // 根据倍速调整定时器
	}
}

void videoPlayerClass::on_pushButton_play_clicked()
{
	m_isPlaying = !m_isPlaying;
	if (m_isPlaying)
	{
		timer->start(); // Set a timer to update progress
		ui.pushButton_play->setStyleSheet("background-color:transparent;color:#FFFFFF;background-image: url(:/style/image/pause.png);");
	}
	else
	{
		ui.pushButton_play->setStyleSheet("background-color:transparent;color:#FFFFFF;background-image: url(:/style/image/play.png);");
	}
}

void videoPlayerClass::on_pushButton_right_clicked()
{
	speedFactor *= 2.0;
	if (m_isPlaying) {
		timer->start(30 / speedFactor); // 根据倍速调整定时器
	}
}

void videoPlayerClass::on_pushButton_stop_clicked()
{
	m_isPlaying = false;
	ui.pushButton_play->setStyleSheet("background-color:transparent;color:#FFFFFF;background-image: url(:/style/image/play.png);");
	timer->stop();closeVideo();
	// 重新打开视频
	openVideo(m_videoFilePath , m_frequency); // 替换为实际视频路径
}

主函数调用方法，只需要调用videoPlayerClass::openVideo(QString videoFilePath, int frequency)传入对应的视频文件路径即可播放视频。

以上就是通过ffmpeg读取本地视频，并在openGLWidget上进行播放的方法。

注：如果本文章对您有所帮助，请点赞收藏支持一下，谢谢。^_^

版权声明：本文为博主原创文章，转载请附上博文链接。

Qt/C++音视频开发：使用QOpenGLWidget显示视频
CodeJolt的博客
09-14 512
在initializeGL函数中，我们需要进行一些OpenGL的初始化工作，例如创建和编译着色器程序，创建和绑定顶点缓冲区，以及设置其他OpenGL状态。希望这篇文章能帮助到你！在上述代码中，我们创建了一个MainWindow类作为主窗口，并将自定义的VideoWidget设置为主窗口的中央部件。在这个主函数中，我们创建了一个QApplication对象，然后创建了MainWindow对象，并显示出来。在paintGL函数中，我们需要清除OpenGL缓冲区，绘制视频帧，并刷新OpenGL缓冲区。
Qt音视频开发之视频播放——使用QOpenGLWidget显示
DevNinja的博客
08-15 1218
在上述代码中，updateVideo函数用于更新视频纹理，其中，data为视频帧数据。paintGL函数用于绘制OpenGL场景，其中，需要通过OpenGL函数设置渲染纹理。在代码中，需要定义一个OpenGL窗口类，继承自QOpenGLWidget，并重写其initializeGL、resizeGL和paintGL函数。其中，initializeGL函数用于初始化OpenGL，resizeGL函数用于处理窗口大小的改变，paintGL函数用于绘制OpenGL场景。
opencv+ffmpeg+QOpenGLWidget开发的音视频播放器demo
linyibin_123的博客
08-15 1966
本篇文档的demo包含了 1.使用OpenCV对图像进行处理，对图像进行置灰，旋转，抠图，高斯模糊，中值滤波，部分区域清除置黑，背景移除，边缘检测等操作；2.单纯使用opencv播放显示视频；3.使用opencv和openGL播放显示视频；4.在ffmpeg解码后，使用opencv显示视频，并支持对视频的旋转翻转、裁剪、添加文字、添加logo、亮度调节、置灰、录像截图，音频开关等功能。视频播放器同时支持本地文件与网络码流地址的播放。本篇博客的最后有提供工程代码的下载。
ffmpeg+QOpenGLWidget显示视频
最新发布
深之JohnChen的专栏
03-24 794
​一个基于 ‌FFmpeg 4.x‌ 和 QOpenGLWidget的简单视频播放器代码示例，实现视频解码和渲染到 Qt 窗口的功能。1）ffmpeg库界面，视频解码支持软解和硬解方式。硬解后，硬件解码完成需要将数据从GPU复制到CPU。优先采用av_hwframe_map函数，失败后再使用av_hwframe_transfer_data2）显示帧数据采用QOpenGLWidget。该类支持YUV420P、NV12、RGB帧数据显示。
FFmpeg4入门09：软解并使用QOpenGL播放视频（YUV420P）
qq_26056015的博客
06-07 1681
我在开发过程中Qt用的比较大，所以本系列主要界面由Qt开发。而Qt主要的特性是跨平台，在嵌入式平台中，主要使用QML进行界面开发，如果使用QML开发视频的话，就需要用到OpenGL了。本篇主要介绍常用的桌面版的QOpenGL的视频显示，桌面版解码的YUV数据格式为YUV420P，下一篇介绍QML版的视频显示，也是YUV420P格式的。解码流程图为：解码函数调用流程图为：显示流程为：解码显示流程：共分为三个部分。这个就比较简单，前面几篇文章一直在说这个，FFmpeg默认软解输出格式为YUV420P。这里需要注
Qt+FFmpeg视频播放器开发（一）
2401_82413779的博客
02-25 799
Qt+FFmpeg开发视频播放器专题介绍
qt使用FFmPeg+SDL2.0+QOpenGLWidget实现的音视频播放器，支持播放器的多数基本功能
10-16
qt使用FFmPeg+SDL2.0+QOpenGLWidget实现的视频播放器，FFmPeg+SDL2.0解码音视频，视频图像解码为YUV420的格式，然后使用QOpenGLWidget进行显示。亲测在windows和Linux下都可使用，附带FFmPeg+SDL2.0第三方库 支持功能如下： 1.各种视频的播放 2.各种音频的播放 3.播放进度条的控制，全屏控制，音量控制，下一个和上一个控制，播放、暂停、停止等 4.附带播放列表，可记录播放的视频路径 5.可播放各种网络流（rtmp，http，rtsp，flv）等 6.添加文字水印 7.播放视频的屏幕可根据视频的分辨率的大小自适应
Qt中使用QOpengGLWidget播放视频时，如果设置了窗口背景透明，视频播放会不正常
崔杰城的博客
11-06 1708
在Qt里面我们经常会用QOpengGLWidget进行YUV转RGB像素格式转换来播放视频，但如果我们在其所在的窗口中添加了如下语句： setWindowFlags(Qt::FramelessWindowHint|Qt::Tool); //设置窗口去除边框 setAttribute(Qt::WA_TranslucentBackground); //设置窗口背景透明 则播放视频时可能会不正常。 解决方法： 如果必须使用窗口透明，则播放视频不使用QOpengGLWidget。使用...
基于CUDA+ffmpeg+QT+QOpenGL的硬解码解决方案demo
12-18
"基于CUDA+ffmpeg+QT+QOpenGL的硬解码解决方案demo" 提供了一种高效、低延迟的视频解码方法，利用现代NVIDIA显卡的硬件加速能力，结合开源多媒体处理框架ffmpeg，图形用户界面库QT以及OpenGL进行实时视频渲染。...
QT软件开发-基于FFMPEG设计视频播放器-GPU硬解、OpenGL渲染、解码音频完整例子（六）
09-18 2292
前面章节编写的例 子都是独立的，没有结合在一起，当前这篇文章是将前面的几个例子结合在一起，完成一个完整的播放器Demo开发。支持硬件加速解码视频帧、通过OpenGL渲染；解码音频帧、通过QAudioOutput播放音频。支持本地视频文件播放，支持流媒体地址播放。例如：rtmp、rtsp、hls、http等等协议。支持进度条跳转（实时直播流不支持的）、进度条显示，总时间显示，视频基本信息显示，基本上完成一个播放器的基础功能。
如何用QVideoWidget播放视频
04-29
Qt播放视频文件，一个简单用Qt自己的累播放视频
qt基于FFmPeg+SDL2.0+QOpenGLWidget实现的视频播放器
09-08
qt使用FFmPeg+SDL2.0+QOpenGLWidget实现的视频播放器，FFmPeg+SDL2.0解码音视频，视频图像解码为YUV420的格式，然后使用QOpenGLWidget进行显示。亲测在windows和Linux下都可使用，附带FFmPeg+SDL2.0第三方库
一个qt+ffmpeg+opengl播放音视频的demo
01-29
一个qt+ffmpeg+opengl播放音视频的demo，存在少量bug，供学习使用，注释蛮齐全的
qt实现opengl简单例子
08-22
在本文中，我们将深入探讨如何使用Qt框架来实现OpenGL的基本功能，特别关注如何在Qt环境中创建一个OpenGLWidget，展示一个简单的OpenGL渲染实例。Qt是一个强大的跨平台应用开发框架，而OpenGL则是一种广泛应用的图形...
视频教程-学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程-计算机视觉
weixin_29716135的博客
05-28 749
学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程 夏曹...
FFMpeg-4、基于QtCreat开发使用FFMpeg解码后QTAudio和QTOpenGL播放显示
2401_89317650的博客
01-23 791
/decode->pts 是在解码AVFrame* XDcode::Recv()中进行赋值 音频解码时间pts。if(synpts > 0 && synpts < decode->pts)//视频快与音频，则要进行一下等待。//解码pts，如果接收到的解码数据pts大于seekPts return true 并显示。//将pkt发送到解码线程，不管成功与否都要释放pkt(包含两个空间对象和内部数据)//创建接口，则以后用其他显示的时候 videoThread这个类是不用变的。
01 Qt6.2.3播放YUV视频，使用QOpenGLWidget
qq582880551的博客
03-30 4427
Qt6.2.3播放YUV视频，使用QOpenGLWidget 作者 将狼才鲸 创建日期 2022-03-30 工程Gitee源码地址：qt_gui_simple2complex/ source / 004_MultiMedia_VideoAudio / 003_yuv_video_play 优快云文章阅读地址： 视频讲解地址（待完成）：才鲸嵌入式 参考资料： qt采用opengl显示yuv视频数据 Qt 创建定时器 该工程在Qt5.15.2、Qt6.0.4和Qt6.
Opencv加QOpenGLWidget 手撸视频播放器，实现自己的看片神器
热门推荐
weixin_42309565的博客
03-29 22万+
Opencv加QOpenGLWidget 手撸视频播放器，实现自己的看片神器 开发环境： VS2017+QtQt5.9.3+Opencv3.4.3 废话不多说，直接上代码 MyXVideo.h #pragma once #include <QOpenGLWidget> #include<QTimerEvent> #include <QPaintEvent> #include "opencv2/core.hpp" #include "opencv2/imgcodecs.hp
基于QT+FFMPEG+OpenGL的音视频播放Demo
而标题中提到的 "qt+ffmpeg+opengl播放音视频的demo" 就是一个结合了上述技术组件的示例应用程序。这个demo的主要功能是实现音视频播放功能，但它的核心在于演示如何使用Qt来创建GUI界面，使用FFmpeg来处理音视频的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值