以下是一个使用Qt、FFmpeg和OpenGLWidget播放RTSP流的示例代码：
首先，确保已经安装了Qt和FFmpeg库，并在Qt项目中添加了相应的依赖项。
在Qt项目中创建一个自定义的OpenGLWidget类，用于显示视频帧：
```cpp
// myopenglwidget.h
#ifndef MYOPENGLWIDGET_H
#define MYOPENGLWIDGET_H
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QOpenGLBuffer>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
class MyOpenGLWidget : public QOpenGLWidget, protected QOpenGLFunctions
{
Q_OBJECT
public:
explicit MyOpenGLWidget(QWidget *parent = nullptr);
~MyOpenGLWidget();
protected:
void initializeGL() override;
void resizeGL(int w, int h) override;
void paintGL() override;
private:
QOpenGLBuffer m_vertexBuffer;
QOpenGLShaderProgram m_shaderProgram;
QOpenGLTexture m_texture;
float m_vertices[12] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f
};
};
#endif // MYOPENGLWIDGET_H
```
```cpp
// myopenglwidget.cpp
#include "myopenglwidget.h"
MyOpenGLWidget::MyOpenGLWidget(QWidget *parent)
: QOpenGLWidget(parent)
{
}
MyOpenGLWidget::~MyOpenGLWidget()
{
}
void MyOpenGLWidget::initializeGL()
{
initializeOpenGLFunctions();
m_vertexBuffer.create();
m_vertexBuffer.bind();
m_vertexBuffer.allocate(m_vertices, sizeof(m_vertices));
m_shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex,
"attribute vec3 aPosition;"
"void main() {"
" gl_Position = vec4(aPosition, 1.0);"
"}");
m_shaderProgram.link();
m_shaderProgram.bind();
m_texture.create();
m_texture.setMinificationFilter(QOpenGLTexture::Nearest);
m_texture.setMagnificationFilter(QOpenGLTexture::Linear);
}
void MyOpenGLWidget::resizeGL(int w, int h)
{
glViewport(0, 0, w, h);
}
void MyOpenGLWidget::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT);
m_vertexBuffer.bind();
m_shaderProgram.bind();
int vertexLocation = m_shaderProgram.attributeLocation("aPosition");
m_shaderProgram.enableAttributeArray(vertexLocation);
m_shaderProgram.setAttributeBuffer(vertexLocation, GL_FLOAT, 0, 3);
glDrawArrays(GL_QUADS, 0, 4);
}
```
接下来，创建一个Qt窗口类，并在其中使用FFmpeg来解码和播放RTSP流，并将帧渲染到OpenGLWidget中：
```cpp
// mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QThread>
#include <QTimer>
#include <QImage>
#include <QMutex>
#include "myopenglwidget.h"
extern "C" {
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
class VideoDecoder : public QThread
{
Q_OBJECT
public:
explicit VideoDecoder(QObject *parent = nullptr);
~VideoDecoder();
void setUrl(const QString &url);
void stop();
signals:
void frameDecoded(const QImage &image);
protected:
void run() override;
private:
QString m_url;
bool m_stopRequested;
QMutex m_mutex;
void decodePacket(AVPacket *packet, AVCodecContext *codecContext, SwsContext *swsContext);
};
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();
private slots:
void onFrameDecoded(const QImage &image);
void onTimerTimeout();
private:
MyOpenGLWidget *m_openglWidget;
VideoDecoder *m_videoDecoder;
QTimer *m_timer;
};
#endif // MAINWINDOW_H
```
```cpp
// mainwindow.cpp
#include "mainwindow.h"
VideoDecoder::VideoDecoder(QObject *parent)
: QThread(parent),
m_stopRequested(false)
{
}
VideoDecoder::~VideoDecoder()
{
stop();
}
void VideoDecoder::setUrl(const QString &url)
{
m_url = url;
}
void VideoDecoder::stop()
{
QMutexLocker locker(&m_mutex);
m_stopRequested = true;
}
void VideoDecoder::run()
{
av_register_all();
AVFormatContext *formatContext = nullptr;
AVCodecContext *codecContext = nullptr;
SwsContext *swsContext = nullptr;
if (avformat_open_input(&formatContext, m_url.toUtf8().constData(), nullptr, nullptr) != 0) {
qDebug() << "Failed to open input file";
return;
}
if (avformat_find_stream_info(formatContext, nullptr) < 0) {
qDebug() << "Failed to find stream info";
avformat_close_input(&formatContext);
return;
}
int videoStreamIndex = -1;
for (unsigned int i = 0; i < formatContext->nb_streams; ++i) {
if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStreamIndex = i;
break;
}
}
if (videoStreamIndex == -1) {
qDebug() << "Failed to find video stream";
avformat_close_input(&formatContext);
return;
}
AVCodec *codec = avcodec_find_decoder(formatContext->streams[videoStreamIndex]->codecpar->codec_id);
if (!codec) {
qDebug() << "Failed to find decoder";
avformat_close_input(&formatContext);
return;
}
codecContext = avcodec_alloc_context3(codec);
if (!codecContext) {
qDebug() << "Failed to allocate codec context";
avformat_close_input(&formatContext);
return;
}
if (avcodec_parameters_to_context(codecContext, formatContext->streams[videoStreamIndex]->codecpar) < 0) {
qDebug() << "Failed to copy codec parameters to context";
avcodec_free_context(&codecContext);
avformat_close_input(&formatContext);
return;
}
if (avcodec_open2(codecContext, codec, nullptr) < 0) {
qDebug() << "Failed to open codec";
avcodec_free_context(&codecContext);
avformat_close_input(&formatContext);
return;
}
AVPacket *packet = av_packet_alloc();
AVFrame *frame = av_frame_alloc();
swsContext = sws_getContext(codecContext->width, codecContext->height, codecContext->pix_fmt,
codecContext->width, codecContext->height, AV_PIX_FMT_RGB24,
SWS_BILINEAR, nullptr, nullptr, nullptr);
while (av_read_frame(formatContext, packet) >= 0) {
if (m_stopRequested)
break;
if (packet->stream_index == videoStreamIndex) {
decodePacket(packet, codecContext, swsContext);
}
av_packet_unref(packet);
}
av_packet_free(&packet);
av_frame_free(&frame);
avcodec_free_context(&codecContext);
avformat_close_input(&formatContext);
sws_freeContext(swsContext);
}
void VideoDecoder::decodePacket(AVPacket *packet, AVCodecContext *codecContext, SwsContext *swsContext)
{
AVFrame *frame = av_frame_alloc();
int ret = avcodec_send_packet(codecContext, packet);
if (ret < 0) {
qDebug() << "Error sending packet to decoder";
av_frame_free(&frame);
return;
}
ret = avcodec_receive_frame(codecContext, frame);
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
av_frame_free(&frame);
return;
} else if (ret < 0) {
qDebug() << "Error receiving frame from decoder";
av_frame_free(&frame);
return;
}
QImage image(codecContext->width, codecContext->height, QImage::Format_RGB888);
uint8_t *srcData[4] = { frame->data[0], frame->data[1], frame->data[2], nullptr };
int srcLinesize[4] = { frame->linesize[0], frame->linesize[1], frame->linesize[2], 0 };
uint8_t *dstData[1] = { image.bits() };
int dstLinesize[1] = { image.bytesPerLine() };
sws_scale(swsContext, srcData, srcLinesize, 0, codecContext->height, dstData, dstLinesize);
emit frameDecoded(image);
av_frame_free(&frame);
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent),
m_openglWidget(new MyOpenGLWidget(this)),
m_videoDecoder(new VideoDecoder(this)),
m_timer(new QTimer(this))
{
setCentralWidget(m_openglWidget);
connect(m_videoDecoder, &VideoDecoder::frameDecoded, this, &MainWindow::onFrameDecoded);
connect(m_timer, &QTimer::timeout, this, &MainWindow::onTimerTimeout);
// 设置RTSP流的URL
QString rtspUrl = "rtsp://example.com/stream";
m_videoDecoder->setUrl(rtspUrl);
m_videoDecoder->start();
// 设置定时器来刷新OpenGLWidget
int frameRate = 30; // 帧率
int timerInterval = 1000 / frameRate;
m_timer->start(timerInterval);
}
MainWindow::~MainWindow()
{
m_videoDecoder->stop();
m_videoDecoder->wait();
}
void MainWindow::onFrameDecoded(const QImage &image)
{
m_openglWidget->update(); // 触发OpenGLWidget的重绘事件
}
void MainWindow::onTimerTimeout()
{
// 在OpenGLWidget的paintGL()函数中绘制当前帧
QMutexLocker locker(m_videoDecoder->getMutex());
QImage image = m_videoDecoder->getImage();
if (!image.isNull()) {
// 将图像数据复制到OpenGLWidget中
// ...
// 更新OpenGLWidget
m_openglWidget->update();
}
}
```
这只是一个简单的示例，具体的实现可能会根据你的需求有所调整。你可以根据实际情况修改代码以适应你的应用程序。同时，你还需要根据Qt和FFmpeg的文档进行更详细的学习和了解。