ffmpeg c++ rgb 转h264 并 推流

要使用FFmpeg C++库将RGB图像转换为H.264编码，并将其推流，可以按照以下步骤进行：

1. 初始化FFmpeg库和相关的编码器、解码器、格式器等组件。

2. 创建输入的RGB图像数据，可以使用OpenCV等库读取图像文件，或者使用自己的算法生成RGB图像数据。

3. 创建输出的H.264编码器，并初始化编码器参数。可以使用FFmpeg提供的编码器，如libx264，或者其他第三方编码器。

4. 将RGB图像数据转换为YUV420P格式，这是H.264编码器所需的格式。可以使用FFmpeg提供的sws_scale函数进行转换。

5. 将YUV420P格式的图像数据输入到编码器中进行编码，生成H.264码流。

6. 创建输出的网络流或文件，将编码后的H.264码流写入到网络流或文件中。

7. 循环执行步骤2到6，直到所有图像都被编码并推流完毕。

下面是一个简单的代码示例，仅供参考：

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>

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

using namespace std;

int main(int argc, char* argv[])
{
    // 初始化FFmpeg库
    av_register_all();
    avcodec_register_all();

    // 输入RGB图像的宽度和高度
    int width = 640;
    int height = 480;

    // 创建输入的RGB图像数据，这里使用随机数据代替
    uint8_t* rgb_data = new uint8_t[width * height * 3];
    for (int i = 0; i < width * height * 3; i++)
        rgb_data[i] = rand() % 256;

    // 创建输出的H.264编码器
    AVCodec* codec = avcodec_find_encoder_by_name("libx264");
    if (!codec) {
        cerr << "Codec libx264 not found" << endl;
        exit(1);
    }
    AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        cerr << "Could not allocate video codec context" << endl;
        exit(1);
    }
    codec_ctx->bit_rate = 400000;
    codec_ctx->width = width;
    codec_ctx->height = height;
    codec_ctx->time_base = { 1, 25 };
    codec_ctx->gop_size = 10;
    codec_ctx->max_b_frames = 1;
    codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
        cerr << "Could not open codec" << endl;
        exit(1);
    }

    // 创建输出的网络流或文件
    const char* filename = "output.mp4";
    AVOutputFormat* fmt = av_guess_format(NULL, filename, NULL);
    AVFormatContext* fmt_ctx = avformat_alloc_context();
    if (!fmt_ctx) {
        cerr << "Could not allocate output format context" << endl;
        exit(1);
    }
    fmt_ctx->oformat = fmt;
    if (avio_open(&fmt_ctx->pb, filename, AVIO_FLAG_WRITE) < 0) {
        cerr << "Could not open output file '" << filename << "'" << endl;
        exit(1);
    }

    // 创建输出的视频流
    AVStream* video_stream = avformat_new_stream(fmt_ctx, NULL);
    if (!video_stream) {
        cerr << "Could not allocate video stream" << endl;
        exit(1);
    }
    video_stream->id = fmt_ctx->nb_streams - 1;
    AVCodecParameters* codecpar = video_stream->codecpar;
    codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    codecpar->codec_id = codec->id;
    codecpar->bit_rate = codec_ctx->bit_rate;
    codecpar->width = codec_ctx->width;
    codecpar->height = codec_ctx->height;
    codecpar->format = codec_ctx->pix_fmt;
    avcodec_parameters_to_context(codec_ctx, codecpar);
    av_dump_format(fmt_ctx, 0, filename, 1);

    // 初始化编码器
    AVFrame* frame = av_frame_alloc();
    if (!frame) {
        cerr << "Could not allocate video frame" << endl;
        exit(1);
    }
    frame->format = codec_ctx->pix_fmt;
    frame->width = codec_ctx->width;
    frame->height = codec_ctx->height;
    if (av_frame_get_buffer(frame, 0) < 0) {
        cerr << "Could not allocate video frame data" << endl;
        exit(1);
    }
    AVPacket* pkt = av_packet_alloc();
    if (!pkt) {
        cerr << "Could not allocate packet" << endl;
        exit(1);
    }

    // 将RGB图像数据转换为YUV420P格式
    int y_size = codec_ctx->width * codec_ctx->height;
    uint8_t* yuv_data = new uint8_t[y_size * 3 / 2];
    SwsContext* sws_ctx = sws_getContext(codec_ctx->width, codec_ctx->height, AV_PIX_FMT_RGB24,
        codec_ctx->width, codec_ctx->height, AV_PIX_FMT_YUV420P, 0, NULL, NULL, NULL);
    sws_scale(sws_ctx, &rgb_data, &width, 0, codec_ctx->height, &yuv_data, &codec_ctx->width);

    // 编码并推流
    int ret = 0;
    int frame_count = 0;
    while (frame_count < 100) { // 循环100次，测试用，可以根据实际情况修改
        // 将YUV420P格式的图像数据输入到编码器中进行编码
        frame->data[0] = yuv_data;
        frame->data[1] = yuv_data + y_size;
        frame->data[2] = yuv_data + y_size * 5 / 4;
        frame->pts = frame_count * codec_ctx->time_base.den / codec_ctx->time_base.num;
        ret = avcodec_send_frame(codec_ctx, frame);
        if (ret < 0) {
            cerr << "Error sending a frame for encoding" << endl;
            exit(1);
        }
        while (ret >= 0) {
            ret = avcodec_receive_packet(codec_ctx, pkt);
            if (ret < 0) {
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                    break;
                cerr << "Error during encoding" << endl;
                exit(1);
            }
            av_packet_rescale_ts(pkt, codec_ctx->time_base, video_stream->time_base);
            pkt->stream_index = video_stream->index;
            ret = av_interleaved_write_frame(fmt_ctx, pkt);
            if (ret < 0) {
                cerr << "Error writing video frame" << endl;
                exit(1);
            }
        }
        frame_count++;
    }

    // 清理资源
    av_write_trailer(fmt_ctx);
    av_packet_free(&pkt);
    av_frame_free(&frame);
    avcodec_free_context(&codec_ctx);
    avformat_close_input(&fmt_ctx);
    avio_close(fmt_ctx->pb);
    avformat_free_context(fmt_ctx);
    sws_freeContext(sws_ctx);
    delete[] rgb_data;
    delete[] yuv_data;

    return 0;
}

运行该程序后，会将生成的H.264编码后的码流写入到文件"output.mp4"中。要将编码后的码流推流到网络上，可以使用FFmpeg提供的RTMP协议或者其他协议进行推流。