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

创建 RTSP 服务器需要使用 FFmpeg 和 C++，下面是一个简单的示例：

首先，需要包含 FFmpeg 和 C++ 的头文件：

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

#include <iostream>

然后，创建一个 RTSP 服务器类：

class RTSPServer {
public:
    RTSPServer() {}
    ~RTSPServer() {}

    int open(const char* url);
    void close();

private:
    AVFormatContext* m_formatCtx;
    AVCodecContext* m_codecCtx;
    AVStream* m_stream;
    AVPacket* m_packet;
    AVFrame* m_frame;
    uint8_t* m_frameBuffer;
    int m_frameBufferSize;

    void init(const char* url);
    void deinit();
    void encode();
    void send(AVFormatContext* formatCtx, AVStream* stream, AVPacket* packet);
};

`open()` 方法用于打开 RTSP 服务器，`close()` 方法用于关闭服务器。`init()` 方法用于初始化 FFmpeg 相关的数据结构，`deinit()` 方法用于释放这些数据结构。

`encode()` 方法用于编码一帧视频数据，`send()` 方法用于将编码后的数据发送到客户端。

下面是 `open()` 方法的实现：

int RTSPServer::open(const char* url) {
    init(url);

    AVDictionary* options = nullptr;
    av_dict_set(&options, "rtsp_transport", "tcp", 0);
    av_dict_set(&options, "muxdelay", "0.1", 0);

    int ret = avformat_write_header(m_formatCtx, &options);
    if (ret < 0) {
        std::cerr << "avformat_write_header error: " << av_err2str(ret) << std::endl;
        deinit();
        return ret;
    }

    while (true) {
        encode();
        send(m_formatCtx, m_stream, m_packet);
        av_packet_unref(m_packet);
    }

    return 0;
}

首先，调用 `init()` 方法初始化数据结构。然后，设置 RTSP 相关的选项。接着，调用 `avformat_write_header()` 方法写入文件头。

最后，进入一个循环，不断编码视频数据并发送到客户端。注意，这里没有实现 RTSP 的状态机，只是简单地发送视频数据。

下面是 `init()` 方法的实现：

void RTSPServer::init(const char* url) {
    av_register_all();
    avformat_network_init();

    m_formatCtx = nullptr;
    m_codecCtx = nullptr;
    m_stream = nullptr;
    m_packet = nullptr;
    m_frame = nullptr;
    m_frameBuffer = nullptr;
    m_frameBufferSize = 0;

    avformat_alloc_output_context2(&m_formatCtx, nullptr, "rtsp", url);
    if (!m_formatCtx) {
        std::cerr << "avformat_alloc_output_context2 error" << std::endl;
        return;
    }

    AVCodec* codec = avcodec_find_encoder_by_name("libx264");
    if (!codec) {
        std::cerr << "avcodec_find_encoder_by_name error" << std::endl;
        deinit();
        return;
    }

    m_stream = avformat_new_stream(m_formatCtx, codec);
    if (!m_stream) {
        std::cerr << "avformat_new_stream error" << std::endl;
        deinit();
        return;
    }

    m_codecCtx = avcodec_alloc_context3(codec);
    if (!m_codecCtx) {
        std::cerr << "avcodec_alloc_context3 error" << std::endl;
        deinit();
        return;
    }

    m_codecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    m_codecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
    m_codecCtx->width = 640;
    m_codecCtx->height = 480;
    m_codecCtx->time_base = { 1, 25 };
    m_codecCtx->framerate = { 25, 1 };
    m_codecCtx->bit_rate = 1000000;

    av_opt_set(m_codecCtx->priv_data, "preset", "ultrafast", 0);
    av_opt_set(m_codecCtx->priv_data, "tune", "zerolatency", 0);

    int ret = avcodec_open2(m_codecCtx, codec, nullptr);
    if (ret < 0) {
        std::cerr << "avcodec_open2 error: " << av_err2str(ret) << std::endl;
        deinit();
        return;
    }

    avcodec_parameters_from_context(m_stream->codecpar, m_codecCtx);

    m_packet = av_packet_alloc();
    if (!m_packet) {
        std::cerr << "av_packet_alloc error" << std::endl;
        deinit();
        return;
    }

    m_frame = av_frame_alloc();
    if (!m_frame) {
        std::cerr << "av_frame_alloc error" << std::endl;
        deinit();
        return;
    }

    m_frame->format = m_codecCtx->pix_fmt;
    m_frame->width = m_codecCtx->width;
    m_frame->height = m_codecCtx->height;

    ret = av_image_alloc(m_frame->data, m_frame->linesize, m_frame->width, m_frame->height, m_frame->format, 32);
    if (ret < 0) {
        std::cerr << "av_image_alloc error: " << av_err2str(ret) << std::endl;
        deinit();
        return;
    }

    m_frameBufferSize = av_image_get_buffer_size(m_frame->format, m_frame->width, m_frame->height, 32);
    m_frameBuffer = new uint8_t[m_frameBufferSize];
}

首先，调用 `av_register_all()` 和 `avformat_network_init()` 方法初始化 FFmpeg 库和网络协议。然后，分配 `AVFormatContext` 结构体。

接着，查找 libx264 编码器，并创建一个新的流。然后，分配 `AVCodecContext` 结构体，设置编码器的参数，并打开编码器。

接下来，将 `AVCodecContext` 中的参数赋值给 `AVStream` 中的 `AVCodecParameters`。分配 `AVPacket` 和 `AVFrame` 结构体，并设置 `AVFrame` 的参数。

最后，分配 `AVFrame` 的数据缓冲区。

下面是 `deinit()` 方法的实现：

void RTSPServer::deinit() {
    if (m_formatCtx) {
        avio_closep(&m_formatCtx->pb);
        avformat_free_context(m_formatCtx);
    }

    if (m_codecCtx) {
        avcodec_free_context(&m_codecCtx);
    }

    if (m_packet) {
        av_packet_free(&m_packet);
    }

    if (m_frame) {
        av_freep(&m_frame->data[0]);
        av_frame_free(&m_frame);
    }

    if (m_frameBuffer) {
        delete[] m_frameBuffer;
    }

    m_formatCtx = nullptr;
    m_codecCtx = nullptr;
    m_stream = nullptr;
    m_packet = nullptr;
    m_frame = nullptr;
    m_frameBuffer = nullptr;
    m_frameBufferSize = 0;

    avformat_network_deinit();
}

这个方法用于释放 FFmpeg 相关的数据结构。

下面是 `encode()` 方法的实现：

void RTSPServer::encode() {
    av_init_packet(m_packet);
    m_packet->data = nullptr;
    m_packet->size = 0;

    av_frame_make_writable(m_frame);

    // fill the frame with dummy data
    for (int y = 0; y < m_codecCtx->height; y++) {
        for (int x = 0; x < m_codecCtx->width; x++) {
            m_frame->data[0][y * m_frame->linesize[0] + x] = x + y;
        }
    }

    // convert frame from RGB to YUV
    SwsContext* swsCtx = sws_getContext(m_codecCtx->width, m_codecCtx->height, AV_PIX_FMT_RGB24,
        m_codecCtx->width, m_codecCtx->height, AV_PIX_FMT_YUV420P,
        SWS_BILINEAR, nullptr, nullptr, nullptr);
    sws_scale(swsCtx, m_frame->data, m_frame->linesize, 0, m_codecCtx->height, m_frame->data, m_frame->linesize);
    sws_freeContext(swsCtx);

    int ret = avcodec_send_frame(m_codecCtx, m_frame);
    if (ret < 0) {
        std::cerr << "avcodec_send_frame error: " << av_err2str(ret) << std::endl;
        return;
    }

    while (ret >= 0) {
        ret = avcodec_receive_packet(m_codecCtx, m_packet);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            return;
        } else if (ret < 0) {
            std::cerr << "avcodec_receive_packet error: " << av_err2str(ret) << std::endl;
            return;
        }

        m_packet->stream_index = m_stream->index;
        av_packet_rescale_ts(m_packet, m_codecCtx->time_base, m_stream->time_base);
        av_packet_rescale_ts(m_packet, m_stream->time_base, { 1, 90000 });
        av_interleaved_write_frame(m_formatCtx, m_packet);
    }
}

这个方法用于编码一帧视频数据。首先，创建一个空的 `AVPacket`，然后填充一个 RGB24 格式的 `AVFrame`，并将其转换为 YUV420P 格式。

然后，调用 `avcodec_send_frame()` 方法将 `AVFrame` 发送给编码器。接着，调用 `avcodec_receive_packet()` 方法从编码器中获取编码后的数据。

最后，将 `AVPacket` 的时间戳进行转换，并调用 `av_interleaved_write_frame()` 方法将数据写入到输出流中。

下面是 `send()` 方法的实现：

void RTSPServer::send(AVFormatContext* formatCtx, AVStream* stream, AVPacket* packet) {
    int ret = av_write_frame(formatCtx, packet);
    if (ret < 0) {
        std::cerr << "av_write_frame error: " << av_err2str(ret) << std::endl;
        return;
    }

    av_usleep(1000000 / 25);
}

这个方法用于将编码后的数据发送到客户端。这里使用了 `av_write_frame()` 方法将 `AVPacket` 写入到输出流中。注意，这里没有实现 RTSP 的状态机，只是简单地让发送的数据按照一定的速率发送。

最后，我们可以在 `main()` 函数中创建一个 `RTSPServer` 对象，并调用 `open()` 方法打开 RTSP 服务器：

int main(int argc, char* argv[]) {
    RTSPServer server;
    server.open("rtsp://127.0.0.1:8554/live");
    return 0;
}

这里将 RTSP 服务器的地址设置为 `rtsp://127.0.0.1:8554/live`，可以根据实际情况进行修改。