使用 C++ 和 FFmpeg创建RTSP 服务器示例

下面是使用 C++ 和 FFmpeg 创建 RTSP 服务器的示例代码：

#include <iostream>
#include <thread>
#include <chrono>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <ctime>

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

#define WIDTH 640
#define HEIGHT 480
#define FPS 25

static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt, FILE *outfile) {
    int ret;

    /* send the frame to the encoder */
    ret = avcodec_send_frame(enc_ctx, frame);
    if (ret < 0) {
        std::cerr << "Error sending a frame for encoding" << std::endl;
        exit(1);
    }

    /* receive packet from encoder */
    while (ret >= 0) {
        ret = avcodec_receive_packet(enc_ctx, pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            return;
        else if (ret < 0) {
            std::cerr << "Error during encoding" << std::endl;
            exit(1);
        }

        /* write the compressed frame to the media file */
        fwrite(pkt->data, 1, pkt->size, outfile);
        av_packet_unref(pkt);
    }
}

static void encode_thread(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt, FILE *outfile) {
    while (true) {
        encode(enc_ctx, frame, pkt, outfile);
    }
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        std::cerr << "Usage: " << argv[0] << " output_url" << std::endl;
        return 1;
    }

    const char *output_url = argv[1];

    // Initialize FFmpeg
    av_register_all();
    avcodec_register_all();

    // Create format context
    AVFormatContext *format_ctx = nullptr;
    int ret = avformat_alloc_output_context2(&format_ctx, nullptr, "rtsp", output_url);
    if (ret < 0) {
        std::cerr << "Error creating output context" << std::endl;
        return 1;
    }

    // Create video stream
    AVStream *video_stream = avformat_new_stream(format_ctx, nullptr);
    if (video_stream == nullptr) {
        std::cerr << "Error creating video stream" << std::endl;
        return 1;
    }

    // Set codec parameters
    AVCodecParameters *codec_params = video_stream->codecpar;
    codec_params->codec_id = AV_CODEC_ID_H264;
    codec_params->codec_type = AVMEDIA_TYPE_VIDEO;
    codec_params->width = WIDTH;
    codec_params->height = HEIGHT;
    codec_params->format = AV_PIX_FMT_YUV420P;
    codec_params->bit_rate = 1000000;
    codec_params->fps_num = FPS;
    codec_params->fps_den = 1;

    // Find codec
    AVCodec *codec = avcodec_find_encoder(codec_params->codec_id);
    if (codec == nullptr) {
        std::cerr << "Error finding codec" << std::endl;
        return 1;
    }

    // Create codec context
    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (codec_ctx == nullptr) {
        std::cerr << "Error creating codec context" << std::endl;
        return 1;
    }

    // Set codec options
    av_opt_set(codec_ctx->priv_data, "preset", "ultrafast", 0);

    // Open codec
    ret = avcodec_open2(codec_ctx, codec, nullptr);
    if (ret < 0) {
        std::cerr << "Error opening codec" << std::endl;
        return 1;
    }

    // Copy codec parameters to codec context
    ret = avcodec_parameters_to_context(codec_ctx, codec_params);
    if (ret < 0) {
        std::cerr << "Error copying codec parameters" << std::endl;
        return 1;
    }

    // Allocate frame
    AVFrame *frame = av_frame_alloc();
    if (frame == nullptr) {
        std::cerr << "Error allocating frame" << std::endl;
        return 1;
    }

    // Set frame options
    frame->format = codec_ctx->pix_fmt;
    frame->width = codec_ctx->width;
    frame->height = codec_ctx->height;

    // Allocate frame buffer
    ret = av_frame_get_buffer(frame, 0);
    if (ret < 0) {
        std::cerr << "Error allocating frame buffer" << std::endl;
        return 1;
    }

    // Open output file
    ret = avio_open(&format_ctx->pb, output_url, AVIO_FLAG_WRITE);
    if (ret < 0) {
        std::cerr << "Error opening output file" << std::endl;
        return 1;
    }

    // Write format header
    ret = avformat_write_header(format_ctx, nullptr);
    if (ret < 0) {
        std::cerr << "Error writing format header" << std::endl;
        return 1;
    }

    // Create packet
    AVPacket *pkt = av_packet_alloc();
    if (pkt == nullptr) {
        std::cerr << "Error creating packet" << std::endl;
        return 1;
    }

    // Create encoding thread
    std::thread encode_thread(encode_thread, codec_ctx, frame, pkt, format_ctx->pb);

    // Generate video frames
    AVFrame *rgb_frame = av_frame_alloc();
    if (rgb_frame == nullptr) {
        std::cerr << "Error allocating RGB frame" << std::endl;
        return 1;
    }

    uint8_t *buffer = reinterpret_cast<uint8_t *>(av_malloc(av_image_get_buffer_size(AV_PIX_FMT_RGB24, WIDTH, HEIGHT, 1)));
    if (buffer == nullptr) {
        std::cerr << "Error allocating buffer" << std::endl;
        return 1;
    }

    av_image_fill_arrays(rgb_frame->data, rgb_frame->linesize, buffer, AV_PIX_FMT_RGB24, WIDTH, HEIGHT, 1);

    for (int i = 0; i < 1000; ++i) {
        // Generate random image
        for (int y = 0; y < HEIGHT; ++y) {
            for (int x = 0; x < WIDTH; ++x) {
                rgb_frame->data[0][y * rgb_frame->linesize[0] + x * 3] = rand() % 256;
                rgb_frame->data[0][y * rgb_frame->linesize[0] + x * 3 + 1] = rand() % 256;
                rgb_frame->data[0][y * rgb_frame->linesize[0] + x * 3 + 2] = rand() % 256;
            }
        }

        // Convert RGB to YUV
        SwsContext *sws_ctx = sws_getContext(WIDTH, HEIGHT, AV_PIX_FMT_RGB24,
                                             WIDTH, HEIGHT, AV_PIX_FMT_YUV420P,
                                             0, nullptr, nullptr, nullptr);
        sws_scale(sws_ctx, rgb_frame->data, rgb_frame->linesize, 0, HEIGHT, frame->data, frame->linesize);
        sws_freeContext(sws_ctx);

        // Set frame timestamp
        frame->pts = i * (codec_ctx->time_base.den) / (codec_ctx->time_base.num * FPS);

        // Encode frame
        encode(codec_ctx, frame, pkt, format_ctx->pb);

        std::this_thread::sleep_for(std::chrono::milliseconds(1000 / FPS));
    }

    // Flush encoder
    encode(codec_ctx, nullptr, pkt, format_ctx->pb);

    // Write format trailer
    av_write_trailer(format_ctx);

    // Join encoding thread
    encode_thread.join();

    // Free resources
    av_frame_free(&frame);
    av_frame_free(&rgb_frame);
    av_packet_free(&pkt);
    avcodec_free_context(&codec_ctx);
    avformat_free_context(format_ctx);

    return 0;
}

在上面的示例中，我们使用了 FFmpeg 库来生成随机视频帧并将其编码为 H.264 格式，并使用 RTSP 协议将其流式传输到给定的 URL。首先，我们使用 `avformat_alloc_output_context2` 函数创建一个输出上下文，并将其格式设置为 RTSP。然后，我们创建一个视频流并设置其编解码器参数。接下来，我们使用 `avcodec_find_encoder` 函数查找 H.264 编解码器，并使用 `avcodec_alloc_context3` 函数创建编解码器上下文。然后，我们设置编解码器的选项并打开它。接下来，我们将编解码器参数复制到编解码器上下文中，并使用 `av_frame_alloc` 函数分配一个帧。然后，我们设置帧的选项并使用 `av_frame_get_buffer` 函数分配其缓冲区。接下来，我们使用 `avio_open` 函数打开输出文件，并使用 `avformat_write_header` 函数写入格式头。然后，我们创建一个数据包并启动一个编码线程。接下来，我们使用 `av_frame_alloc` 函数分配一个 RGB 帧，并使用 `av_malloc` 函数分配一个缓冲区。然后，我们生成随机 RGB 像素，并使用 `sws_getContext` 函数创建一个缩放上下文。然后，我们使用 `sws_scale` 函数将 RGB 帧转换为 YUV 帧。接下来，我们在帧上设置时间戳，并使用 `encode` 函数将其编码为 H.264 格式并写入输出文件。最后，我们使用 `av_write_trailer` 函数写入格式尾，并等待编码线程完成。在退出之前，我们释放所有使用的资源，并返回 0。