qt ffmpeg rtsp 拉流 降帧率

Qt是一个跨平台的C++应用程序框架，ffmpeg是一个开源的跨平台音视频处理工具库，rtsp是一种实时流媒体传输协议。拉流是指从网络上获取流媒体数据，降帧率是指减少视频帧率。

使用Qt可以方便地实现图形界面，同时Qt也提供了QMediaPlayer类来播放音视频文件，可以通过设置QMediaPlayer::setMedia(const QMediaContent &media)来实现对网络上的rtsp流进行播放。ffmpeg可以用来处理音视频数据，并且提供了相应的接口可以在Qt中使用，同时ffmpeg也提供了降帧率的功能，可以通过设置AVStream::r_frame_rate来实现。

如果需要在Qt中使用ffmpeg，可以考虑使用QtAV这个开源项目，它提供了一个简单易用的Qt多媒体框架，支持播放各种格式的音视频文件，并且封装了ffmpeg的相关功能。

相关问题

qt ffmpeg OpenGLWidget 播放rtsp代码

以下是一个使用Qt、FFmpeg和OpenGLWidget播放RTSP流的示例代码：

首先，确保已经安装了Qt和FFmpeg库，并在Qt项目中添加了相应的依赖项。

在Qt项目中创建一个自定义的OpenGLWidget类，用于显示视频帧：

// 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

// 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中：

// 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

// 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的文档进行更详细的学习和了解。

生成一个qt下用opencv的Mat格式图片通过rkmpp编码成h264,并通过rtsp推流的程序

以下是一个Qt下使用OpenCV的Mat格式图片通过RK3399的硬件编码器RKMPP编码成H.264并通过RTSP推流的程序示例。

#include <QCoreApplication>
#include <opencv2/opencv.hpp>
#include <rockchip/rk_mpi.h>
#include <rockchip/rk_mpp.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 初始化RKMPP
    MPP_RET ret = mpp_env_init();
    if (ret != MPP_OK) {
        printf("mpp_env_init failed!\n");
        return -1;
    }

    // 创建编码器
    MppCtx ctx;
    ret = mpp_create(&ctx, MPP_CTX_ENC);
    if (ret != MPP_OK) {
        printf("mpp_create failed!\n");
        return -1;
    }

    // 配置编码器参数
    MppApi *mpi = mpp_get_api(ctx);
    MppEncPrepCfg prep_cfg;
    prep_cfg.change = MPP_ENC_PREP_CFG_CHANGE_INPUT |
                       MPP_ENC_PREP_CFG_CHANGE_FORMAT;
    prep_cfg.width = 640;
    prep_cfg.height = 480;
    prep_cfg.format = MPP_FMT_YUV420P;
    mpi->control(ctx, MPP_ENC_SET_PREP_CFG, &prep_cfg);

    MppEncCodecCfg codec_cfg;
    codec_cfg.coding = MPP_VIDEO_CodingAVC;
    codec_cfg.rc_mode = MPP_ENC_RC_MODE_CBR;
    codec_cfg.fps_in = 30;
    codec_cfg.fps_out = 30;
    codec_cfg.profile = MPP_PROFILE_AVC_MAIN;
    codec_cfg.level = MPP_LEVEL_UNKNOWN;
    codec_cfg.target_bitrate = 1000000;
    codec_cfg.qp_init = 26;
    codec_cfg.qp_max = 48;
    codec_cfg.qp_min = 20;
    mpi->control(ctx, MPP_ENC_SET_CODEC_CFG, &codec_cfg);

    // 初始化编码器
    ret = mpi->init(ctx);
    if (ret != MPP_OK) {
        printf("mpi->init failed!\n");
        return -1;
    }

    // 打开RTSP推流
    cv::VideoWriter writer;
    writer.open("rtsp://localhost:8554/test.sdp", cv::CAP_FFMPEG,
                cv::VideoWriter::fourcc('H', '2', '6', '4'), 30,
                cv::Size(640, 480), true);

    // 加载测试图片
    cv::Mat image = cv::imread("test.jpg");
    if (image.empty()) {
        printf("Failed to load image!\n");
        return -1;
    }

    // 创建输入YUV内存
    MppFrame frame;
    ret = mpi->control(ctx, MPP_ENC_GET_EXTRA_INFO, &frame);
    if (ret != MPP_OK) {
        printf("mpi->control failed!\n");
        return -1;
    }
    frame->width = 640;
    frame->height = 480;
    frame->hor_stride = 640;
    frame->ver_stride = 480;
    frame->fmt = MPP_FMT_YUV420P;
    mpp_frame_init(frame);

    // 创建输出H.264内存
    MppBuffer packet_buf;
    mpp_buffer_get(ctx, &packet_buf, 4 * 1024 * 1024);
    MppPacket packet;
    mpp_packet_init(&packet, packet_buf);

    // 编码YUV图像
    for (int i = 0; i < 100; i++) {
        // 将OpenCV的Mat格式转换为YUV格式
        cv::Mat yuv_image;
        cv::cvtColor(image, yuv_image, cv::COLOR_BGR2YUV_I420);

        // 将YUV图像写入输入YUV内存
        uint8_t *buf = (uint8_t *)mpp_buffer_get_ptr(frame->buf);
        memcpy(buf, yuv_image.data, 640 * 480 * 3 / 2);

        // 编码YUV图像
        ret = mpi->encode_put_frame(ctx, frame, NULL);
        if (ret != MPP_OK) {
            printf("mpi->encode_put_frame failed!\n");
            return -1;
        }

        // 获取编码后的H.264数据
        ret = mpi->encode_get_packet(ctx, &packet);
        if (ret != MPP_OK) {
            printf("mpi->encode_get_packet failed!\n");
            return -1;
        }

        // 将H.264数据写入RTSP推流
        writer.write(packet->data, packet->length);
    }

    // 释放资源
    writer.release();
    mpp_packet_deinit(&packet);
    mpp_buffer_put(packet_buf);
    mpp_frame_deinit(&frame);
    mpi->reset(ctx);
    mpi->control(ctx, MPP_ENC_SET_IDR_FRAME, NULL);
    mpi->destroy(ctx);
    mpp_env_deinit();

    return 0;
}

需要注意的几点：

1. 该示例程序使用的是Rockchip的RKMPP编码器。如果使用的是其他厂商的编码器，代码可能会有所不同。

2. 在编码器初始化时，需要设置编码器的参数。例如，设置编码器的分辨率、码率、帧率等。

3. 将OpenCV的Mat格式图像转换为YUV格式，并写入输入YUV内存。

4. 在编码器中，将输入YUV内存编码为H.264格式，并将编码后的数据写入输出H.264内存。

5. 将输出H.264内存的数据写入RTSP推流。在这个示例中，使用了OpenCV的VideoWriter类来实现RTSP推流。

6. 在程序结束前，需要释放所有资源。