解碼後的YUV幀（AVFrame）→ 格式轉換（SwsContext）→ RGB幀 → 顯示或保存

SwsContext *sws_getContext(
    int srcW,                      // 源圖像寬度
    int srcH,                      // 源圖像高度
    enum AVPixelFormat srcFormat,  // 源像素格式
    int dstW,                      // 目標圖像寬度
    int dstH,                      // 目標圖像高度
    enum AVPixelFormat dstFormat,  // 目標像素格式
    int flags,                     // 縮放算法標誌
    SwsFilter *srcFilter,          // 源濾鏡（一般傳NULL）
    SwsFilter *dstFilter,          // 目標濾鏡（一般傳NULL）
    const double *param            // 額外參數（一般傳NULL）
);

// 創建 YUV → RGB 轉換器  codec_context是解碼器上下文
SwsContext* sws_ctx = sws_getContext(
    codec_context->width,           // 源寬度
    codec_context->height,          // 源高度
    codec_context->pix_fmt,         // 源格式（YUV）
    codec_context->width,           // 目標寬度
    codec_context->height,          // 目標高度
    AV_PIX_FMT_RGB24,              // 目標格式（RGB24）
    SWS_BILINEAR,                   // 雙線性插值
    nullptr, nullptr, nullptr       // 其他參數默認
);

if(!sws_ctx) {
    qDebug() << "格式轉換器創建失敗";
    return -1;
}

int sws_scale(
    SwsContext *c,                  // 轉換上下文
    const uint8_t *const srcSlice[], // 源數據指針數組
    const int srcStride[],          // 源每行字節數數組
    int srcSliceY,                  // 起始行（一般傳0）
    int srcSliceH,                  // 處理行數（一般傳圖像高度）
    uint8_t *const dst[],           // 目標數據指針數組
    const int dstStride[]           // 目標每行字節數數組
);

// 執行 YUV → RGB 轉換
int rows = sws_scale(
    sws_ctx,                // 轉換器
    frame->data,            // 源數據（YUV）
    frame->linesize,        // 源每行字節數
    0,                      // 從第0行開始
    frame->height,          // 處理整個圖像
    rgb_data,               // 目標數據（RGB） 事先分配好的!!!!!!!!
    rgb_linesize            // 目標每行字節數  事先分配好的!!!!!!!!
);

if(rows > 0) {
    qDebug() << "成功轉換" << rows << "行";
}

// 假設圖像寬度 1920，RGB24 格式
int 理論字節數 = 1920 * 3 = 5760;
int 實際linesize = 5760;  // 如果正好對齊
// 或者
int 實際linesize = 5776;  // 補齊到16的倍數

void sws_freeContext(SwsContext *swsContext);

// 程序結束時釋放
sws_freeContext(sws_ctx);
sws_ctx = nullptr;  // 好習慣：釋放後置空

int av_image_alloc(
    uint8_t *pointers[4],           // 輸出：數據指針數組
    int linesizes[4],               // 輸出：每行字節數數組
    int w, int h,                   // 圖像寬高
    enum AVPixelFormat pix_fmt,     // 像素格式
    int align                       // 對齊字節數
);

uint8_t* rgb_data[4];
int rgb_linesize[4];

int buffer_size = av_image_alloc(
    rgb_data, 
    rgb_linesize,
    codec_context->width,
    codec_context->height,
    AV_PIX_FMT_RGB24,
    1  // 1字節對齊
);

if(buffer_size < 0) {
    qDebug() << "內存分配失敗";
    return -1;
}

qDebug() << "分配了" << buffer_size << "字節內存";

uint8_t* rgb_data[4];      // 指針數組
int rgb_linesize[4];       // 整數數組

av_image_alloc(rgb_data, rgb_linesize, ...);

// ✅ rgb_data[0] 指向動態分配的內存，需要釋放
av_freep(&rgb_data[0]);

// ❌ rgb_linesize[0] 只是整數，不需要釋放
// av_freep(&rgb_linesize[0]);  // 錯誤！

alloc  → 需要 free
open   → 需要 close
get    → 需要 free（如 sws_getContext）

#include "mainwindow.h"
#include<QDebug>
#include <QApplication>
#include<stdio.h>

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



int main(int argc, char *argv[])
{
    QString path="E:video.mp4";

    AVFormatContext * avfmatcontext=nullptr;
    int result=avformat_open_input(&avfmatcontext,path.toUtf8().data(),nullptr,nullptr);

    if(result<0)
    {
        qDebug()<<"avformat_open_input is error";
        return 0;
    }
    qDebug()<<"avformat_open_input is success";

    result=av_find_best_stream(avfmatcontext,AVMEDIA_TYPE_VIDEO,-1,-1,NULL,0);
    int video_dex=result;
    if(result!=0)
    {
        qDebug()<<"av_find_best_stream is error";
        return 0;
    }
    qDebug()<<"av_find_best_stream is success";

    AVStream* stream=avfmatcontext->streams[result];
    qDebug()<<"this video stream index is "<<stream->index;


    const AVCodec* decoder=avcodec_find_decoder(stream->codecpar->codec_id);
    if(!decoder)
    {
        qDebug()<<"avcodec_find_decoder is error";
        return 0;
    }
    qDebug()<<"avcodec_find_decoder is success ,this decoder name is "<<decoder->name;

    //分配解碼器上下文
    AVCodecContext * codec_context=avcodec_alloc_context3(decoder);

    //複製信息
    result=avcodec_parameters_to_context(codec_context,stream->codecpar);
    if(result!=0)
    {
        qDebug()<<"avcodec_parameters_to_context is error";
        return 0;
    }
    qDebug()<<"avcodec_parameters_to_context is success";


    //打開解碼器
    result=avcodec_open2(codec_context,decoder,nullptr);
    if(result!=0)
    {
        qDebug()<<"avcodec_open2 is error";
        return 0;
    }
    qDebug()<<"avcodec_open2 is success";
    qDebug()<<"視頻分辨率:"<<codec_context->width<<" x "<<codec_context->height;

    AVPacket* packet=av_packet_alloc();
    AVFrame* frame=av_frame_alloc();
    int total_frame=0;

    //創建格式轉換器 後續解碼第一幀的時候傳入參數
    SwsContext* sws_ctx=nullptr;


    //讀取packet
    while(av_read_frame(avfmatcontext,packet)>=0&&total_frame!=1000)
    {
        if(packet->stream_index!=video_dex)continue;
        //發送packet給解碼器
        if(avcodec_send_packet(codec_context,packet)==0)
        {
            //解碼器解碼
            while(avcodec_receive_frame(codec_context,frame)==0&&total_frame!=1000)
            {
                if(total_frame == 0) {
                    //第一幀的時候設置格式轉換器參數
                    sws_ctx=sws_getContext(
                        codec_context->width,
                        codec_context->height,
                        codec_context->pix_fmt,
                        codec_context->width,
                        codec_context->height,
                        AV_PIX_FMT_RGB24,
                        SWS_BILINEAR,
                        nullptr,
                        nullptr,
                        nullptr);

                    if(!sws_ctx)
                    {
                        qDebug()<<"格式轉換器創建失敗";
                        return 0;
                    }
                    qDebug()<<"格式轉換器創建成功";

                    //分配rgb圖像內存
                    uint8_t* rgb_data[4];
                    int rgb_linesize[4];

                    int result_alloc=av_image_alloc
                    (rgb_data,rgb_linesize,codec_context->width,codec_context->height,
                                                      AV_PIX_FMT_RGB24,1);
                    if(result_alloc<0)
                    {
                        qDebug()<<"給rgb分配內存空間失敗";
                        return 0;
                    }
                    qDebug() << "RGB 內存分配成功，大小:" << result_alloc << "字節";


                    //只轉換第一幀
                    int p=sws_scale(sws_ctx,frame->data,frame->linesize,
                    0,frame->height,rgb_data,rgb_linesize);
                    if(p>0)
                    {
                        qDebug() << "成功將一幀 YUV 轉換為 RGB，共轉換" << p << "行";
                        // 保存為 PPM 格式
                        FILE* ppm_file = fopen("E:/frame.ppm", "wb");
                        fprintf(ppm_file, "P6\n%d %d\n255\n", 
                        codec_context->width, codec_context->height);
                        // 寫入 RGB 數據
                        fwrite(rgb_data[0], 1, result_alloc, ppm_file);
                        fclose(ppm_file);
                    }
                    //釋放手動開闢的rgb空間
                    av_freep(&rgb_data[0]);
                }
                total_frame++;
                av_frame_unref(frame);
            }
        }
        av_packet_unref(packet);
    }
    qDebug()<<"總共讀取了"<<total_frame<<"幀";

    // 釋放所有資源
    sws_freeContext(sws_ctx);
    av_packet_free(&packet);
    av_frame_free(&frame);
    avcodec_free_context(&codec_context);
    avformat_close_input(&avfmatcontext);
    
    qDebug() << "程序執行完成";
    return 0;
}

// 如果保存的圖片是綠色，嘗試改成 BGR24
sws_getContext(..., AV_PIX_FMT_BGR24, ...);

// ❌ 錯誤
int index = y * width * 3 + x * 3;

// ✅ 正確
int index = y * rgb_linesize[0] + x * 3;

// ✅ 每個 alloc 都要有對應的 free
av_packet_alloc()     → av_packet_free()
av_frame_alloc()      → av_frame_free()
sws_getContext()      → sws_freeContext()
av_image_alloc()      → av_freep(&data[0])
avcodec_alloc_context3() → avcodec_free_context()
avformat_open_input() → avformat_close_input()

av_freep(&rgb_data[0]);     // ✅ 需要
av_freep(&rgb_linesize[0]); // ❌ 不需要