音視頻/FFmpeg #Qt

Qt-FFmpeg開發-保存視頻流裸流??

音視頻/FFmpeg #Qt
Qt-FFmpeg開發-保存視頻流裸流??
- 1、概述??
- 2、實作效果??
- 3、FFmpeg保存裸流代碼流程??
- 4、主要代碼??
- 5、完整源代碼??

更多精彩內容
??個人內容分類匯總 ??
??音視頻開發 ??

1、概述??

最近研究了一下FFmpeg開發，功能實在是太強大了，網上ffmpeg3、4的文章還是很多的，但是學習嘛，最新的還是不能放過，就選了一個最新的ffmpeg n5.1.2版本，和3、4版本api變化還是挺大的；

在這個Demo里主要使用Qt + FFmpeg開發一個簡單的【視頻播放器】，支持【保存視頻流裸流】功能，這里主要使用的是【軟解碼】，需要使用硬解碼的可以看之前的文章；

同時為了盡可能的簡單，這里沒有進行音頻解碼和播放，只是單獨的進行視頻解碼播放；

再日常開發中，經常有將播放的網路視頻流影像保存到本地視頻檔案中的需求，但是如果將影像重新編碼保存則會非常消耗CPU資源，裸流資料一般是H264格式的資料，這里其實可以直接將網路視頻流未解碼的AVPacket直接保存到視頻檔案中，不需要編碼，可大大降低資源占用；

并且直接保存裸流的代碼流程不重新編碼/轉碼保存的流程簡單許多，

開發環境說明

系統：Windows10、Ubuntu20.04
Qt版本：V5.12.5
編譯器：MSVC2017-64、GCC/G++64
FFmpeg版本：n5.1.2
- 注意：如果使用了較低版本的庫，程式中部分功能可能會存在問題，不會兼容，
- 官方下載
- 我使用的庫

2、實作效果??

ffmpeg音視頻庫【軟解碼】實作的視頻播放器；

支持打開本地視頻檔案（如mp4、mov、avi等）、網路視頻流（rtsp、rtmp、http等）；

支持視頻勻速播放；

采用QPainter進行顯示，支持自適應視窗縮放；

視頻播放支持實時開始/關閉、暫停/繼續播放；

視頻解碼、執行緒控制、顯示各部分功能分離，低耦合度，

采用最新的5.1.2版本ffmpeg庫進行開發，超詳細注釋資訊，將所有踩過的坑、解決辦法、注意事項都得很寫清楚，

在使用ffmpeg打開網路視頻流時，如果是【h264裸流可以直接保存為本地檔案】，不需要進行編碼操作，

3、FFmpeg保存裸流代碼流程??

白色部分： 主要為打開讀取網路視頻流、解碼流程；
綠色部分： 主要是打開輸出檔案，將裸流保存到檔案的流程，

4、主要代碼??

啥也不說了，直接上代碼，一切有注釋

videodecode.h檔案

/******************************************************************************
 * @檔案名     videodecode.h
 * @功能       視頻解碼類，在這個類中呼叫ffmpeg打開視頻進行解碼，并且打開輸出檔案，將h264裸流保存
 *
 * @開發者     mhf
 * @郵箱       [email protected]
 * @時間       2022/09/15
 * @備注
 *****************************************************************************/
#ifndef VIDEODECODE_H
#define VIDEODECODE_H

#include <QString>
#include <QSize>

struct AVFormatContext;
struct AVCodecContext;
struct AVRational;
struct AVPacket;
struct AVFrame;
struct SwsContext;
struct AVBufferRef;
struct AVStream;
class QImage;

class VideoDecode
{
public:
    VideoDecode();
    ~VideoDecode();

    bool open(const QString& url = QString());    // 打開媒體檔案，或者流媒體rtmp、strp、http
    QImage read();                               // 讀取視頻影像
    void close();                                 // 關閉
    bool isEnd();                                 // 是否讀取完成
    const qint64& pts();                          // 獲取當前幀顯示時間

private:
    void initFFmpeg();                            // 初始化ffmpeg庫（整個程式中只需加載一次）
    void showError(int err);                      // 顯示ffmpeg執行錯誤時的錯誤資訊
    qreal rationalToDouble(AVRational* rational); // 將AVRational轉換為double
    void clear();                                 // 清空讀取緩沖
    void free();                                  // 釋放
    bool openSave();                              // 打開輸出檔案并初始化

private:
    AVFormatContext* m_formatContext = nullptr;   // 解封裝背景關系
    AVCodecContext*  m_codecContext  = nullptr;   // 解碼器背景關系
    SwsContext*      m_swsContext    = nullptr;   // 影像轉換背景關系
    AVPacket* m_packet = nullptr;                 // 資料包
    AVFrame*  m_frame  = nullptr;                 // 解碼后的視頻幀
    int    m_videoIndex   = 0;                    // 視頻流索引
    qint64 m_totalTime    = 0;                    // 視頻總時長
    qint64 m_totalFrames  = 0;                    // 視頻總幀數
    qint64 m_obtainFrames = 0;                    // 視頻當前獲取到的幀數
    qint64 m_pts          = 0;                    // 影像幀的顯示時間
    qreal  m_frameRate    = 0;                    // 視頻幀率
    QSize  m_size;                                // 視頻解析度大小
    char*  m_error = nullptr;                     // 保存例外資訊
    bool   m_end = false;                         // 視頻讀取完成
    uchar* m_buffer = nullptr;                    // YUV影像需要轉換位RGBA影像，這里保存轉換后的圖形資料

    /********  保存裸流使用 ******************/
    AVFormatContext* m_formatContextSave = nullptr;  // 封裝背景關系
    QString m_strCodecName;                          // 編解碼器名稱
    AVStream* m_videoStream = nullptr;               // 輸出視頻流
    bool m_writeHeader = false;                      // 是否寫入檔案頭
};

#endif // VIDEODECODE_H

videodecode.cpp檔案

#include "videodecode.h"
#include <QDebug>
#include <QDir>
#include <QImage>
#include <QMutex>
#include <qdatetime.h>


extern "C" {        // 用C規則編譯指定的代碼
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/avutil.h"
#include "libswscale/swscale.h"
#include "libavutil/imgutils.h"

}

#define ERROR_LEN 1024  // 例外資訊陣列長度
#define PRINT_LOG 1

VideoDecode::VideoDecode()
{
//    initFFmpeg();      // 5.1.2版本不需要呼叫了

    m_error = new char[ERROR_LEN];
}

VideoDecode::~VideoDecode()
{
    close();
}

/**
 * @brief 初始化ffmpeg庫（整個程式中只需加載一次）
 *        舊版本的ffmpeg需要注冊各種檔案格式、解復用器、對網路庫進行全域初始化，
 *        在新版本的ffmpeg中紛紛棄用了，不需要注冊了
 */
void VideoDecode::initFFmpeg()
{
    static bool isFirst = true;
    static QMutex mutex;
    QMutexLocker locker(&mutex);
    if(isFirst)
    {
        //        av_register_all();         // 已經從原始碼中洗掉
        /**
         * 初始化網路庫,用于打開網路流媒體，此函式僅用于解決舊GnuTLS或OpenSSL庫的執行緒安全問題，
         * 一旦洗掉對舊GnuTLS和OpenSSL庫的支持，此函式將被棄用，并且此函式不再有任何用途，
         */
        avformat_network_init();
        isFirst = false;
    }
}

/**
 * @brief      打開媒體檔案，或者流媒體，例如rtmp、strp、http
 * @param url  視頻地址
 * @return     true：成功  false：失敗
 */
bool VideoDecode::open(const QString &url)
{
    if(url.isNull()) return false;

    AVDictionary* dict = nullptr;
    av_dict_set(&dict, "rtsp_transport", "tcp", 0);      // 設定rtsp流使用tcp打開，如果打開失敗錯誤資訊為【Error number -135 occurred】可以切換（UDP、tcp、udp_multicast、http），比如vlc推流就需要使用udp打開
//    av_dict_set(&dict, "max_delay", "3", 0);             // 設定最大復用或解復用延遲（以微秒為單位），當通過【UDP】 接收資料時，解復用器嘗試重新排序接收到的資料包（因為它們可能無序到達，或者資料包可能完全丟失），這可以通過將最大解復用延遲設定為零（通過max_delayAVFormatContext 欄位）來禁用，
//    av_dict_set(&dict, "timeout", "1000000", 0);         // 以微秒為單位設定套接字 TCP I/O 超時，如果等待時間過短，也可能會還沒連接就回傳了，

    // 打開輸入流并回傳解封裝背景關系
    int ret = avformat_open_input(&m_formatContext,          // 回傳解封裝背景關系
                                  url.toStdString().data(),  // 打開視頻地址
                                  nullptr,                   // 如果非null，此引數強制使用特定的輸入格式，自動選擇解封裝器（檔案格式）
                                  &dict);                    // 引數設定
    // 釋放引數字典
    if(dict)
    {
        av_dict_free(&dict);
    }
    // 打開視頻失敗
    if(ret < 0)
    {
        showError(ret);
        free();
        return false;
    }

    // 讀取媒體檔案的資料包以獲取流資訊，
    ret = avformat_find_stream_info(m_formatContext, nullptr);
    if(ret < 0)
    {
        showError(ret);
        free();
        return false;
    }
    m_totalTime = m_formatContext->duration / (AV_TIME_BASE / 1000); // 計算視頻總時長（毫秒）
#if PRINT_LOG
    qDebug() << QString("視頻總時長：%1 ms，[%2]").arg(m_totalTime).arg(QTime::fromMSecsSinceStartOfDay(int(m_totalTime)).toString("HH:mm:ss zzz"));
#endif

    // 通過AVMediaType列舉查詢視頻流ID（也可以通過遍歷查找），最后一個引數無用
    m_videoIndex = av_find_best_stream(m_formatContext, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
    if(m_videoIndex < 0)
    {
        showError(m_videoIndex);
        free();
        return false;
    }

    AVStream* videoStream = m_formatContext->streams[m_videoIndex];  // 通過查詢到的索引獲取視頻流

    // 獲取視頻影像解析度（AVStream中的AVCodecContext在新版本中棄用，改為使用AVCodecParameters）
    m_size.setWidth(videoStream->codecpar->width);
    m_size.setHeight(videoStream->codecpar->height);
    m_frameRate = rationalToDouble(&videoStream->avg_frame_rate);  // 視頻幀率

    // 通過解碼器ID獲取視頻解碼器（新版本回傳值必須使用const）
    const AVCodec* codec = avcodec_find_decoder(videoStream->codecpar->codec_id);
    m_totalFrames = videoStream->nb_frames;
    m_strCodecName = codec->name;

#if PRINT_LOG
    qDebug() << QString("解析度：[w:%1,h:%2] 幀率：%3  總幀數：%4  解碼器：%5")
                .arg(m_size.width()).arg(m_size.height()).arg(m_frameRate).arg(m_totalFrames).arg(codec->name);
#endif

    // 分配AVCodecContext并將其欄位設定為默認值，
    m_codecContext = avcodec_alloc_context3(codec);
    if(!m_codecContext)
    {
#if PRINT_LOG
        qWarning() << "創建視頻解碼器背景關系失敗！";
#endif
        free();
        return false;
    }

    // 使用視頻流的codecpar為解碼器背景關系賦值
    ret = avcodec_parameters_to_context(m_codecContext, videoStream->codecpar);
    if(ret < 0)
    {
        showError(ret);
        free();
        return false;
    }

    m_codecContext->flags2 |= AV_CODEC_FLAG2_FAST;    // 允許不符合規范的加速技巧，
    m_codecContext->thread_count = 8;                 // 使用8執行緒解碼

    // 初始化解碼器背景關系，如果之前avcodec_alloc_context3傳入了解碼器，這里設定NULL就可以
    ret = avcodec_open2(m_codecContext, nullptr, nullptr);
    if(ret < 0)
    {
        showError(ret);
        free();
        return false;
    }

    // 分配AVPacket并將其欄位設定為默認值，
    m_packet = av_packet_alloc();
    if(!m_packet)
    {
#if PRINT_LOG
        qWarning() << "av_packet_alloc() Error！";
#endif
        free();
        return false;
    }
    // 分配AVFrame并將其欄位設定為默認值，
    m_frame = av_frame_alloc();
    if(!m_frame)
    {
#if PRINT_LOG
        qWarning() << "av_frame_alloc() Error！";
#endif
        free();
        return false;
    }

    // 分配影像空間
    int size = av_image_get_buffer_size(AV_PIX_FMT_RGBA, m_size.width(), m_size.height(), 4);
    /**
     * 【注意：】這里可以多分配一些，否則如果只是安裝size分配，大部分視頻影像資料拷貝沒有問題，
     *         但是少部分視頻影像在使用sws_scale()拷貝時會超出陣列長度，在使用使用msvc debug模式時delete[] m_buffer會報錯（HEAP CORRUPTION DETECTED: after Normal block(#32215) at 0x000001AC442830370.CRT delected that the application wrote to memory after end of heap buffer）
     *         特別是這個視頻流http://vfx.mtime.cn/Video/2019/02/04/mp4/190204084208765161.mp4
     */
    m_buffer = new uchar[size + 1000];    // 這里多分配1000個位元組就基本不會出現拷貝超出的情況了，反正不缺這點記憶體
//    m_image = new QImage(m_buffer, m_size.width(), m_size.height(), QImage::Format_RGBA8888);  // 這種方式分配記憶體大部分情況下也可以，但是因為存在拷貝超出陣列的情況，delete時也會報錯
    m_end = false;

    return openSave();
}

/**
 * @brief
 * @return
 */
QImage VideoDecode::read()
{
    // 如果沒有打開則回傳
    if(!m_formatContext)
    {
        return QImage();
    }

    // 讀取下一幀資料
    int readRet = av_read_frame(m_formatContext, m_packet);
    if(readRet < 0)
    {
        avcodec_send_packet(m_codecContext, m_packet); // 讀取完成后向解碼器中傳如空AVPacket，否則無法讀取出最后幾幀
    }
    else
    {
        if(m_packet->stream_index == m_videoIndex)     // 如果是影像資料則進行解碼
        {
            if(m_formatContextSave)
            {
                // 由于保存的m_formatContextSave只創建了一個視頻流，而讀取到的影像的流索引不一定為0，可能會出現錯誤【Invalid packet stream index: 1】
                // 所以這里需要將stream_index指定為和m_formatContextSave中視頻流索引相同，因為就一個流，所以直接設定為0
                m_packet->stream_index = 0;
                av_write_frame(m_formatContextSave, m_packet);   // 將資料包寫入輸出媒體檔案
            }
            // 計算當前幀時間（毫秒）
#if 1       // 方法一：適用于所有場景，但是存在一定誤差
            m_packet->pts = qRound64(m_packet->pts * (1000 * rationalToDouble(&m_formatContext->streams[m_videoIndex]->time_base)));
            m_packet->dts = qRound64(m_packet->dts * (1000 * rationalToDouble(&m_formatContext->streams[m_videoIndex]->time_base)));
#else       // 方法二：適用于播放本地視頻檔案，計算每一幀時間較準，但是由于網路視頻流無法獲取總幀數，所以無法適用
            m_obtainFrames++;
            m_packet->pts = qRound64(m_obtainFrames * (qreal(m_totalTime) / m_totalFrames));
#endif
            // 將讀取到的原始資料包傳入解碼器
            int ret = avcodec_send_packet(m_codecContext, m_packet);
            if(ret < 0)
            {
                showError(ret);
            }
        }
    }
    av_packet_unref(m_packet);  // 釋放資料包，參考計數-1，為0時釋放空間

    int ret = avcodec_receive_frame(m_codecContext, m_frame);
    if(ret < 0)
    {
        av_frame_unref(m_frame);
        if(readRet < 0)
        {
            m_end = true;     // 當無法讀取到AVPacket并且解碼器中也沒有資料時表示讀取完成
        }
        return QImage();
    }

    m_pts = m_frame->pts;

    // 為什么影像轉換背景關系要放在這里初始化呢，是因為m_frame->format，如果使用硬體解碼，解碼出來的影像格式和m_codecContext->pix_fmt的影像格式不一樣，就會導致無法轉換為QImage
    if(!m_swsContext)
    {
        // 獲取快取的影像轉換背景關系，首先校驗引數是否一致，如果校驗不通過就釋放資源；然后判斷背景關系是否存在，如果存在直接復用，如不存在進行分配、初始化操作
        m_swsContext = sws_getCachedContext(m_swsContext,
                                            m_frame->width,                     // 輸入影像的寬度
                                            m_frame->height,                    // 輸入影像的高度
                                            (AVPixelFormat)m_frame->format,     // 輸入影像的像素格式
                                            m_size.width(),                     // 輸出影像的寬度
                                            m_size.height(),                    // 輸出影像的高度
                                            AV_PIX_FMT_RGBA,                    // 輸出影像的像素格式
                                            SWS_BILINEAR,                       // 選擇縮放演算法(只有當輸入輸出影像大小不同時有效),一般選擇SWS_FAST_BILINEAR
                                            nullptr,                            // 輸入影像的濾波器資訊, 若不需要傳NULL
                                            nullptr,                            // 輸出影像的濾波器資訊, 若不需要傳NULL
                                            nullptr);                          // 特定縮放演算法需要的引數(?)，默認為NULL
        if(!m_swsContext)
        {
#if PRINT_LOG
            qWarning() << "sws_getCachedContext() Error！";
#endif
            free();
            return QImage();
        }
    }

    // AVFrame轉QImage
    uchar* data[]  = {m_buffer};
    int    lines[4];
    av_image_fill_linesizes(lines, AV_PIX_FMT_RGBA, m_frame->width);  // 使用像素格式pix_fmt和寬度填充影像的平面線條大小，
    ret = sws_scale(m_swsContext,             // 縮放背景關系
                    m_frame->data,            // 原影像陣列
                    m_frame->linesize,        // 包含源影像每個平面步幅的陣列
                    0,                        // 開始位置
                    m_frame->height,          // 行數
                    data,                     // 目標影像陣列
                    lines);                   // 包含目標影像每個平面的步幅的陣列
    QImage image(m_buffer, m_frame->width, m_frame->height, QImage::Format_RGBA8888);
    av_frame_unref(m_frame);

    return image;
}

/**
 * @brief 關閉視頻播放并釋放記憶體
 */
void VideoDecode::close()
{
    clear();
    free();

    m_totalTime     = 0;
    m_videoIndex    = 0;
    m_totalFrames   = 0;
    m_obtainFrames  = 0;
    m_pts           = 0;
    m_frameRate     = 0;
    m_size          = QSize(0, 0);
}

/**
 * @brief  視頻是否讀取完成
 * @return
 */
bool VideoDecode::isEnd()
{
    return m_end;
}

/**
 * @brief    回傳當前幀影像播放時間
 * @return
 */
const qint64 &VideoDecode::pts()
{
    return m_pts;
}

/**
 * @brief        顯示ffmpeg函式呼叫例外資訊
 * @param err
 */
void VideoDecode::showError(int err)
{
#if PRINT_LOG
    memset(m_error, 0, ERROR_LEN);        // 將陣列置零
    av_strerror(err, m_error, ERROR_LEN);
    qWarning() << "DecodeVideo Error：" << m_error;
#else
    Q_UNUSED(err)
#endif
}

/**
 * @brief          將AVRational轉換為double，用于計算幀率
 * @param rational
 * @return
 */
qreal VideoDecode::rationalToDouble(AVRational* rational)
{
    qreal frameRate = (rational->den == 0) ? 0 : (qreal(rational->num) / rational->den);
    return frameRate;
}

/**
 * @brief 清空讀取緩沖
 */
void VideoDecode::clear()
{
    if(m_formatContextSave && m_writeHeader)
    {
        av_write_trailer(m_formatContextSave);   // 寫入檔案尾
        m_writeHeader = false;

        avformat_free_context(m_formatContextSave);
        m_formatContext = nullptr;
        m_videoStream = nullptr;
    }
    // 因為avformat_flush不會重繪AVIOContext (s->pb)，如果有必要，在呼叫此函式之前呼叫avio_flush(s->pb)，
    if(m_formatContext && m_formatContext->pb)
    {
        avio_flush(m_formatContext->pb);
    }
    if(m_formatContext)
    {
        avformat_flush(m_formatContext);   // 清理讀取緩沖
    }
}

void VideoDecode::free()
{
    // 釋放背景關系swsContext，
    if(m_swsContext)
    {
        sws_freeContext(m_swsContext);
        m_swsContext = nullptr;             // sws_freeContext不會把背景關系置NULL
    }
    // 釋放編解碼器背景關系和與之相關的所有內容，并將NULL寫入提供的指標
    if(m_codecContext)
    {
        avcodec_free_context(&m_codecContext);
    }
    // 關閉并失敗m_formatContext，并將指標置為null
    if(m_formatContext)
    {
        avformat_close_input(&m_formatContext);
    }
    if(m_packet)
    {
        av_packet_free(&m_packet);
    }
    if(m_frame)
    {
        av_frame_free(&m_frame);
    }
    if(m_buffer)
    {
        delete [] m_buffer;
        m_buffer = nullptr;
    }
}

/**
 * @brief  打開輸出檔案
 * @return
 */
bool VideoDecode::openSave()
{
    QDir dir;
    if(!dir.exists("./Videos"))
    {
        dir.mkdir("./Videos");
    }
    QString strName = QString("./Videos/%1.h264").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd HH-mm-ss"));
    int ret = avformat_alloc_output_context2(&m_formatContextSave, nullptr, m_strCodecName.toStdString().data(), strName.toStdString().data());  // 這里使用和解碼一樣的編碼器，防止保存的影像顏色出問題

    if(ret < 0)
    {
        free();
        showError(ret);
        return false;
    }
    // 創建并初始化AVIOContext以訪問url所指示的資源，
    ret = avio_open(&m_formatContextSave->pb, strName.toStdString().data(), AVIO_FLAG_WRITE);
    if(ret < 0)
    {
        free();
        showError(ret);
        return false;
    }

    // 向媒體檔案添加新流
    m_videoStream = avformat_new_stream(m_formatContextSave, nullptr);
    if(!m_videoStream)
    {
        free();
        showError(AVERROR(ENOMEM));
        return false;
    }

    //拷貝一些引數，給codecpar賦值(這里使用編碼器背景關系進行賦值)
    ret = avcodec_parameters_from_context(m_videoStream->codecpar, m_codecContext);
    if(ret < 0)
    {
        free();
        showError(ret);
        return false;
    }

    // 寫入檔案頭
    ret = avformat_write_header(m_formatContextSave, nullptr);
    if(ret < 0)
    {
        free();
        showError(ret);
        return false;
    }
    m_writeHeader = true;

    qDebug() << "開始錄制視頻！";
    return true;
}

5、完整源代碼??

github
gitee

　??????? ?????????
　????? ????????
???????????????
　??????????????
　??????????????
　????????? |/
　????????? ???????
　??????????????

????????????_????????

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/549532.html

標籤：其他

上一篇：Qt-FFmpeg開發-實作錄屏功能（10）

下一篇：健身3年，再看堅持的意義！如何找到你的一生所愛？