ffmpeg写h264视频文件

可以使用ffmpeg库将视频流编码为H.264视频文件。以下是使用ffmpeg库编写H.264视频文件的基本步骤：

1. 打开视频文件，获取输入视频流和输出视频流。
2. 配置编码器参数，例如视频分辨率、帧率、位速率等。
3. 初始化编码器。
4. 从输入视频流中读取帧。
5. 将帧送入编码器进行编码。
6. 将编码后的数据写入输出视频流。
7. 重复步骤4到6，直到所有帧都被编码并写入输出视频流。
8. 关闭输入和输出视频流，关闭编码器。

下面是一个简单的示例代码，演示如何使用ffmpeg库将视频文件编码为H.264视频文件：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>

#define __STDC_CONSTANT_MACROS
#ifdef _WIN32
//Windows
extern "C"{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "libavutil/opt.h"
};
#else
//Linux...
#ifdef __cplusplus
extern "C"{
#endif
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/opt.h>
#ifdef __cplusplus
};
#endif
#endif

using namespace std;

int main(int argc, char* argv[])
{
    // 注册所有的编解码器、复用器和过滤器等
    av_register_all();

    // 打开视频文件
    AVFormatContext *pFormatCtx = NULL;
    if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0) {
        printf("Couldn't open input stream.\n");
        return -1;
    }

    // 找到视频流信息
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        printf("Couldn't find stream information.\n");
        return -1;
    }

    // 打印视频流信息
    av_dump_format(pFormatCtx, 0, argv[1], 0);

    // 找到视频编码器
    AVCodec* pCodec = NULL;
    int videoStreamIndex = -1;
    for (int i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStreamIndex = i;
            pCodec = avcodec_find_decoder(pFormatCtx->streams[i]->codec->codec_id);
            break;
        }
    }
    if (videoStreamIndex == -1) {
        printf("Couldn't find a video stream.\n");
        return -1;
    }
    if (pCodec == NULL) {
        printf("Couldn't find a suitable video decoder.\n");
        return -1;
    }

    // 打开视频编码器
    if (avcodec_open2(pFormatCtx->streams[videoStreamIndex]->codec, pCodec, NULL) < 0) {
        printf("Couldn't open codec.\n");
        return -1;
    }

    // 打开输出文件
    AVFormatContext* pOutputFormatCtx = NULL;
    AVOutputFormat* pOutputFormat = av_guess_format(NULL, "output.mp4", NULL);
    avformat_alloc_output_context2(&pOutputFormatCtx, pOutputFormat, NULL, "output.mp4");
    if (pOutputFormatCtx == NULL) {
        printf("Couldn't create output context.\n");
        return -1;
    }
    AVStream* pOutputStream = avformat_new_stream(pOutputFormatCtx, NULL);
    if (pOutputStream == NULL) {
        printf("Couldn't create output stream.\n");
        return -1;
    }
    if (avcodec_copy_context(pOutputStream->codec, pFormatCtx->streams[videoStreamIndex]->codec) < 0) {
        printf("Couldn't copy codec context.\n");
        return -1;
    }
    if (avio_open(&pOutputFormatCtx->pb, "output.mp4", AVIO_FLAG_WRITE) < 0) {
        printf("Couldn't open output file.\n");
        return -1;
    }
    if (avformat_write_header(pOutputFormatCtx, NULL) < 0) {
        printf("Error occurred when opening output file.\n");
        return -1;
    }

    // 初始化编码器
    AVCodecContext* pEncoderCtx = pOutputStream->codec;
    if (avcodec_open2(pEncoderCtx, avcodec_find_encoder(AV_CODEC_ID_H264), NULL) < 0) {
        printf("Couldn't open encoder.\n");
        return -1;
    }

    // 分配视频帧和输出缓冲区
    AVFrame* pFrame = av_frame_alloc();
    AVFrame* pFrameRGB = av_frame_alloc();
    uint8_t* buffer = (uint8_t*)av_malloc(avpicture_get_size(AV_PIX_FMT_RGB24, pEncoderCtx->width, pEncoderCtx->height));
    avpicture_fill((AVPicture*)pFrameRGB, buffer, AV_PIX_FMT_RGB24, pEncoderCtx->width, pEncoderCtx->height);

    // 初始化像素格式转换器
    struct SwsContext* imgConvertCtx = sws_getContext(pEncoderCtx->width, pEncoderCtx->height, pFormatCtx->streams[videoStreamIndex]->codec->pix_fmt,
        pEncoderCtx->width, pEncoderCtx->height, AV_PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);

    // 编码每一帧
    AVPacket pkt;
    int frameFinished = 0;
    while (av_read_frame(pFormatCtx, &pkt) >= 0) {
        if (pkt.stream_index == videoStreamIndex) {
            avcodec_decode_video2(pFormatCtx->streams[videoStreamIndex]->codec, pFrame, &frameFinished, &pkt);
            if (frameFinished) {
                sws_scale(imgConvertCtx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0,
                    pEncoderCtx->height, pFrameRGB->data, pFrameRGB->linesize);
                AVPacket pktOut;
                av_init_packet(&pktOut);
                pktOut.data = NULL;
                pktOut.size = 0;
                int gotPacket = 0;
                avcodec_encode_video2(pEncoderCtx, &pktOut, pFrameRGB, &gotPacket);
                if (gotPacket) {
                    av_packet_rescale_ts(&pktOut, pEncoderCtx->time_base, pOutputStream->time_base);
                    pktOut.stream_index = pOutputStream->index;
                    av_write_frame(pOutputFormatCtx, &pktOut);
                }
            }
        }
        av_free_packet(&pkt);
    }

    // 编码结束
    av_write_trailer(pOutputFormatCtx);

    // 清理
    avcodec_close(pEncoderCtx);
    av_free(pEncoderCtx);
    av_frame_free(&pFrame);
    av_frame_free(&pFrameRGB);
    av_free(buffer);
    avio_close(pOutputFormatCtx->pb);
    avformat_free_context(pOutputFormatCtx);
    avcodec_close(pFormatCtx->streams[videoStreamIndex]->codec);
    avformat_close_input(&pFormatCtx);
    return 0;
}