uvgRTP

https://ultravideo.github.io/uvgRTP/
Admin
uvgRTP is an open-source library for RTP/SRTP media delivery that supports various audio and video...
Tokens:63,900
Snippets:437
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### RTCP Hook Installation Methods

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1rtcp-members.html

Methods to install callback hooks for receiving various RTCP packet types.

```APIDOC
## install_app_hook / install_receiver_hook / install_sdes_hook / install_sender_hook

### Description
Installs a callback function to handle incoming RTCP APP, Receiver Report, SDES, or Sender Report packets.

### Parameters
#### Request Body
- **hook/handler** (function) - Required - The callback function or std::function to execute when a packet is received.
```

--------------------------------

### RTCP Hook Installation

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Methods for installing hooks to process incoming RTCP packets.

```APIDOC
## install_receiver_hook

### Description
Install an RTCP Receiver Report hook.

### Parameters
- **hook** (void(*)(uvgrtp::frame::rtcp_receiver_report *)) - Required - Function pointer for the hook.
- **rr_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_receiver_report>)>) - Required - Handler function for the hook.

## install_sender_hook

### Description
Install an RTCP Sender Report hook.

### Parameters
- **hook** (void(*)(uvgrtp::frame::rtcp_sender_report *)) - Required - Function pointer for the hook.
- **sr_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sender_report>)>) - Required - Handler function for the hook.

## install_sdes_hook

### Description
Install an RTCP SDES packet hook.

### Parameters
- **sdes_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sdes_packet>)>) - Required - Handler function for the hook.

## install_app_hook

### Description
Install an RTCP APP packet hook.

### Parameters
- **hook** (void(*)(uvgrtp::frame::rtcp_app_packet *)) - Required - Function pointer for the hook.
- **app_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_app_packet>)>) - Required - Handler function for the hook.
```

--------------------------------

### Start ZRTP Session

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Starts the ZRTP negotiation for a media stream. This function is used to initiate secure RTP sessions.

```cpp
rtp_error_t start_zrtp();
```

--------------------------------

### Simple Sending and Receiving Example

Source: https://ultravideo.github.io/uvgRTP/html/index.html

A basic example demonstrating the creation of a session and media stream, sending a message, receiving it, and then cleaning up resources. Compile with g++ main.cc -luvgrtp -lpthread.

```cpp
#include <uvgrtp/lib.hh>
/* g++ main.cc -luvgrtp -lpthread && ./a.out */
int main(void)
{
uvgrtp::context ctx;
uvgrtp::session *sess = ctx.create_session("127.0.0.1");
uvgrtp::media_stream *strm = sess->create_stream(8888, 8888, RTP_FORMAT_GENERIC, RCE_NO_FLAGS);
strm->configure_ctx(RCC_MTU_SIZE, 2312);
char *message = (char *)"Hello, world!";
size_t msg_len = strlen(message) + 1;
for (;;)
{
strm->push_frame((uint8_t *)message, msg_len, RTP_NO_FLAGS);
auto frame = strm->pull_frame();
fprintf(stderr, "Message: '%s'\n", frame->payload);
uvgrtp::frame::dealloc_frame(frame);
}
sess->destroy_stream(strm);
ctx.destroy_session(sess);
}
```

--------------------------------

### Install Receive Hook Callback

Source: https://ultravideo.github.io/uvgRTP/html/index.html

Installs a callback function to handle incoming media frames. This method is recommended to minimize latency. The user must deallocate the received frame.

```cpp
strm->install_receive_hook(nullptr, rtp_receive_hook);
```

--------------------------------

### media_stream::start_zrtp

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream.html

Starts the ZRTP negotiation manually.

```APIDOC
## POST /media_stream/start_zrtp

### Description
Start the ZRTP negotiation manually.

### Method
POST

### Endpoint
/media_stream/start_zrtp

### Response
#### Success Response (200)
- **rtp_error_t** (integer) - RTP error code. RTP_OK on success.

#### Error Response
- **rtp_error_t** (integer) - RTP error code indicating failure.
```

--------------------------------

### uvgrtp::media_stream::install_receive_hook

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Installs a hook to asynchronously receive frames.

```APIDOC
## uvgrtp::media_stream::install_receive_hook

### Description
Asynchronous way of getting frames.

### Method
rtp_error_t install_receive_hook(void *arg, void(*hook)(void *, uvgrtp::frame::rtp_frame *))

### Endpoint
N/A (Method within a class)

### Parameters
#### Request Body
- **arg** (void *) - User-defined argument to pass to the hook.
- **hook** (void(*)(void *, uvgrtp::frame::rtp_frame *)) - The callback function to be executed when a frame is received.

### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### media_stream::install_receive_hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream.html

Installs a hook for asynchronous frame reception.

```APIDOC
## POST /media_stream/install_receive_hook

### Description
Asynchronous way of getting frames.

### Method
POST

### Endpoint
/media_stream/install_receive_hook

### Parameters
#### Request Body
- **arg** (void*) - Required - Argument to be passed to the hook function.
- **hook** (void(*)(void *, uvgrtp::frame::rtp_frame *)) - Required - Pointer to the hook function.

### Response
#### Success Response (200)
- **rtp_error_t** (integer) - RTP error code. RTP_OK on success.

#### Error Response
- **rtp_error_t** (integer) - RTP error code indicating failure.
```

--------------------------------

### Install RTCP SDES Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a callback function to handle incoming RTCP SDES (Source Description) packets. The handler is invoked when an SDES packet is received.

```cpp
rtp_error_t install_sdes_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_sdes_packet>)> sdes_handler);
```

--------------------------------

### Install RTCP SDES Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a callback function to process incoming RTCP SDES packets. This hook allows for custom handling of Sender Description packets.

```APIDOC
## uvgrtp::rtcp::install_sdes_hook

### Description
Install an RTCP SDES packet hook.

### Method
Not applicable (function signature)

### Endpoint
Not applicable (function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
rtp_error_t install_sdes_hook(void(*hook)(uvgrtp::frame::rtcp_sdes_packet *))
```

### Response
#### Success Response (200)
Not applicable (function return type)

#### Response Example
```cpp
rtp_error_t
```
```

--------------------------------

### Install SDES Hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1rtcp.html

Installs a hook that is called when an RTCP SDES packet is received. Two overloads are provided for different handler types.

```APIDOC
## POST /rtcp/install_sdes_hook

### Description
Installs an RTCP SDES packet hook. This function is called when an RTCP SDES packet is received.

### Method
POST

### Endpoint
/rtcp/install_sdes_hook

### Parameters
#### Request Body
- **sdes_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sdes_packet>)>) - Required - C++ function pointer to the hook.
- **hook** (void(*)(uvgrtp::frame::rtcp_sdes_packet*)) - Required - Function pointer to the hook.

### Response
#### Success Response (200)
- **rtp_error_t** (RTP_OK) - Indicates success.

#### Error Response (400)
- **rtp_error_t** (RTP_INVALID_VALUE) - If hook is nullptr.
```

--------------------------------

### Install RTCP Application-Defined Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a callback function to handle incoming RTCP application-defined packets. The handler is invoked when an APP packet is received.

```cpp
rtp_error_t install_app_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_app_packet>)> app_handler);
```

--------------------------------

### Install Receive Hook

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Installs a custom receive hook function that will be called when a frame is received. The hook receives a void pointer for user data and a pointer to the received rtp_frame.

```cpp
rtp_error_t install_receive_hook(void *arg, void (*hook)(void *, uvgrtp::frame::rtp_frame *));
```

--------------------------------

### Install RTCP Sender Report Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a callback function to handle incoming RTCP sender reports. The handler is invoked when a sender report packet is received.

```cpp
rtp_error_t install_sender_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_sender_report>)> sr_handler);
```

--------------------------------

### SRTP Context Management

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Methods for adding SRTP context and starting ZRTP negotiation.

```APIDOC
## SRTP Context Management

### Description
Manages SRTP context and ZRTP negotiation for secure media streams.

### Methods

#### `rtp_error_t start_zrtp()`
Starts the ZRTP negotiation process for SRTP.

#### `rtp_error_t add_srtp_ctx(uint8_t *key, uint8_t *salt)`
Adds an SRTP context with the provided key and salt.

**Parameters:**
- **key** (uint8_t*) - The SRTP key.
- **salt** (uint8_t*) - The SRTP salt.
```

--------------------------------

### Install RTCP Send Application Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a callback function for sending application-defined RTCP data. This function is called when the library needs to send custom RTCP data.

```cpp
rtp_error_t install_send_app_hook(std::string app_name, std::function<std::unique_ptr<uint8_t[]>(uint8_t& subtype, uint32_t& payload_len)> app_sending_func);
```

--------------------------------

### ZRTP Session Initiation

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream-members.html

Method for starting a ZRTP (The ZRTP Protocol) session for secure media transmission.

```APIDOC
## uvgrtp::media_stream ZRTP Session

### Description
Initiates a secure media session using the ZRTP protocol.

### Method

- **start_zrtp()**
  - Description: Starts the ZRTP session for secure media delivery.
  - Returns: void
```

--------------------------------

### Install RTCP Receiver Report Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a callback function to handle incoming RTCP receiver reports. The handler is invoked when a receiver report packet is received.

```cpp
rtp_error_t install_receiver_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_receiver_report>)> rr_handler);
```

--------------------------------

### Enable SRTP with ZRTP and NULL cipher

Source: https://ultravideo.github.io/uvgRTP

Example of passing multiple RCE flags to the create_stream method to configure SRTP security settings.

```cpp
session->create_stream(..., RCE_SRTP | RCE_SRTP_KMNGMNT_ZRTP | RCE_SRTP_NULL_CIPHER);
```

--------------------------------

### Install RTCP Sender Report Hook (Function Pointer)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a C-style function pointer hook for receiving RTCP Sender Reports. This hook is invoked when a Sender Report is received.

```cpp
rtp_error_t install_sender_hook(void(*hook)(uvgrtp::frame::rtcp_sender_report *))
```

--------------------------------

### Install Send APP Hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1rtcp.html

Installs a hook for sending application-defined APP packets. This function is called each time an RR/SR is sent to retrieve data for the APP packet.

```APIDOC
## POST /rtcp/install_send_app_hook

### Description
Install hook for one type of APP packets. Each time the RR/SR is sent, all APP sending hooks call their respective functions to get the data.

### Method
POST

### Endpoint
/rtcp/install_send_app_hook

### Parameters
#### Request Body
- **app_name** (std::string) - Required - Name of the APP packet. Max 4 chars.
- **app_sending_func** (std::function<std::unique_ptr<uint8_t[]>(uint8_t &subtype, uint32_t &payload_len)>) - Required - The function to be called when hook fires.

### Response
#### Success Response (200)
- **rtp_error_t** (RTP_OK) - Indicates success.

#### Error Response (400)
- **rtp_error_t** (RTP_INVALID_VALUE) - If app_name is empty or longer than 4 characters or function pointer is empty.
```

--------------------------------

### Install RTCP Receiver Report Hook (Function Pointer)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a C-style function pointer hook for receiving RTCP Receiver Reports. This hook is called when a Receiver Report is received.

```cpp
rtp_error_t install_receiver_hook(void(*hook)(uvgrtp::frame::rtcp_receiver_report *))
```

--------------------------------

### Install RTCP APP Hook (Function Pointer)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a C-style function pointer hook for receiving RTCP APP packets. This hook is called when an application-defined RTCP packet is received.

```cpp
rtp_error_t install_app_hook(void(*hook)(uvgrtp::frame::rtcp_app_packet *))
```

--------------------------------

### RTCP Class API

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Documentation for the RTCP class, including its constructor, start, and stop methods.

```APIDOC
## RTCP Class

### Description
Provides functionality for Real-time Transport Control Protocol (RTCP) operations, including starting and stopping RTCP sessions and generating reports.

### Methods

#### `rtcp(std::shared_ptr<uvgrtp::rtp> rtp, std::shared_ptr<std::atomic<std::uint32_t>> ssrc, std::shared_ptr<std::atomic<uint32_t>> remote_ssrc, std::string cname, std::shared_ptr<uvgrtp::socketfactory> sfp, int rce_flags)`
Constructor for the RTCP class.

#### `rtcp(std::shared_ptr<uvgrtp::rtp> rtp, std::shared_ptr<std::atomic<std::uint32_t>> ssrc, std::shared_ptr<std::atomic<uint32_t>> remote_ssrc, std::string cname, std::shared_ptr<uvgrtp::socketfactory> sfp, std::shared_ptr<uvgrtp::srtcp> srtcp, int rce_flags)`
Constructor for the RTCP class with SRTCP support.

#### `~rtcp()`
Destructor for the RTCP class.

#### `rtp_error_t start()`
Starts the RTCP runner thread.

**Return Value:**
- `RTP_OK` on success.
- `RTP_MEMORY_ERROR` if allocation fails.

#### `rtp_error_t stop()`
Ends the RTCP session and sends RTCP BYE to all participants.

**Return Value:**
- `RTP_OK` on success.

#### `rtp_error_t generate_report()`
Generates either an RTCP Sender Report or Receiver Report and sends it to all participants.

**Return Value:**
- `RTP_OK` on success.
- `RTP_ERROR` on error.
```

--------------------------------

### Get uvgRTP Version Information

Source: https://ultravideo.github.io/uvgRTP/html/version_8hh_source.html

Retrieve the version string, major, minor, and patch components of the uvgRTP library. Also includes the Git hash for precise version tracking.

```cpp
#include <cstdint>
#include <string>

namespace uvgrtp {
std::string get_version();
uint16_t get_version_major();
uint16_t get_version_minor();
uint16_t get_version_patch();
std::string get_git_hash();
} // namespace uvgrtp
```

--------------------------------

### media_stream::add_srtp_ctx

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream.html

Adds keying information for a user-managed SRTP session. The media stream will not start until SRTP key has been added.

```APIDOC
## POST /media_stream/add_srtp_ctx

### Description
Adds keying information for user-managed SRTP session. For user-managed SRTP session (flag RCE_SRTP_KMNGMNT_USER), the media stream is not started until SRTP key has been added and all calls to push_frame() will fail.

### Method
POST

### Endpoint
/media_stream/add_srtp_ctx

### Parameters
#### Request Body
- **key** (uint8_t*) - Required - SRTP master key, default is 128-bit long
- **salt** (uint8_t*) - Required - 112-bit long salt

### Response
#### Success Response (200)
- **rtp_error_t** (integer) - RTP error code. RTP_OK on success.

#### Error Response
- **rtp_error_t** (integer) - RTP_INVALID_VALUE if key or salt is invalid.
- **rtp_error_t** (integer) - RTP_NOT_SUPPORTED if user-managed SRTP was not specified in create_stream().
```

--------------------------------

### install_app_hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1rtcp.html

Installs a hook to be called when an RTCP APP packet is received. Two overloads are provided: one for C++ function pointers and one for std::function objects.

```APIDOC
## install_app_hook

### Description
Installs a hook to be called when an RTCP APP packet is received.

### Parameters
#### Path Parameters
- **app_handler / hook** (std::function or function pointer) - Required - The callback function to be executed upon receiving an APP packet.

### Response
#### Success Response (RTP_OK)
- **rtp_error_t** - Returns RTP_OK on success.

#### Error Response (RTP_INVALID_VALUE)
- **rtp_error_t** - Returns RTP_INVALID_VALUE if the provided hook is nullptr.
```

--------------------------------

### Install RTCP SDES packet hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Registers a callback function to process incoming RTCP SDES packets.

```cpp
rtp_error_t install_sdes_hook(void(*hook)(uvgrtp::frame::rtcp_sdes_packet *))
```

--------------------------------

### Media Stream Configuration and Control

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream-members.html

Methods for configuring and controlling the media stream, including SRTP context setup and RTCP retrieval.

```APIDOC
## uvgrtp::media_stream Configuration and Control

### Description
Provides methods for setting up SRTP contexts, configuring stream parameters, and retrieving RTCP information.

### Methods

- **add_srtp_ctx(uint8_t *key, uint8_t *salt)**
  - Description: Adds an SRTP context with the provided key and salt.
  - Parameters:
    - `key` (uint8_t*) - The SRTP key.
    - `salt` (uint8_t*) - The SRTP salt.

- **configure_ctx(int rcc_flag, ssize_t value)**
  - Description: Configures a context flag with a specific value.
  - Parameters:
    - `rcc_flag` (int) - The configuration flag.
    - `value` (ssize_t) - The value to set for the flag.

- **get_configuration_value(int rcc_flag)**
  - Description: Retrieves the value of a specific configuration flag.
  - Parameters:
    - `rcc_flag` (int) - The configuration flag to query.
  - Returns: The value of the configuration flag.

- **get_rtcp()**
  - Description: Retrieves the RTCP (RTP Control Protocol) information.
  - Returns: RTCP information.

- **get_ssrc() const**
  - Description: Retrieves the SSRC (Synchronization Source) identifier of the stream.
  - Returns: The SSRC identifier.
```

--------------------------------

### Install RTCP Hooks

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Registers callback functions to be triggered when specific RTCP packets are received. Supports both raw function pointers and std::function handlers.

```cpp
rtp_error_t install_sender_hook(void (*hook)(uvgrtp::frame::rtcp_sender_report *));
rtp_error_t install_sender_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sender_report>)> sr_handler);
rtp_error_t install_receiver_hook(void (*hook)(uvgrtp::frame::rtcp_receiver_report *));
rtp_error_t install_receiver_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_receiver_report>)> rr_handler);
rtp_error_t install_sdes_hook(void (*hook)(uvgrtp::frame::rtcp_sdes_packet *));
rtp_error_t install_sdes_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sdes_packet>)> sdes_handler);
rtp_error_t install_app_hook(void (*hook)(uvgrtp::frame::rtcp_app_packet *));
rtp_error_t install_app_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_app_packet>)> app_handler);
```

--------------------------------

### start_zrtp()

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream.html

Manually initiates the ZRTP negotiation process for secure media streams.

```APIDOC
## start_zrtp()

### Description
Starts the ZRTP negotiation manually. This is used when the stream was created without automatic ZRTP negotiation flags.

### Response
#### Success Response (RTP_OK)
- **Return** (rtp_error_t) - Returns RTP_OK on success.

#### Error Responses
- **RTP_TIMEOUT** - ZRTP negotiation timed out.
- **RTP_GENERIC_ERROR** - Other errors.
```

--------------------------------

### uvgrtp::media_stream::start_zrtp

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Initiates the ZRTP negotiation process manually.

```APIDOC
## uvgrtp::media_stream::start_zrtp

### Description
Start the ZRTP negotiation manually.

### Method
rtp_error_t start_zrtp()

### Endpoint
N/A (Method within a class)

### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Create uvgRTP Context

Source: https://ultravideo.github.io/uvgRTP/html/index.html

Initialize the uvgRTP library by creating a context object. This must be done before any other uvgRTP operations.

```cpp
uvgrtp::context ctx;
```

--------------------------------

### Install Sender Report Hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1rtcp.html

Installs a hook that is called when an RTCP Sender Report is received. Two overloads are provided for different handler types.

```APIDOC
## POST /rtcp/install_sender_hook

### Description
Installs an RTCP Sender Report hook. This function is called when an RTCP Sender Report is received.

### Method
POST

### Endpoint
/rtcp/install_sender_hook

### Parameters
#### Request Body
- **sr_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sender_report>)>) - Required - C++ function pointer to the hook.
- **hook** (void(*)(uvgrtp::frame::rtcp_sender_report*)) - Required - Function pointer to the hook.

### Response
#### Success Response (200)
- **rtp_error_t** (RTP_OK) - Indicates success.

#### Error Response (400)
- **rtp_error_t** (RTP_INVALID_VALUE) - If hook is nullptr.
```

--------------------------------

### Install Receiver Report Hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1rtcp.html

Installs a hook that is called when an RTCP Receiver Report is received. Two overloads are provided for different handler types.

```APIDOC
## POST /rtcp/install_receiver_hook

### Description
Installs an RTCP Receiver Report hook. This function is called when an RTCP Receiver Report is received.

### Method
POST

### Endpoint
/rtcp/install_receiver_hook

### Parameters
#### Request Body
- **rr_handler** (std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_receiver_report>)>) - Required - C++ function pointer to the hook.
- **hook** (void(*)(uvgrtp::frame::rtcp_receiver_report*)) - Required - Function pointer to the hook.

### Response
#### Success Response (200)
- **rtp_error_t** (RTP_OK) - Indicates success.

#### Error Response (400)
- **rtp_error_t** (RTP_INVALID_VALUE) - If hook is nullptr.
```

--------------------------------

### Session Configuration and Getters

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Methods for retrieving session information and configuring network addresses and bandwidth.

```cpp
uint32_t get_rtcp_interval_ms() const;
void set_session_bandwidth(uint32_t kbps);
std::shared_ptr<uvgrtp::socket> get_socket() const;
rtp_error_t set_network_addresses(std::string local_addr, std::string remote_addr,
uint16_t local_port, uint16_t dst_port, bool ipv6);
std::vector<uint32_t> get_participants() const;
void set_ts_info(uint64_t clock_start, uint32_t clock_rate, uint32_t rtp_ts_start);
```

--------------------------------

### Install RTCP APP Hook (std::function)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a std::function hook for receiving RTCP APP packets. This allows custom handling of application-defined data.

```cpp
rtp_error_t install_app_hook(std::function< void(std::unique_ptr< uvgrtp::frame::rtcp_app_packet >)> app_handler)
```

--------------------------------

### Create uvgRTP Stream

Source: https://ultravideo.github.io/uvgRTP/html/wrapper__c_8hh_source.html

Sets up a media stream within an existing session, specifying local and remote ports and RTP flags.

```c
#include "uvgrtp.h"

void* uvgrtp_session;
void* uvgrtp_stream;
uint16_t local_port = 8888;
uint16_t remote_port = 9999;
int rce_flags = 0; // Example flags

// Assume uvgrtp_session is already created
uvgrtp_create_stream(uvgrtp_session, &uvgrtp_stream, local_port, remote_port, rce_flags);
```

--------------------------------

### Create uvgRTP Context

Source: https://ultravideo.github.io/uvgRTP/html/wrapper__c_8hh_source.html

Initializes the uvgRTP library context. This must be called before any other uvgRTP functions.

```c
#include "uvgrtp.h"

void* uvgrtp_context;
uvgrtp_create_ctx(&uvgrtp_context);
```

--------------------------------

### uvgRTP Configuration and Format Constants

Source: https://ultravideo.github.io/uvgRTP/html/globals_eval.html

A reference list of available enumerations for RTP configuration, session flags, and media formats.

```APIDOC
## Enumerations Reference

### Description
This section lists the constants used for configuring RTP sessions, defining media formats, and setting execution flags in the uvgRTP library.

### Configuration Constants (RCC)
- **RCC_CLOCK_RATE**
- **RCC_DYN_PAYLOAD_TYPE**
- **RCC_FPS_DENOMINATOR**
- **RCC_FPS_NUMERATOR**
- **RCC_MTU_SIZE**
- **RCC_MULTICAST_TTL**
- **RCC_PKT_MAX_DELAY**
- **RCC_POLL_TIMEOUT**
- **RCC_REMOTE_SSRC**
- **RCC_RING_BUFFER_SIZE**
- **RCC_SESSION_BANDWIDTH**
- **RCC_SSRC**
- **RCC_UDP_RCV_BUF_SIZE**
- **RCC_UDP_SND_BUF_SIZE**

### Execution Flags (RCE)
- **RCE_FRAGMENT_GENERIC**
- **RCE_FRAME_RATE**
- **RCE_H26X_DEPENDENCY_ENFORCEMENT**
- **RCE_HOLEPUNCH_KEEPALIVE**
- **RCE_NO_FLAGS**
- **RCE_NO_H26X_PREPEND_SC**
- **RCE_PACE_FRAGMENT_SENDING**
- **RCE_RECEIVE_ONLY**
- **RCE_RTCP**
- **RCE_RTCP_MUX**
- **RCE_SEND_ONLY**
- **RCE_SRTP**
- **RCE_SRTP_AUTHENTICATE_RTP**
- **RCE_SRTP_KEYSIZE_192**
- **RCE_SRTP_KEYSIZE_256**
- **RCE_SRTP_KMNGMNT_USER**
- **RCE_SRTP_KMNGMNT_ZRTP**
- **RCE_SRTP_NULL_CIPHER**
- **RCE_SRTP_REPLAY_PROTECTION**
- **RCE_SYSTEM_CALL_CLUSTERING**
- **RCE_ZRTP_DIFFIE_HELLMAN_MODE**
- **RCE_ZRTP_MULTISTREAM_MODE**

### RTP Formats and Status Codes
- **RTP_FORMAT_H264**, **RTP_FORMAT_H265**, **RTP_FORMAT_H266**
- **RTP_FORMAT_OPUS**, **RTP_FORMAT_PCMA**, **RTP_FORMAT_PCMU**
- **RTP_OK**, **RTP_GENERIC_ERROR**, **RTP_MEMORY_ERROR**, **RTP_TIMEOUT**
```

--------------------------------

### Include uvgRTP Library

Source: https://ultravideo.github.io/uvgRTP/html/index.html

Include all necessary uvgRTP header files with a single line.

```cpp
#include <uvgrtp/lib.hh>
```

--------------------------------

### Create uvgRTP Session (Dual Address)

Source: https://ultravideo.github.io/uvgRTP/html/index.html

Create a uvgRTP session object, specifying both the remote and local IP addresses.

```cpp
uvgrtp::session *sess = ctx.create_session("10.10.10.2", "10.10.10.3");
```

--------------------------------

### Install RTCP SDES Hook (std::function)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a std::function hook for receiving RTCP SDES (Source Description) packets. This allows custom handling of SDES information.

```cpp
rtp_error_t install_sdes_hook(std::function< void(std::unique_ptr< uvgrtp::frame::rtcp_sdes_packet >)> sdes_handler)
```

--------------------------------

### uvgrtp::context Methods

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1context-members.html

API documentation for the core methods available in the uvgrtp::context class.

```APIDOC
## POST create_session

### Description
Creates a new RTP/SRTP session using the provided address information.

### Method
POST

### Parameters
#### Request Body
- **addresses** (std::pair<std::string, std::string>) - Required - A pair of strings representing local and remote addresses.
- **address** (std::string) - Required - A single string representing the remote address.

## POST destroy_session

### Description
Destroys an existing RTP/SRTP session.

### Method
POST

### Parameters
#### Request Body
- **session** (uvgrtp::session*) - Required - Pointer to the session object to be destroyed.

## GET crypto_enabled

### Description
Checks if cryptographic features are enabled for the context.

### Method
GET

### Response
- **return** (bool) - Returns true if crypto is enabled, false otherwise.
```

--------------------------------

### Media Stream Initialization

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Methods for initializing a media stream, with options for traditional RTP or secure SRTP with automatic ZRTP negotiation.

```APIDOC
## Media Stream Initialization

### Description
Initializes a media stream for RTP or SRTP communication.

### Methods

#### `rtp_error_t init(std::shared_ptr<uvgrtp::zrtp> zrtp)`
Initializes a traditional RTP session. Allocates and initializes connection, reader, and writer objects.

**Return Values:**
- `RTP_OK`: Success.
- `RTP_MEMORY_ERROR`: Allocation failed.
- Other error codes defined in {conn,writer,reader}.hh.

#### `rtp_error_t init_auto_zrtp(std::shared_ptr<uvgrtp::zrtp> zrtp)`
Initializes a secure RTP session with automatic ZRTP negotiation. Allocates and initializes connection, reader, and writer objects.

**Return Values:**
- `RTP_OK`: Success.
- `RTP_MEMORY_ERROR`: Allocation failed.
- TODO: Document all error codes.
- Other error codes defined in {conn,writer,reader,srtp}.hh.
```

--------------------------------

### Include uvgRTP library headers

Source: https://ultravideo.github.io/uvgRTP/html/lib_8hh_source.html

This header file acts as a convenience wrapper to include all core uvgRTP components, including media streams, sessions, and utility functions.

```cpp
#pragma once

/* Including this header will include all the necessary headers for using uvgRTP, but
 * you can also include the headers individually instead of this header. */


#include "media_stream.hh" // media streamer class
#include "session.hh" // session class
#include "context.hh" // context class
#include "rtcp.hh" // RTCP

#include "clock.hh" // time related functions
#include "frame.hh" // frame related functions
#include "util.hh" // types
#include "version.hh" // version
```

--------------------------------

### Install RTCP Sender Report Hook (std::function)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a std::function hook for receiving RTCP Sender Reports. This overload provides more flexibility for handling incoming Sender Reports.

```cpp
rtp_error_t install_sender_hook(std::function< void(std::unique_ptr< uvgrtp::frame::rtcp_sender_report >)> sr_handler)
```

--------------------------------

### uvgrtp Classes Overview

Source: https://ultravideo.github.io/uvgRTP/html/annotated.html

Overview of the main classes available in the uvgrtp library, with brief descriptions and references to relevant RFCs where applicable.

```APIDOC
## uvgrtp Library Classes

### Description
This section lists the primary classes within the uvgrtp library, detailing their purpose and associated RFC specifications.

### Classes

#### `uvgrtp`
Provides CNAME isolation and can be used to create uvgrtp::session objects.

#### `frame`
Represents a frame of media data.

#### `Crtcp_app_packet`
Represents an RTCP Application Defined Packet. See RFC 3550 section 6.7.

#### `Crtcp_fb_fci`
Represents RTCP Feedback Control Information. See RFC 4585 section 6.1.

#### `Crtcp_fb_packet`
Represents an RTCP Feedback Message. See RFC 4585 section 6.1.

#### `Crtcp_fir`
Represents a Full Intra Request. See RFC 5104 section 4.3.1.

#### `Crtcp_header`
Represents the header for all RTCP packets defined in RFC 3550 section 6.

#### `Crtcp_receiver_report`
Represents an RTCP Receiver Report. See RFC 3550 section 6.4.2.

#### `Crtcp_report_block`
Represents an RTCP Report Block. See RFC 3550 section 6.4.1.

#### `Crtcp_rpsi`
Represents a Reference Picture Selection Indication. See RFC 4585 section 6.3.3.

#### `Crtcp_sdes_chunk`
Represents an SDES chunk. See RFC 3550 section 6.5.

#### `Crtcp_sdes_item`
Represents an SDES item. See RFC 3550 section 6.5.

#### `Crtcp_sdes_packet`
Represents an SDES packet. See RFC 3550 section 6.5.

#### `Crtcp_sender_info`
Represents RTCP Sender Information. See RFC 3550 section 6.4.1.

#### `Crtcp_sender_report`
Represents an RTCP Sender Report. See RFC 3550 section 6.4.1.

#### `Crtcp_sli`
Represents a Slice Loss Indication. See RFC 4585 section 6.3.2.

#### `Crtp_frame`
Represents an RTP frame. See RFC 3550 section 5.

#### `Ccontext`
Provides CNAME isolation and can be used to create uvgrtp::session objects.

#### `Cmedia_stream`
The media_stream is an entity which represents one RTP stream.

#### `Crtcp`
RTCP instance handles all incoming and outgoing RTCP traffic, including report generation.

#### `Csession`
Provides ZRTP synchronization and can be used to create uvgrtp::media_stream objects.
```

--------------------------------

### Install RTCP APP Packet Send Hook

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Allows installation of a custom function to handle sending of APP packets. This hook is invoked when an APP packet needs to be sent, providing an opportunity to customize its content.

```APIDOC
## uvgrtp::rtcp::install_send_app_hook

### Description
Install hook for one type of APP packets.

### Method
Not applicable (function signature)

### Endpoint
Not applicable (function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
rtp_error_t install_send_app_hook(std::string app_name, std::function< std::unique_ptr< uint8_t[]>(uint8_t &subtype, uint32_t &payload_len)> app_sending_func)
```

### Response
#### Success Response (200)
Not applicable (function return type)

#### Response Example
```cpp
rtp_error_t
```
```

--------------------------------

### Install RTCP Receiver Report Hook (std::function)

Source: https://ultravideo.github.io/uvgRTP/html/rtcp_8hh_source.html

Installs a std::function hook for receiving RTCP Receiver Reports. This overload accepts a function object, providing more flexibility than a raw function pointer.

```cpp
rtp_error_t install_receiver_hook(std::function< void(std::unique_ptr< uvgrtp::frame::rtcp_receiver_report >)> rr_handler)
```

--------------------------------

### uvgrtp::media_stream::configure_ctx

Source: https://ultravideo.github.io/uvgRTP/html/media__stream_8hh_source.html

Configures the media stream with specified flags and values.

```APIDOC
## uvgrtp::media_stream::configure_ctx

### Description
Configure the media stream, see RTP_CTX_CONFIGURATION_FLAGS for more details.

### Method
rtp_error_t configure_ctx(int rcc_flag, ssize_t value)

### Endpoint
N/A (Method within a class)

### Parameters
#### Request Body
- **rcc_flag** (int) - The configuration flag to set.
- **value** (ssize_t) - The value associated with the configuration flag.

### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### install_receive_hook

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1media__stream.html

Registers an asynchronous callback function for receiving frames.

```APIDOC
## install_receive_hook

### Description
Asynchronous way of getting frames. uvgRTP will notify the application when a frame has been received.

### Parameters
#### Request Body
- **arg** (void*) - Optional - Argument passed to the hook.
- **hook** (function pointer) - Required - Function pointer to the receive hook.

### Response
#### Success Response (200)
- **RTP_OK** (rtp_error_t) - On success.

#### Error Response
- **RTP_INVALID_VALUE** (rtp_error_t) - If hook is nullptr.
```

--------------------------------

### uvgrtp::context::create_session

Source: https://ultravideo.github.io/uvgRTP/html/classuvgrtp_1_1context.html

API for creating new RTP sessions.

```APIDOC
## uvgrtp::context::create_session (1/2)

### Description
Create a new RTP session between two IP addresses.

### Method
POST (conceptual)

### Endpoint
N/A

### Parameters
#### Request Body
- **addresses** (std::pair<std::string, std::string>) - Required - Local and remote IP address for the session as a pair.

### Request Example
```json
{
  "addresses": {"local": "192.168.1.100", "remote": "192.168.1.1"}
}
```

### Response
#### Success Response (200)
- **session** (uvgrtp::session*) - Pointer to the newly created RTP session object.

#### Response Example
```json
{
  "session": "0x7ffc8c4d8a00"
}
```

## uvgrtp::context::create_session (2/2)

### Description
Create a new RTP session.

### Method
POST (conceptual)

### Endpoint
N/A

### Parameters
#### Request Body
- **address** (std::string) - Required - IP address of the remote participant.

### Request Example
```json
{
  "address": "192.168.1.1"
}
```

### Response
#### Success Response (200)
- **session** (uvgrtp::session*) - Pointer to the newly created RTP session object.

#### Response Example
```json
{
  "session": "0x7ffc8c4d8a00"
}
```

### Error Handling
- **nullptr**: If the provided address is empty or memory allocation fails.
```
Tokens:
Raw