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

创建一个 RTSP 服务器需要以下步骤：

1. 使用 FFmpeg 解码视频文件。
2. 使用 Live555 开发 RTSP 服务器。
3. 将解码后的视频数据通过 RTP 协议发送到客户端。

以下是一个基本的示例代码，使用 C++ 和 FFmpeg 创建 RTSP 服务器：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

#include <liveMedia.hh>
#include <BasicUsageEnvironment.hh>
#include <GroupsockHelper.hh>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}

// 视频文件名和分辨率
const char* kVideoFileName = "test.mp4";
const int kVideoWidth = 640;
const int kVideoHeight = 480;

class H264VideoServerMediaSubsession : public OnDemandServerMediaSubsession {
public:
    static H264VideoServerMediaSubsession* createNew(UsageEnvironment& env, char const* fileName);
    ~H264VideoServerMediaSubsession();

private:
    H264VideoServerMediaSubsession(UsageEnvironment& env, char const* fileName);

private:
    virtual char const* getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource);
    virtual FramedSource* createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate);
    virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource);
    virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);

private:
    char* fFileName;
    AVFormatContext* fFormatCtx;
    AVCodecContext* fCodecCtx;
    AVCodec* fCodec;
    AVFrame* fFrame;
    struct SwsContext* fSwsCtx;
    unsigned char* fBuffer;
    int fBufferSize;
};

H264VideoServerMediaSubsession*
H264VideoServerMediaSubsession::createNew(UsageEnvironment& env, char const* fileName) {
    return new H264VideoServerMediaSubsession(env, fileName);
}

H264VideoServerMediaSubsession::H264VideoServerMediaSubsession(UsageEnvironment& env, char const* fileName)
    : OnDemandServerMediaSubsession(env, True /*reuse the first source*/),
    fFileName(strDup(fileName)), fFormatCtx(NULL), fCodecCtx(NULL), fCodec(NULL), fFrame(NULL),
    fSwsCtx(NULL), fBuffer(NULL), fBufferSize(0) {
    AVCodecParameters* codecpar = NULL;
    if (avformat_open_input(&fFormatCtx, fileName, NULL, NULL) != 0) {
        fprintf(stderr, "Cannot open input file '%s'\n", fileName);
        return;
    }
    if (avformat_find_stream_info(fFormatCtx, NULL) < 0) {
        fprintf(stderr, "Cannot find stream information\n");
        return;
    }
    for (unsigned i = 0; i < fFormatCtx->nb_streams; i++) {
        AVStream* stream = fFormatCtx->streams[i];
        codecpar = stream->codecpar;
        if (codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            fCodec = avcodec_find_decoder(codecpar->codec_id);
            if (fCodec == NULL) {
                fprintf(stderr, "Unsupported codec!\n");
                return;
            }
            fCodecCtx = avcodec_alloc_context3(fCodec);
            avcodec_parameters_to_context(fCodecCtx, codecpar);
            avcodec_open2(fCodecCtx, fCodec, NULL);
            fFrame = av_frame_alloc();
            fSwsCtx = sws_getContext(codecpar->width, codecpar->height, fCodecCtx->pix_fmt,
                kVideoWidth, kVideoHeight, AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
            fBufferSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, kVideoWidth, kVideoHeight, 16);
            fBuffer = (unsigned char*)av_malloc(fBufferSize);
            break;
        }
    }
}

H264VideoServerMediaSubsession::~H264VideoServerMediaSubsession() {
    delete[] fFileName;
    if (fFormatCtx) {
        avformat_close_input(&fFormatCtx);
    }
    if (fCodecCtx) {
        avcodec_close(fCodecCtx);
        avcodec_free_context(&fCodecCtx);
    }
    if (fFrame) {
        av_frame_free(&fFrame);
    }
    if (fSwsCtx) {
        sws_freeContext(fSwsCtx);
    }
    if (fBuffer) {
        av_free(fBuffer);
    }
}

char const* H264VideoServerMediaSubsession::getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource) {
    return inputSource->auxSDPLine();
}

FramedSource* H264VideoServerMediaSubsession::createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate) {
    estBitrate = 500;
    return H264VideoStreamFramer::createNew(envir(), new FFmpegVideoSource(fFormatCtx, fCodecCtx, fFrame, fSwsCtx, fBuffer, fBufferSize));
}

RTPSink* H264VideoServerMediaSubsession::createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource) {
    return H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
}

void H264VideoServerMediaSubsession::seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes) {
    FFmpegVideoSource* videoSrc = dynamic_cast<FFmpegVideoSource*>(inputSource);
    if (videoSrc == NULL) {
        return;
    }
    seekNPT = videoSrc->seekToByteAbsolute(numBytes);
}

class MyRTSPServer : public RTSPServer {
public:
    static MyRTSPServer* createNew(UsageEnvironment& env, Port port, UserAuthenticationDatabase* authDatabase = NULL, unsigned reclamationTestSeconds = 65);

private:
    MyRTSPServer(UsageEnvironment& env, int ourSocket, Port ourPort, UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds);
    virtual ServerMediaSession* lookupServerMediaSession(char const* streamName, Boolean isFirstLookupInSession);
    virtual void incomingConnection(int serverSocket);

private:
    ServerMediaSession* fSMS;
};

MyRTSPServer* MyRTSPServer::createNew(UsageEnvironment& env, Port port, UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds) {
    int ourSocket = setUpOurSocket(env, port);
    if (ourSocket == -1) {
        return NULL;
    }
    return new MyRTSPServer(env, ourSocket, port, authDatabase, reclamationTestSeconds);
}

MyRTSPServer::MyRTSPServer(UsageEnvironment& env, int ourSocket, Port ourPort, UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds)
    : RTSPServer(env, ourSocket, ourPort, authDatabase, reclamationTestSeconds, True) {
    fSMS = ServerMediaSession::createNew(env, "test", "test", "session description", True);
    fSMS->addSubsession(H264VideoServerMediaSubsession::createNew(env, kVideoFileName));
}

ServerMediaSession* MyRTSPServer::lookupServerMediaSession(char const* streamName, Boolean isFirstLookupInSession) {
    return fSMS;
}

void MyRTSPServer::incomingConnection(int serverSocket) {
    MyRTSPServer* server = new MyRTSPServer(envir(), serverSocket, port(), NULL, 65);
    if (server == NULL) {
        fprintf(stderr, "Failed to create new RTSP server\n");
        return;
    }
    server->setUpTunnelingOverHTTP(serverSocket);
}

int main(int argc, char** argv) {
    av_register_all();
    avformat_network_init();
    avcodec_register_all();

    TaskScheduler* scheduler = BasicTaskScheduler::createNew();
    UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);

    MyRTSPServer* server = MyRTSPServer::createNew(*env, 8554);
    if (server == NULL) {
        fprintf(stderr, "Failed to create new RTSP server\n");
        return EXIT_FAILURE;
    }

    signal(SIGINT, [](int) { env->taskScheduler().stopScheduler(); });

    env->taskScheduler().doEventLoop();

    return EXIT_SUCCESS;
}

在此示例代码中，我们使用 `H264VideoServerMediaSubsession` 类创建一个带有 H.264 编码视频源的 `ServerMediaSession` 对象。`H264VideoServerMediaSubsession` 类继承自 `OnDemandServerMediaSubsession`，并实现了以下虚拟函数：

- `getAuxSDPLine()`: 获取 SDP 描述。
- `createNewStreamSource()`: 创建新的视频源。
- `createNewRTPSink()`: 创建新的 RTP sink。
- `seekStreamSource()`: 调整视频源的时间戳。

在 `H264VideoServerMediaSubsession` 类中，我们使用 FFmpeg 解码视频文件，并将解码后的视频数据转换为 YUV420P 格式。然后，我们使用 `FFmpegVideoSource` 类将解码后的视频数据封装为视频源对象。最后，我们使用 `H264VideoStreamFramer` 类将视频源转换为 H.264 帧。

在 `MyRTSPServer` 类中，我们创建一个新的 `ServerMediaSession` 对象，并将 `H264VideoServerMediaSubsession` 对象添加为其中的子会话。然后，我们重写了 `lookupServerMediaSession()` 函数，以便在每次查找媒体会话时返回创建的 `ServerMediaSession` 对象。

最后，在 `main()` 函数中，我们创建一个新的 `MyRTSPServer` 对象，并将其绑定到 8554 端口。然后，我们使用 `TaskScheduler` 类启动事件循环并等待客户端连接。当收到 SIGINT 信号时，我们停止事件循环并退出程序。

请注意，此示例代码仅用于演示目的。实际使用中，您需要根据您的具体需求进行修改和调整。