RTSP API#

Oasis supports an RTSP server.

Supported video codecs are H264 and H265, and audio codecs are OPUS, AAC, MP3, and PCM. For live streaming, OPUS operates as the default codec.

Header File#

OasisRtsp.h

URL Format#

The URL format used when a client media player, such as VLC, connects to the Oasis RTSP server is as follows:

rtsp://<Server Address>[:Port Number][/RTSP Streaming Session Configuration Key-Value List]/<Streaming Destination Path>

• Server Address: The address of the RTSP server.

• Port Number: If not specified, the default value is 554.

• RTSP Streaming Session Configuration Key-Value List: This is optional and supports the following key-values. Each key-value pair is separated by "&".

• Streaming Destination Path: Specifies the target to be streamed. A live camera path or a file path can be specified. In the case of a file path, it must be located within the root-dir specified when creating the RTSP server. The live camera path is formatted as Live/<Camera Device ID>. <Camera Device ID> is the value specified as a key-value map in the oasis::configCameras API. In the case of a file path, a relative path is specified based on root-dir. If a video file contains multiple video tracks, a specific track can be specified in the format of /<File Path>/TrackID=<Track Number>.

Below are examples of URLs:

RtspEventDelegate Interface#

The user can verify events occurring during streaming between the RTSP server and connected clients by creating an object derived from the RtspEventDelegate interface.

This interface is not mandatory for the operation of the RTSP server.

class RtspEventDelegate : public std::enable_shared_from_this<RtspEventDelegate>
{
public:
    RtspEventDelegate();
    virtual ~RtspEventDelegate();

public:
    virtual void onDescription(const char *uri, const char *remote, const char *sdp);
    virtual void onSetup(const char *uri, const char *remote, const char *transport_line);
    virtual void onPlay(const char *uri, const char *remote, const char *rtp_info);
    virtual void onTeardown(const char *uri, const char *remote);
    virtual void onPause(const char *uri, const char *remote);
    virtual void onError(int error_code, const char *error_msg, const char *error_desc);
    virtual void onClosed(const char *uri, const char *remote);
};

The error response codes sent by the RTSP server are as follows:

Functions#

Example#

Below is an RTSP server example.

#include "OasisAPI.h"
#include "OasisLog.h"
#include "OasisRtsp.h"

#include <thread>
#include <mutex>
#include <memory>
#include <condition_variable>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <signal.h>

#define DLOG_TRACE  0x00080000

#undef DLOG_FLAGS
#define  DLOG_FLAGS (DLOG_FLAGS_DEFAULT|DLOG_TRACE/***/)

#undef DLOG_TAG
#define DLOG_TAG "RTSP"

#define RTSP_PORT  554

using namespace oasis;

namespace oasis {
    uint64_t getFreeMemorySize();
}

static bool continuing = true;

void cancel_handler(int signum)
{
    continuing = false;
}



int main(int argc, char* argv[])
{
    int32_t err;
    int32_t c;
    std::thread t2, t3;

    uint16_t rtsp_port = RTSP_PORT;
    RtspServerRef rtsp_server;

    oasis::key_value_map_t parameters;

    parameters["offs-disable"] = "1";
    if(oasis::initialize(parameters) < 0) {
        DLOG(DLOG_ERROR, "Oasis init failed\n");
        return -1;
    }

    //Oasis set SIGINT
    signal(SIGINT, cancel_handler);


    // config cameras
    // ...

    // Create RTSP server

    parameters.clear();
    parameters["port"] = std::to_string(rtsp_port);
    parameters["root-dir"] = "/mnt/extsd";
    parameters["remote-pool-size"] = std::to_string(20); //max con-current network connections
    parameters["scheduler-size"] = std::to_string(10); //max working threads
    parameters["upstreamer-size"] = std::to_string(10); //max working threads
    parameters["transmitter-size"] = std::to_string(15);
    parameters["timer-size"] = std::to_string(3);
    parameters["file-session-max"] = std::to_string(1);  //0: unlimited
    parameters["live-session-max"] = std::to_string(6);  //0: unlimited 
    parameters["linger-time-max"] = std::to_string(1000);   
    parameters["rtp-data-size-max"] = std::to_string(1024); 
    parameters["rtp-packet-pool-count-max"] = std::to_string(6);    
    parameters["rtp-packet-pool-size"] = std::to_string(256);   

    rtsp_server = createRtspServer(parameters);
    if(rtsp_server) {
        // Start RTSP server
        err = oasis::startRtspServer(rtsp_server);
        ASSERT(err == 0);
        if(err < 0) {
            DLOG(DLOG_ERROR, "RTSP server failed\n");
            goto done;
        }
        DLOG(DLOG_TRACE, "RTSP running at %d...\n", rtsp_port);
    }

    do {
        usleep(10000);
    } while(continuing);

if(rtsp_server) {
        oasis::destroyRtspServer(rtsp_server);
    }

    oasis::finalize();

    return 0;
}