QT+FFmpeg 使用 GPU 加速解码

精选原创

鱼弦CTO 2024-11-18 09:51:21 博主文章分类：基础 ©著作权

文章标签 ide CUDA qt ffmpeg GPU 文章分类 C/C++ 后端开发 私藏项目实操分享

©著作权归作者所有：来自51CTO博客作者鱼弦CTO的原创作品，请联系作者获取转载授权，否则将追究法律责任

QT+FFmpeg 使用 GPU 加速解码

介绍

在现代多媒体应用中，视频解码是一个计算密集型任务。使用 GPU 来加速解码可以显著提高性能，降低 CPU 的负载和功耗。QT 是一个流行的 C++ 框架，用于开发跨平台应用，而 FFmpeg 是一个强大的开源多媒体框架，支持音频、视频的编解码。结合两者，可以构建高效的视频处理应用。

应用使用场景

视频播放器：需要实时解码和渲染视频流。
视频编辑软件：对大量视频进行解码、剪辑、合成等操作。
视频监控系统：要求低延迟和高并发的视频解码。
游戏引擎：用于渲染复杂的视频内容。

实现上述应用程序涉及复杂的系统设计和大量代码，这里只能给出每个应用场景的一些基本代码示例，帮助理解各项技术的实现方法。

1. 视频播放器

视频播放器通常需要实时解码和渲染视频流。可以使用开源库如FFmpeg进行解码，用SDL进行渲染。

// C语言中的简单视频播放器示例
#include <stdio.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <SDL2/SDL.h>

int main(int argc, char *argv[]) {
    const char *filename = "video.mp4";
    
    // Initialize FFmpeg
    av_register_all();
    
    AVFormatContext *pFormatCtx = NULL;
    if (avformat_open_input(&pFormatCtx, filename, NULL, NULL) != 0)
        return -1;

    if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
        return -1;
    
    // Find the first video stream
    int videoStream = -1;
    for (int i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStream = i;
            break;
        }
    }
    if (videoStream == -1)
        return -1;

    AVCodecParameters *pCodecParam = pFormatCtx->streams[videoStream]->codecpar;
    AVCodec *pCodec = avcodec_find_decoder(pCodecParam->codec_id);
    if (!pCodec)
        return -1;

    AVCodecContext *pCodecCtx = avcodec_alloc_context3(pCodec);
    avcodec_parameters_to_context(pCodecCtx, pCodecParam);

    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
        return -1;

    // Initialize SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
        return -1;

    SDL_Window *window = SDL_CreateWindow("Video Player", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 
                                          pCodecCtx->width, pCodecCtx->height, SDL_WINDOW_OPENGL);

    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_IYUV, SDL_TEXTUREACCESS_STREAMING, 
                                             pCodecCtx->width, pCodecCtx->height);

    AVFrame *pFrame = av_frame_alloc();
    AVPacket packet;
    struct SwsContext *sws_ctx = sws_getContext(
        pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
        pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P,
        SWS_BILINEAR, NULL, NULL, NULL);

    while (av_read_frame(pFormatCtx, &packet) >= 0) {
        if (packet.stream_index == videoStream) {
            avcodec_send_packet(pCodecCtx, &packet);
            if (avcodec_receive_frame(pCodecCtx, pFrame) == 0) {
                uint8_t *data[AV_NUM_DATA_POINTERS];
                int linesize[AV_NUM_DATA_POINTERS];
                av_image_fill_arrays(data, linesize, (const uint8_t *)pFrame->data[0], AV_PIX_FMT_YUV420P, 
                                     pCodecCtx->width, pCodecCtx->height, 1);

                sws_scale(sws_ctx, (const uint8_t * const *)pFrame->data, pFrame->linesize, 0, 
                          pCodecCtx->height, data, linesize);

                SDL_UpdateYUVTexture(texture, NULL, data[0], linesize[0], data[1], linesize[1], data[2], linesize[2]);
                SDL_RenderClear(renderer);
                SDL_RenderCopy(renderer, texture, NULL, NULL);
                SDL_RenderPresent(renderer);
            }
        }
        av_packet_unref(&packet);
    }

    av_frame_free(&pFrame);
    avcodec_free_context(&pCodecCtx);
    avformat_close_input(&pFormatCtx);
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

2. 视频编辑软件

视频编辑软件需要对大量视频进行解码、剪辑、合成等操作。以下是一个简单的视频合成示例，仍然利用FFmpeg.

# 使用FFmpeg命令行工具来进行视频编辑和合成
ffmpeg -i input1.mp4 -i input2.mp4 -filter_complex "[0:v][1:v]hstack=inputs=2[v]" -map "[v]" output.mp4

这个命令将两个视频水平并排合成为一个视频。

3. 视频监控系统

视频监控系统要求低延迟和高并发的视频解码，可以使用GStreamer来快速处理和显示视频流。

# 使用GStreamer命令行工具以低延迟方式播放RTSP视频流
gst-launch-1.0 rtspsrc location=rtsp://your_camera_feed ! decodebin ! autovideosink

4. 游戏引擎

现代游戏引擎如Unity或Unreal Engine内置强大的视频处理能力，下面是一个在Unity中播放视频的简单C#脚本示例：

using UnityEngine;
using UnityEngine.Video;

public class SimpleVideoPlayer : MonoBehaviour
{
    public VideoPlayer videoPlayer;

    void Start()
    {
        // Set the Video URL (local file or online streaming)
        videoPlayer.url = "http://path/to/your/video.mp4";

        // Play the video
        videoPlayer.Play();
    }
}

原理解释

GPU 解码利用硬件加速来实现高效的视频解码过程。通常，通过 CUDA、OpenCL 或特定硬件接口（如 NVIDIA 的 NVDEC）与 GPU 交互，以执行解码任务。

算法原理流程图

+--------------------+
|   Input Video File |
+---------+----------+
          |
          v
+---------------------------+
|   FFmpeg Demuxer          |
| (Extracts video streams)  |
+-----------+---------------+
            |
            v
+---------------------------+
|  GPU Video Decoder        |
| (Using NVDEC/CUDA APIs)   |
+-----------+---------------+
            |
            v
+---------------------------+
|   Rendered on Screen      |
|  (Using Qt/OpenGL)        |
+---------------------------+

算法原理解释

Demuxing：从视频文件中提取音视频流。
GPU 解码：将压缩的视频流传递给 GPU，使用硬件解码器（如 NVIDIA 的 NVDEC）进行解码。
渲染：将解码后的帧传递到屏幕上显示，通过 OpenGL 和 Qt 实现。

实际详细应用代码示例实现

以下是一个简单的代码片段，展示如何利用 FFmpeg 和 CUDA 进行视频解码：

#include <QApplication>
#include <QWidget>
#include <QTimer>
extern "C" {
    #include <libavcodec/avcodec.h>
    #include <libavformat/avformat.h>
    #include <libavutil/hwcontext.h>
}

void decode_video(const char* filename) {
    // Initialize FFmpeg and open the input file
    av_register_all();
    AVFormatContext *fmt_ctx = nullptr;
    avformat_open_input(&fmt_ctx, filename, nullptr, nullptr);
    
    // Find the first valid video stream
    AVCodecContext *dec_ctx = nullptr;
    AVStream *video_stream = nullptr;
    for (unsigned i = 0; i < fmt_ctx->nb_streams; i++) {
        if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            AVCodec *decoder = avcodec_find_decoder(fmt_ctx->streams[i]->codecpar->codec_id);
            dec_ctx = avcodec_alloc_context3(decoder);
            avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[i]->codecpar);
            avcodec_open2(dec_ctx, decoder, nullptr);
            video_stream = fmt_ctx->streams[i];
            break;
        }
    }

    // Setup hardware decoding
    AVBufferRef *hw_device_ctx = nullptr;
    av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_CUDA, nullptr, nullptr, 0);
    dec_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);

    // Decode frames
    AVPacket pkt;
    av_init_packet(&pkt);
    while (av_read_frame(fmt_ctx, &pkt) >= 0) {
        if (pkt.stream_index == video_stream->index) {
            avcodec_send_packet(dec_ctx, &pkt);
            AVFrame *frame = av_frame_alloc();
            while (avcodec_receive_frame(dec_ctx, frame) >= 0) {
                // Process the decoded frame (display/render)
                av_frame_free(&frame);
            }
        }
        av_packet_unref(&pkt);
    }

    // Clean up
    avcodec_free_context(&dec_ctx);
    avformat_close_input(&fmt_ctx);
    av_buffer_unref(&hw_device_ctx);
}

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QWidget window;
    window.setWindowTitle("GPU Accelerated Video Decoder");
    window.show();

    QTimer::singleShot(0, [&]() { decode_video("sample_video.mp4"); });

    return app.exec();
}