实现FFmpeg的视频转图片(BMP)

结构体信息可以看这里
https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapfileheader

这里最容易出错的地方就是这里的
#pragma pack(push, 1) // 确保结构体对齐方式与 BMP 格式一致
#pragma pack(pop)

对这个的讲解我这里直接引用了AI的(讲的是真的好（〃｀ 3′〃）)

#pragma pack(push, 1) 和 #pragma pack(pop) 的作用

这两个编译指令用来控制 结构体成员的对齐方式，特别是设置如何在内存中排列结构体的数据。

默认对齐方式

默认情况下，编译器会对结构体成员进行对齐，以优化内存访问的性能。
例如，如果一个结构体成员是 uint32_t 类型（4 字节），它通常会对齐到 4 字节边界。这样会导致结构体中可能出现一些额外的 填充字节（padding），以保证对齐。

例如：

typedef struct {
    uint8_t a;  // 1 字节
    uint32_t b; // 4 字节
} Example;

默认情况下，这个结构体的内存布局是：
| a | 填充 (3 字节) | b | => 总大小为 8 字节

#pragma pack(push, 1)

当使用 #pragma pack(push, 1) 时，结构体的成员按 1 字节对齐。也就是说，成员会紧密排列，不会插入填充字节。

改用 #pragma pack(push, 1) 的情况：

#pragma pack(push, 1)
typedef struct {
    uint8_t a;  // 1 字节
    uint32_t b; // 4 字节
} Example;
#pragma pack(pop)

内存布局：
| a | b | => 总大小为 5 字节

为什么在处理 BMP 文件时使用？

BMP 文件头和信息头的格式是严格定义的，它们在文件中的每一部分都需要紧密排列，不能有填充字节。
例如：

• BMPFileHeader 的大小必须是 14 字节。
• BMPInfoHeader 的大小必须是 40 字节。

如果使用默认对齐方式，结构体可能会包含填充字节，导致文件格式不符合规范。使用 #pragma pack(push, 1) 可以确保数据结构的内存布局与 BMP 文件的定义完全一致。

#pragma pack(pop)

这个指令用来恢复对齐方式到之前的状态。
#pragma pack(push, 1) 改变了对齐方式，因此在定义完需要紧密对齐的结构体后，用 #pragma pack(pop) 恢复默认对齐方式，以免影响后续代码的性能。

---

总结

• #pragma pack(push, 1) 确保结构体紧密对齐，无填充字节，适合文件格式的定义。
• #pragma pack(pop) 恢复默认对齐方式，避免全局影响。
• 在处理像 BMP 这种对数据格式严格要求的场景时，显得尤为重要。

将视频转BMP图片的案例

#pragma pack(push, 1) // 确保结构体对齐方式与 BMP 格式一致

// BMP 文件头
typedef struct {
    uint16_t bfType;      // 文件标识符 ('BM')
    uint32_t bfSize;      // 文件大小
    uint16_t bfReserved1; // 保留字段
    uint16_t bfReserved2; // 保留字段
    uint32_t bfOffBits;   // 数据偏移量
} BMPFileHeader;

// BMP 信息头
typedef struct {
    uint32_t biSize;          // 信息头大小
    int32_t  biWidth;         // 图像宽度
    int32_t  biHeight;        // 图像高度
    uint16_t biPlanes;        // 颜色平面数（始终为1）
    uint16_t biBitCount;      // 每像素位数（24位，BGR）
    uint32_t biCompression;   // 压缩方式（0表示不压缩）
    uint32_t biSizeImage;     // 图像数据大小
    int32_t  biXPelsPerMeter; // 水平分辨率（像素/米）
    int32_t  biYPelsPerMeter; // 垂直分辨率（像素/米）
    uint32_t biClrUsed;       // 调色板颜色数（0表示无调色板）
    uint32_t biClrImportant;  // 重要颜色数（0表示所有颜色重要）
} BMPInfoHeader;

#pragma pack(pop)

void saveBMP(unsigned char* buf, int width, int height, int linesize, const char* name) {
    FILE *f = fopen(name, "wb");
    if (!f) {
        fprintf(stderr, "无法打开文件: %s\n", name);
        return;
    }

    // 初始化 BMP 文件头
    BMPFileHeader fileHeader = {
        .bfType = 0x4D42, // 'BM'
        .bfSize = 0,      // 稍后填充
        .bfReserved1 = 0,
        .bfReserved2 = 0,
        .bfOffBits = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) // 数据偏移量
    };

    // 初始化 BMP 信息头
    BMPInfoHeader infoHeader = {
        .biSize = sizeof(BMPInfoHeader),
        .biWidth = width,
        .biHeight = height, // 注意：正数表示从下到上存储
        .biPlanes = 1,
        .biBitCount = 24,
        .biCompression = 0,
        .biSizeImage = 0,   // 稍后填充
        .biXPelsPerMeter = 0,
        .biYPelsPerMeter = 0,
        .biClrUsed = 0,
        .biClrImportant = 0
    };

    // 计算每行填充的字节数
    //int row_padded = (width * 3 + 3) & (~3); // 行填充到4字节对齐
    int image_size = width * height;    // 图像数据总大小
    fileHeader.bfSize = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + image_size;
    infoHeader.biSizeImage = image_size;

    // 写入文件头和信息头
    fwrite(&fileHeader, sizeof(BMPFileHeader), 1, f);
    fwrite(&infoHeader, sizeof(BMPInfoHeader), 1, f);

    // 写入图像数据（从下到上存储）
    for (int i = height - 1; i >= 0; i--) {
        fwrite(buf + i * linesize, 1, width * 3, f); // 每个像素3个字节，RGB
    }
    fclose(f);
}



static int decode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, const char* fileName) {
    int ret = -1;
    char buf[1024];

    ret = avcodec_send_packet(ctx, pkt);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "发送数据包到解码器失败!\n");
        goto _END;
    }

    while (ret >= 0) {
        ret = avcodec_receive_frame(ctx, frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            return 0;
        } else if (ret < 0) {
            return -1;
        }

        // 创建转换上下文，将YUV转换为RGB
        struct SwsContext *sws_ctx = sws_getContext(
            frame->width, frame->height, frame->format,
            frame->width, frame->height, AV_PIX_FMT_BGR24,
            SWS_BICUBIC, NULL, NULL, NULL
        );
        if (!sws_ctx) {
            av_log(NULL, AV_LOG_ERROR, "初始化转换上下文失败\n");
            return -1;
        }

        // 为RGB数据分配内存
        uint8_t *rgb_data = (uint8_t *)malloc(frame->width * frame->height * 3); // 每个像素3个字节
        int rgb_linesize = frame->width * 3;

        // 执行转换
        sws_scale(sws_ctx, (const uint8_t *const *)frame->data, frame->linesize, 0, frame->height, &rgb_data, &rgb_linesize);

        snprintf(buf, sizeof(buf), "%s-%d.bmp", fileName, ctx->frame_num);
        saveBMP(rgb_data, frame->width, frame->height, rgb_linesize, buf);

        free(rgb_data);
        sws_freeContext(sws_ctx);
    }

_END:
    return 0;
}


int main(int argc, char *argv[])
{
    int ret = -1;
    int idx = -1;
    // 1. 处理参数
    char* src;  // 输入数据
    char* dst;  // 输出数据

    AVFormatContext *pFmtCtx = NULL;
    AVStream *inStream = NULL;

    const AVCodec *codec = NULL;
    AVCodecContext *ctx = NULL;

    AVPacket *pkt = NULL;
    AVFrame *frame = NULL;

    av_log_set_level(AV_LOG_DEBUG);
    if(argc < 3) {
        av_log(NULL, AV_LOG_INFO, "参数数量不足!\n");
        exit(-1);
    }

    src = argv[1];
    dst = argv[2];

    // 2. 配置输入上下文，打开多媒体文件
    if((ret = avformat_open_input(&pFmtCtx, src, NULL, NULL)) < 0){
        av_log(NULL, AV_LOG_ERROR, "%s\n", av_err2str(ret));
        exit(-1);
    }

    // 3. 从多媒体文件中找到视频流
    idx = av_find_best_stream(pFmtCtx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if(idx < 0){
        av_log(pFmtCtx, AV_LOG_ERROR, "未找到视频流!\n");
        goto __ERROR;
    }

    // 4. 查找编码器
    inStream = pFmtCtx->streams[idx];
    codec = avcodec_find_decoder(inStream->codecpar->codec_id);
    if(!codec){
        av_log(NULL, AV_LOG_ERROR, "找不到解码器\n");
        goto __ERROR;
    }

    // 5. 配置编码器上下文
    ctx = avcodec_alloc_context3(codec);
    if(!ctx){
        av_log(NULL, AV_LOG_ERROR, "内存分配失败\n");
        goto __ERROR;
    }
    avcodec_parameters_to_context(ctx, inStream->codecpar);

    // 6. 打开解码器
    ret = avcodec_open2(ctx, codec, NULL);
    if(ret < 0){
        av_log(ctx, AV_LOG_ERROR, "解码器打开失败: %s\n", av_err2str(ret));
        goto __ERROR;
    }

    // 7. 创建AVFrame
    frame = av_frame_alloc();
    if(!frame){
        av_log(NULL, AV_LOG_ERROR, "内存分配失败!\n");
        goto __ERROR;
    }

    // 8. 创建AVPacket
    pkt = av_packet_alloc();
    if(!pkt){
        av_log(NULL, AV_LOG_ERROR, "内存分配失败!\n");
        goto __ERROR;
    }

    // 9. 读取视频数据并保存为图像
    while(av_read_frame(pFmtCtx, pkt) >= 0){
        if(pkt->stream_index == idx){
            decode(ctx, frame, pkt, dst);
        }
        av_packet_unref(pkt);
    }

    decode(ctx, frame, NULL, dst);

    //10. 释放资源
__ERROR:
    if(pFmtCtx){
        avformat_close_input(&pFmtCtx);
        pFmtCtx = NULL;
    }
    if(ctx){
        avcodec_free_context(&ctx);
        ctx = NULL;
    }
    if(frame){
        av_frame_free(&frame);
        frame = NULL;
    }
    if(pkt){
        av_packet_free(&pkt);
        pkt = NULL;
    }
    return 0;
}