wt/mongoose
1
0 Fork 0
mirror of https://github.com/cesanta/mongoose.git synced 2026-10-22 11:36:21 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
a8b4ae95db3c2db85e5ad9db3fefaeebb5f7b43e
mongoose/tutorials/tcp/rtsp-video-stream/rtsp.c
T
cpq 63318a7e48 Add RTSP example
2026-04-03 09:51:35 +01:00

2090 lines
67 KiB
C
Raw Blame History

#include "rtsp.h"
#define RTSP_TRACK_PREFIX "/trackID="
#define RTSP_VIDEO_TRACK 0U
#define RTSP_AUDIO_TRACK 1U
#define RTSP_TRACK_COUNT 2U
#define RTSP_VIDEO_RTP_PT 96U
#define RTSP_AUDIO_RTP_PT 97U
#define RTSP_VIDEO_RTP_CLOCK 90000U
#define RTSP_RTP_PAYLOAD_MAX 1400U
#define RTSP_MAX_NALS 16U
#define H264_MAX_AU (4U * 1024U * 1024U)
#define H264_MAX_RBSP (4U * 1024U * 1024U)
struct rtsp_request {
struct mg_str method;
struct mg_str uri;
struct mg_str cseq;
struct mg_str transport;
struct mg_str session;
size_t msg_len;
};
struct rtsp_nal {
const uint8_t *ptr;
size_t len;
};
struct rtsp_server {
struct mg_rtsp_opts opts;
char *path;
bool has_audio;
char sdp[1024];
};
struct rtsp_track_conn {
bool setup_done;
bool ended;
uint16_t rtp_seq;
uint32_t ssrc;
unsigned rtp_channel;
unsigned rtcp_channel;
uint64_t deadline_ms;
};
struct rtsp_conn {
struct rtsp_server *srv;
bool playing;
struct rtsp_track_conn tracks[RTSP_TRACK_COUNT];
char session_id[24];
};
struct h264_bw {
uint8_t *buf;
size_t len;
size_t cap;
unsigned bitpos;
bool oom;
};
struct h264_color {
uint8_t y;
uint8_t cb;
uint8_t cr;
};
struct h264_testsrc_state {
bool inited;
unsigned width;
unsigned height;
unsigned fps;
unsigned mb_width;
unsigned mb_height;
unsigned box_w;
unsigned box_h;
int box_x;
int box_y;
int dx;
int dy;
uint64_t frame_no;
uint8_t sps[64];
uint8_t pps[32];
size_t sps_len;
size_t pps_len;
uint8_t rbsp[H264_MAX_RBSP];
uint8_t au[H264_MAX_AU];
};
#define MP4_TAG(a, b, c, d) \
(((uint32_t) (uint8_t) (a) << 24) | ((uint32_t) (uint8_t) (b) << 16) | \
((uint32_t) (uint8_t) (c) << 8) | (uint32_t) (uint8_t) (d))
struct mp4_box {
const uint8_t *buf;
size_t len;
uint32_t type;
};
struct rtsp_mp4_stsc {
uint32_t first_chunk;
uint32_t samples_per_chunk;
};
struct rtsp_mp4_sample {
uint64_t offset;
uint32_t size;
uint64_t ts;
uint64_t pts_us;
bool keyframe;
};
struct rtsp_mp4_state {
struct rtsp_mp4_state *next;
char *path;
struct mg_str file;
struct rtsp_mp4_sample *samples;
size_t sample_count;
size_t start_index;
size_t sample_index;
uint32_t width;
uint32_t height;
unsigned fps;
uint32_t timescale;
uint8_t nal_len_size;
uint8_t *param_sets;
size_t param_sets_len;
uint8_t *sps;
size_t sps_len;
uint8_t *pps;
size_t pps_len;
uint8_t *au;
size_t au_cap;
struct rtsp_mp4_sample *audio_samples;
size_t audio_sample_count;
size_t audio_sample_index;
uint32_t audio_timescale;
unsigned audio_rate;
unsigned audio_channels;
uint8_t *audio_config;
size_t audio_config_len;
};
static struct rtsp_mp4_state *s_rtsp_mp4_states;
static int rtsp_tolower(int ch) {
return ch >= 'A' && ch <= 'Z' ? ch + ('a' - 'A') : ch;
}
static bool rtsp_memeq(const void *ptr1, const void *ptr2, size_t len) {
return len == 0 || memcmp(ptr1, ptr2, len) == 0;
}
static bool rtsp_caseeq(struct mg_str s, const char *lit) {
size_t i, len = strlen(lit);
if (s.len != len) return false;
for (i = 0; i < len; i++) {
if (rtsp_tolower((unsigned char) s.buf[i]) != rtsp_tolower((unsigned char) lit[i])) {
return false;
}
}
return true;
}
static bool rtsp_casencontains(struct mg_str s, const char *lit) {
size_t i, j, slen = s.len, llen = strlen(lit);
if (llen == 0 || llen > slen) return false;
for (i = 0; i + llen <= slen; i++) {
for (j = 0; j < llen; j++) {
if (rtsp_tolower((unsigned char) s.buf[i + j]) !=
rtsp_tolower((unsigned char) lit[j])) {
break;
}
}
if (j == llen) return true;
}
return false;
}
static struct mg_str rtsp_trim(struct mg_str s) {
while (s.len > 0 &&
(s.buf[0] == ' ' || s.buf[0] == '\t' || s.buf[0] == '\r' ||
s.buf[0] == '\n')) {
s.buf++;
s.len--;
}
while (s.len > 0 &&
(s.buf[s.len - 1] == ' ' || s.buf[s.len - 1] == '\t' ||
s.buf[s.len - 1] == '\r' || s.buf[s.len - 1] == '\n')) {
s.len--;
}
return s;
}
static bool rtsp_parse_u32(struct mg_str s, uint32_t *value) {
size_t i;
uint32_t n = 0;
s = rtsp_trim(s);
if (s.len == 0) return false;
for (i = 0; i < s.len; i++) {
unsigned ch = (unsigned char) s.buf[i];
if (ch < '0' || ch > '9') return false;
n = n * 10U + (uint32_t) (ch - '0');
}
*value = n;
return true;
}
static char *rtsp_strdup(const char *s) {
size_t len = strlen(s);
char *copy = (char *) mg_calloc(len + 1U, 1U);
if (copy != NULL) memcpy(copy, s, len);
return copy;
}
static struct mg_str rtsp_uri_path(struct mg_str uri) {
const char *p = uri.buf, *end = uri.buf + uri.len, *scheme = NULL;
size_t i;
for (i = 0; i + 2 < uri.len; i++) {
if (uri.buf[i] == ':' && uri.buf[i + 1] == '/' && uri.buf[i + 2] == '/') {
scheme = uri.buf + i;
break;
}
}
if (scheme != NULL) {
p = scheme + 3;
while (p < end && *p != '/') p++;
if (p >= end) return mg_str("/");
}
if (p < end && *p != '/') {
while (p < end && *p != '/') p++;
if (p >= end) return mg_str("/");
}
if (p >= end) return mg_str("/");
end = p;
while (end < uri.buf + uri.len && *end != '?') end++;
return mg_str_n(p, (size_t) (end - p));
}
static bool rtsp_path_eq(struct mg_str uri, const char *path) {
struct mg_str upath = rtsp_uri_path(uri);
size_t path_len = strlen(path);
return upath.len == path_len && rtsp_memeq(upath.buf, path, path_len);
}
static int rtsp_track_path_eq(struct mg_str uri, const char *path) {
struct mg_str upath = rtsp_uri_path(uri);
struct mg_str id;
uint32_t track_id;
size_t path_len = strlen(path), prefix_len = strlen(RTSP_TRACK_PREFIX);
if (upath.len <= path_len + prefix_len) return -1;
if (!rtsp_memeq(upath.buf, path, path_len) ||
!rtsp_memeq(upath.buf + path_len, RTSP_TRACK_PREFIX, prefix_len)) {
return -1;
}
id = mg_str_n(upath.buf + path_len + prefix_len,
upath.len - path_len - prefix_len);
if (!rtsp_parse_u32(id, &track_id)) return -1;
return (int) track_id;
}
static bool rtsp_next_line(const char **cursor, const char *end,
struct mg_str *line) {
const char *p = *cursor;
if (p >= end) return false;
while (p < end && *p != '\n') p++;
if (p >= end) return false;
line->buf = (char *) *cursor;
line->len = (size_t) (p - *cursor);
if (line->len > 0 && line->buf[line->len - 1] == '\r') line->len--;
*cursor = p + 1;
return true;
}
static int rtsp_parse_request(const char *buf, size_t len,
struct rtsp_request *req) {
const char *cursor = buf, *end;
struct mg_str line;
int header_len = mg_http_get_request_len((const unsigned char *) buf, len);
uint32_t content_length = 0;
memset(req, 0, sizeof(*req));
if (header_len <= 0) return header_len;
if ((size_t) header_len > len) return 0;
end = buf + header_len;
if (!rtsp_next_line(&cursor, end, &line)) return -1;
{
const char *p = line.buf, *line_end = line.buf + line.len;
while (p < line_end && *p == ' ') p++;
req->method.buf = (char *) p;
while (p < line_end && *p != ' ') p++;
req->method.len = (size_t) (p - req->method.buf);
while (p < line_end && *p == ' ') p++;
req->uri.buf = (char *) p;
while (p < line_end && *p != ' ') p++;
req->uri.len = (size_t) (p - req->uri.buf);
while (p < line_end && *p == ' ') p++;
if (!rtsp_caseeq(mg_str_n(p, (size_t) (line_end - p)), "RTSP/1.0")) return -1;
if (req->method.len == 0 || req->uri.len == 0) return -1;
}
while (rtsp_next_line(&cursor, end, &line)) {
struct mg_str name, value;
char *colon;
if (line.len == 0) break;
colon = (char *) memchr(line.buf, ':', line.len);
if (colon == NULL) return -1;
name = mg_str_n(line.buf, (size_t) (colon - line.buf));
value = rtsp_trim(mg_str_n(colon + 1, line.len - (size_t) (colon - line.buf) - 1));
if (rtsp_caseeq(name, "CSeq")) {
req->cseq = value;
} else if (rtsp_caseeq(name, "Transport")) {
req->transport = value;
} else if (rtsp_caseeq(name, "Session")) {
req->session = value;
} else if (rtsp_caseeq(name, "Content-Length")) {
if (!rtsp_parse_u32(value, &content_length)) return -1;
}
}
req->msg_len = (size_t) header_len + (size_t) content_length;
if (req->msg_len > len) return 0;
return req->cseq.len > 0 ? 1 : -1;
}
static void rtsp_send_response(struct mg_connection *c,
const struct rtsp_request *req, int status,
const char *reason, const char *headers,
const void *body, size_t body_len) {
const char *extra = headers == NULL ? "" : headers;
mg_printf(c,
"RTSP/1.0 %d %s\r\n"
"CSeq: %.*s\r\n"
"Server: Mongoose RTSP\r\n"
"%s"
"Content-Length: %lu\r\n"
"\r\n",
status, reason, (int) req->cseq.len, req->cseq.buf, extra,
(unsigned long) body_len);
if (body_len > 0) mg_send(c, body, body_len);
}
static void rtsp_send_status(struct mg_connection *c,
const struct rtsp_request *req, int status,
const char *reason, const char *headers) {
rtsp_send_response(c, req, status, reason, headers, NULL, 0);
}
static size_t h264_start_code_len(const uint8_t *buf, size_t len, size_t off) {
if (off + 3 <= len && buf[off] == 0 && buf[off + 1] == 0 &&
buf[off + 2] == 1) {
return 3;
}
if (off + 4 <= len && buf[off] == 0 && buf[off + 1] == 0 &&
buf[off + 2] == 0 && buf[off + 3] == 1) {
return 4;
}
return 0;
}
static size_t h264_split_annexb(const uint8_t *buf, size_t len,
struct rtsp_nal *nals, size_t max_nals) {
size_t i = 0, count = 0;
while (i < len) {
size_t sc = h264_start_code_len(buf, len, i);
if (sc == 0) {
i++;
continue;
}
i += sc;
if (i >= len) break;
{
size_t start = i;
while (i < len && h264_start_code_len(buf, len, i) == 0) i++;
if (start < i && count < max_nals) {
nals[count].ptr = buf + start;
nals[count].len = i - start;
count++;
}
}
}
if (count == 0 && len > 0 && max_nals > 0) {
nals[0].ptr = buf;
nals[0].len = len;
count = 1;
}
return count;
}
static void rtsp_parse_interleaved_channels(struct mg_str transport,
unsigned *rtp_channel,
unsigned *rtcp_channel) {
size_t i;
*rtp_channel = 0;
*rtcp_channel = 1;
for (i = 0; i + 11 < transport.len; i++) {
if (rtsp_tolower((unsigned char) transport.buf[i]) == 'i' &&
rtsp_tolower((unsigned char) transport.buf[i + 1]) == 'n' &&
rtsp_tolower((unsigned char) transport.buf[i + 2]) == 't' &&
rtsp_tolower((unsigned char) transport.buf[i + 3]) == 'e' &&
rtsp_tolower((unsigned char) transport.buf[i + 4]) == 'r' &&
rtsp_tolower((unsigned char) transport.buf[i + 5]) == 'l' &&
rtsp_tolower((unsigned char) transport.buf[i + 6]) == 'e' &&
rtsp_tolower((unsigned char) transport.buf[i + 7]) == 'a' &&
rtsp_tolower((unsigned char) transport.buf[i + 8]) == 'v' &&
rtsp_tolower((unsigned char) transport.buf[i + 9]) == 'e' &&
rtsp_tolower((unsigned char) transport.buf[i + 10]) == 'd' &&
transport.buf[i + 11] == '=') {
uint32_t a = 0, b = 1;
size_t j = i + 12;
struct mg_str s1, s2;
s1.buf = &transport.buf[j];
s1.len = 0;
while (j < transport.len && transport.buf[j] >= '0' && transport.buf[j] <= '9') {
s1.len++;
j++;
}
if (j >= transport.len || transport.buf[j] != '-') return;
j++;
s2.buf = &transport.buf[j];
s2.len = 0;
while (j < transport.len && transport.buf[j] >= '0' && transport.buf[j] <= '9') {
s2.len++;
j++;
}
if (rtsp_parse_u32(s1, &a) && rtsp_parse_u32(s2, &b)) {
*rtp_channel = (unsigned) a;
*rtcp_channel = (unsigned) b;
}
return;
}
}
}
static bool rtsp_session_matches(const struct rtsp_conn *rc, struct mg_str session) {
size_t i;
session = rtsp_trim(session);
for (i = 0; i < session.len; i++) {
if (session.buf[i] == ';') {
session.len = i;
break;
}
}
return session.len == strlen(rc->session_id) &&
rtsp_memeq(session.buf, rc->session_id, session.len);
}
static uint16_t rtsp_mp4_u16(const uint8_t *p) {
return (uint16_t) (((uint16_t) p[0] << 8) | p[1]);
}
static uint32_t rtsp_mp4_u32(const uint8_t *p) {
return ((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16) |
((uint32_t) p[2] << 8) | p[3];
}
static uint64_t rtsp_mp4_u64(const uint8_t *p) {
return ((uint64_t) rtsp_mp4_u32(p) << 32) | rtsp_mp4_u32(p + 4);
}
static uint64_t rtsp_scale_us(uint64_t value, uint32_t timescale) {
if (timescale == 0) return 0;
return (value / timescale) * 1000000ULL +
(((value % timescale) * 1000000ULL) + timescale / 2U) / timescale;
}
static bool rtsp_mp4_next_box(const uint8_t *buf, size_t len, size_t *ofs,
struct mp4_box *box) {
uint64_t start = *ofs, size, head = 8;
if (start + 8U > len) return false;
size = rtsp_mp4_u32(buf + start);
box->type = rtsp_mp4_u32(buf + start + 4U);
if (size == 1U) {
if (start + 16U > len) return false;
size = rtsp_mp4_u64(buf + start + 8U);
head = 16;
} else if (size == 0) {
size = len - start;
}
if (size < head || start + size > len) return false;
box->buf = buf + start + head;
box->len = (size_t) (size - head);
*ofs = (size_t) (start + size);
return true;
}
static bool rtsp_mp4_find_child(const uint8_t *buf, size_t len, uint32_t type,
struct mp4_box *box) {
size_t ofs = 0;
struct mp4_box tmp;
while (rtsp_mp4_next_box(buf, len, &ofs, &tmp)) {
if (tmp.type == type) {
*box = tmp;
return true;
}
}
return false;
}
static uint32_t rtsp_mp4_track_type(const struct mp4_box *mdia) {
struct mp4_box hdlr;
return rtsp_mp4_find_child(mdia->buf, mdia->len, MP4_TAG('h', 'd', 'l', 'r'),
&hdlr) &&
hdlr.len >= 12U
? rtsp_mp4_u32(hdlr.buf + 8U)
: 0;
}
static void rtsp_mp4_free_state(struct rtsp_mp4_state *st) {
if (st == NULL) return;
mg_free(st->path);
mg_free(st->file.buf);
mg_free(st->samples);
mg_free(st->audio_samples);
mg_free(st->param_sets);
mg_free(st->sps);
mg_free(st->pps);
mg_free(st->au);
mg_free(st->audio_config);
mg_free(st);
}
static bool rtsp_mp4_copy_blob(uint8_t **dst, size_t *dst_len, const uint8_t *src,
size_t len) {
uint8_t *copy = (uint8_t *) mg_calloc(len == 0 ? 1U : len, 1U);
if (copy == NULL) return false;
if (len > 0) memcpy(copy, src, len);
mg_free(*dst);
*dst = copy;
*dst_len = len;
return true;
}
static bool rtsp_mp4_parse_avcc(struct rtsp_mp4_state *st, const uint8_t *buf,
size_t len) {
size_t i, pos, out_len = 0, out_cap;
uint8_t num_pps;
uint8_t *out;
if (len < 7U) return false;
st->nal_len_size = (uint8_t) ((buf[4] & 3U) + 1U);
out_cap = len * 2U + 32U;
out = (uint8_t *) mg_calloc(out_cap, 1U);
if (out == NULL) return false;
pos = 6U;
for (i = 0; i < (size_t) (buf[5] & 0x1fU); i++) {
uint16_t n;
if (pos + 2U > len) goto fail;
n = rtsp_mp4_u16(buf + pos);
pos += 2U;
if (n == 0 || pos + n > len || out_len + 4U + n > out_cap) goto fail;
if (st->sps == NULL && !rtsp_mp4_copy_blob(&st->sps, &st->sps_len, buf + pos, n))
goto fail;
memcpy(out + out_len, "\0\0\0\1", 4U);
out_len += 4U;
memcpy(out + out_len, buf + pos, n);
out_len += n;
pos += n;
}
if (pos + 1U > len) goto fail;
num_pps = buf[pos++];
for (i = 0; i < num_pps; i++) {
uint16_t n;
if (pos + 2U > len) goto fail;
n = rtsp_mp4_u16(buf + pos);
pos += 2U;
if (n == 0 || pos + n > len || out_len + 4U + n > out_cap) goto fail;
if (st->pps == NULL && !rtsp_mp4_copy_blob(&st->pps, &st->pps_len, buf + pos, n))
goto fail;
memcpy(out + out_len, "\0\0\0\1", 4U);
out_len += 4U;
memcpy(out + out_len, buf + pos, n);
out_len += n;
pos += n;
}
if (st->sps == NULL || st->pps == NULL || out_len == 0) goto fail;
st->param_sets = out;
st->param_sets_len = out_len;
return true;
fail:
mg_free(out);
return false;
}
static bool rtsp_mp4_next_desc(const uint8_t *buf, size_t len, size_t *ofs,
uint8_t *tag, const uint8_t **body,
size_t *body_len) {
size_t pos = *ofs, i;
uint32_t size = 0;
if (pos >= len) return false;
*tag = buf[pos++];
for (i = 0; i < 4; i++) {
uint8_t b;
if (pos >= len) return false;
b = buf[pos++];
size = (size << 7) | (uint32_t) (b & 0x7fU);
if ((b & 0x80U) == 0) break;
}
if (pos + size > len) return false;
*body = buf + pos;
*body_len = size;
*ofs = pos + size;
return true;
}
static bool rtsp_mp4_parse_esds(struct rtsp_mp4_state *st, const uint8_t *buf,
size_t len) {
const uint8_t *body, *config;
size_t body_len, config_len, ofs;
uint8_t tag;
if (len < 4U) return false;
ofs = 0;
if (!rtsp_mp4_next_desc(buf + 4U, len - 4U, &ofs, &tag, &body, &body_len) ||
tag != 0x03U || body_len < 3U) {
return false;
}
ofs = 3U;
if ((body[2] & 0x80U) != 0) ofs += 2U;
if ((body[2] & 0x40U) != 0) {
if (ofs >= body_len) return false;
ofs += 1U + body[ofs];
}
if ((body[2] & 0x20U) != 0) ofs += 2U;
if (ofs > body_len ||
!rtsp_mp4_next_desc(body, body_len, &ofs, &tag, &body, &body_len) ||
tag != 0x04U || body_len < 13U) {
return false;
}
ofs = 13U;
if (!rtsp_mp4_next_desc(body, body_len, &ofs, &tag, &config, &config_len) ||
tag != 0x05U || config_len == 0) {
return false;
}
while (config_len > 0 && config[config_len - 1] == 0) config_len--;
return config_len > 0 &&
rtsp_mp4_copy_blob(&st->audio_config, &st->audio_config_len, config,
config_len);
}
static bool rtsp_mp4_parse_stsd(struct rtsp_mp4_state *st,
const struct mp4_box *stsd) {
size_t ofs = 8U;
struct mp4_box entry, avcc;
if (stsd->len < 8U || rtsp_mp4_u32(stsd->buf + 4U) == 0) return false;
while (rtsp_mp4_next_box(stsd->buf, stsd->len, &ofs, &entry)) {
if (entry.type != MP4_TAG('a', 'v', 'c', '1') &&
entry.type != MP4_TAG('a', 'v', 'c', '3')) {
continue;
}
if (entry.len < 78U) return false;
st->width = rtsp_mp4_u16(entry.buf + 24U);
st->height = rtsp_mp4_u16(entry.buf + 26U);
if (!rtsp_mp4_find_child(entry.buf + 78U, entry.len - 78U,
MP4_TAG('a', 'v', 'c', 'C'), &avcc)) {
return false;
}
return rtsp_mp4_parse_avcc(st, avcc.buf, avcc.len);
}
return false;
}
static bool rtsp_mp4_parse_audio_stsd(struct rtsp_mp4_state *st,
const struct mp4_box *stsd) {
size_t ofs = 8U;
struct mp4_box entry, esds;
if (stsd->len < 8U || rtsp_mp4_u32(stsd->buf + 4U) == 0) return false;
while (rtsp_mp4_next_box(stsd->buf, stsd->len, &ofs, &entry)) {
uint16_t version;
size_t child_ofs = 28U;
if (entry.type != MP4_TAG('m', 'p', '4', 'a')) continue;
if (entry.len < 28U) return false;
version = rtsp_mp4_u16(entry.buf + 8U);
if (version == 1U) {
child_ofs = 44U;
} else if (version == 2U) {
child_ofs = 64U;
}
if (entry.len < child_ofs) return false;
st->audio_channels = rtsp_mp4_u16(entry.buf + 16U);
st->audio_rate = rtsp_mp4_u32(entry.buf + 24U) >> 16;
if (st->audio_channels == 0 || st->audio_rate == 0) return false;
if (!rtsp_mp4_find_child(entry.buf + child_ofs, entry.len - child_ofs,
MP4_TAG('e', 's', 'd', 's'), &esds)) {
return false;
}
return rtsp_mp4_parse_esds(st, esds.buf, esds.len);
}
return false;
}
static bool rtsp_mp4_parse_mdhd(struct rtsp_mp4_state *st,
const struct mp4_box *mdhd) {
if (mdhd->len < 16U) return false;
if (mdhd->buf[0] == 1) {
if (mdhd->len < 24U) return false;
st->timescale = rtsp_mp4_u32(mdhd->buf + 20U);
} else {
st->timescale = rtsp_mp4_u32(mdhd->buf + 12U);
}
return st->timescale > 0;
}
static bool rtsp_mp4_parse_audio_mdhd(struct rtsp_mp4_state *st,
const struct mp4_box *mdhd) {
if (mdhd->len < 16U) return false;
if (mdhd->buf[0] == 1) {
if (mdhd->len < 24U) return false;
st->audio_timescale = rtsp_mp4_u32(mdhd->buf + 20U);
} else {
st->audio_timescale = rtsp_mp4_u32(mdhd->buf + 12U);
}
return st->audio_timescale > 0;
}
static uint32_t *rtsp_mp4_parse_stsz(const struct mp4_box *stsz,
size_t *sample_count) {
uint32_t fixed_size, count;
uint32_t *sizes;
size_t i;
if (stsz->len < 12U) return NULL;
fixed_size = rtsp_mp4_u32(stsz->buf + 4U);
count = rtsp_mp4_u32(stsz->buf + 8U);
if (count == 0) return NULL;
if (fixed_size == 0 && stsz->len < 12U + (size_t) count * 4U) return NULL;
sizes = (uint32_t *) mg_calloc(count, sizeof(*sizes));
if (sizes == NULL) return NULL;
if (fixed_size != 0) {
for (i = 0; i < count; i++) sizes[i] = fixed_size;
} else {
for (i = 0; i < count; i++) sizes[i] = rtsp_mp4_u32(stsz->buf + 12U + i * 4U);
}
*sample_count = count;
return sizes;
}
static uint64_t *rtsp_mp4_parse_chunk_offsets(const struct mp4_box *box,
size_t *count) {
uint32_t n;
size_t i;
uint64_t *offsets;
bool is64 = box->type == MP4_TAG('c', 'o', '6', '4');
if (box->len < 8U) return NULL;
n = rtsp_mp4_u32(box->buf + 4U);
if (n == 0) return NULL;
if (is64) {
if (box->len < 8U + (size_t) n * 8U) return NULL;
} else {
if (box->len < 8U + (size_t) n * 4U) return NULL;
}
offsets = (uint64_t *) mg_calloc(n, sizeof(*offsets));
if (offsets == NULL) return NULL;
for (i = 0; i < n; i++) {
offsets[i] =
is64 ? rtsp_mp4_u64(box->buf + 8U + i * 8U)
: (uint64_t) rtsp_mp4_u32(box->buf + 8U + i * 4U);
}
*count = n;
return offsets;
}
static struct rtsp_mp4_stsc *rtsp_mp4_parse_stsc(const struct mp4_box *stsc,
size_t *count) {
uint32_t n;
size_t i;
struct rtsp_mp4_stsc *entries;
if (stsc->len < 8U) return NULL;
n = rtsp_mp4_u32(stsc->buf + 4U);
if (n == 0 || stsc->len < 8U + (size_t) n * 12U) return NULL;
entries = (struct rtsp_mp4_stsc *) mg_calloc(n, sizeof(*entries));
if (entries == NULL) return NULL;
for (i = 0; i < n; i++) {
const uint8_t *p = stsc->buf + 8U + i * 12U;
entries[i].first_chunk = rtsp_mp4_u32(p);
entries[i].samples_per_chunk = rtsp_mp4_u32(p + 4U);
}
*count = n;
return entries;
}
static int64_t *rtsp_mp4_parse_pts(const struct mp4_box *stts,
const struct mp4_box *ctts,
size_t sample_count,
uint64_t *duration_units) {
int64_t *pts;
uint64_t dts = 0;
uint32_t entry_count;
size_t i, j, idx = 0, pos;
(void) ctts;
if (stts->len < 8U) return NULL;
entry_count = rtsp_mp4_u32(stts->buf + 4U);
pts = (int64_t *) mg_calloc(sample_count, sizeof(*pts));
if (pts == NULL) return NULL;
pos = 8U;
for (i = 0; i < entry_count; i++, pos += 8U) {
uint32_t count, delta;
if (pos + 8U > stts->len) goto fail;
count = rtsp_mp4_u32(stts->buf + pos);
delta = rtsp_mp4_u32(stts->buf + pos + 4U);
for (j = 0; j < count; j++) {
if (idx >= sample_count) goto fail;
pts[idx++] = (int64_t) dts;
dts += delta;
}
}
if (idx != sample_count) goto fail;
*duration_units = dts;
return pts;
fail:
mg_free(pts);
return NULL;
}
static bool rtsp_mp4_parse_samples(struct rtsp_mp4_state *st,
const struct mp4_box *stbl) {
struct mp4_box stsz, stsc, stts, ctts, stss, chunk_box;
uint32_t *sizes = NULL;
uint64_t *chunk_offsets = NULL, duration_units = 0;
struct rtsp_mp4_stsc *stsc_entries = NULL;
int64_t *pts = NULL, min_pts;
size_t sample_count = 0, chunk_count = 0, stsc_count = 0;
size_t i, chunk = 0, sample = 0, start_index = 0, active_count;
uint64_t duration_us;
bool has_ctts, has_stss;
if (!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 's', 'z'),
&stsz) ||
!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 's', 'c'),
&stsc) ||
!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 't', 's'),
&stts)) {
return false;
}
has_ctts =
rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('c', 't', 't', 's'),
&ctts);
has_stss =
rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 's', 's'),
&stss);
if (!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 'c', 'o'),
&chunk_box) &&
!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('c', 'o', '6', '4'),
&chunk_box)) {
return false;
}
sizes = rtsp_mp4_parse_stsz(&stsz, &sample_count);
chunk_offsets = rtsp_mp4_parse_chunk_offsets(&chunk_box, &chunk_count);
stsc_entries = rtsp_mp4_parse_stsc(&stsc, &stsc_count);
pts = rtsp_mp4_parse_pts(&stts, has_ctts ? &ctts : NULL, sample_count,
&duration_units);
st->samples = (struct rtsp_mp4_sample *) mg_calloc(sample_count, sizeof(*st->samples));
if (sizes == NULL || chunk_offsets == NULL || stsc_entries == NULL || pts == NULL ||
st->samples == NULL) {
goto fail;
}
for (i = 0; i < stsc_count; i++) {
uint32_t first_chunk = stsc_entries[i].first_chunk;
uint32_t last_chunk =
i + 1U < stsc_count ? stsc_entries[i + 1U].first_chunk - 1U
: (uint32_t) chunk_count;
uint32_t chunk_no;
if (first_chunk == 0 || first_chunk > last_chunk) goto fail;
for (chunk_no = first_chunk; chunk_no <= last_chunk; chunk_no++) {
uint64_t offset;
uint32_t sample_no;
if ((size_t) chunk_no > chunk_count) goto fail;
offset = chunk_offsets[chunk_no - 1U];
for (sample_no = 0; sample_no < stsc_entries[i].samples_per_chunk; sample_no++) {
if (sample >= sample_count) goto fail;
st->samples[sample].offset = offset;
st->samples[sample].size = sizes[sample];
if (offset > st->file.len || sizes[sample] > st->file.len - (size_t) offset)
goto fail;
offset += sizes[sample];
sample++;
}
chunk++;
}
}
if (sample != sample_count || chunk != chunk_count) goto fail;
for (i = 0; i < sample_count; i++) st->samples[i].keyframe = !has_stss;
if (has_stss) {
uint32_t sync_count;
size_t pos = 8U;
if (stss.len < 8U) goto fail;
sync_count = rtsp_mp4_u32(stss.buf + 4U);
for (i = 0; i < sync_count; i++, pos += 4U) {
uint32_t sample_no;
if (pos + 4U > stss.len) goto fail;
sample_no = rtsp_mp4_u32(stss.buf + pos);
if (sample_no > 0 && sample_no <= sample_count)
st->samples[sample_no - 1U].keyframe = true;
}
}
min_pts = pts[0];
for (i = 0; i < sample_count; i++) {
if (pts[i] < min_pts) min_pts = pts[i];
}
for (i = 0; i < sample_count; i++) {
st->samples[i].ts = (uint64_t) (pts[i] - min_pts);
st->samples[i].pts_us = rtsp_scale_us(st->samples[i].ts, st->timescale);
}
while (start_index < sample_count && !st->samples[start_index].keyframe) start_index++;
if (start_index >= sample_count) start_index = 0;
st->sample_count = sample_count;
st->start_index = start_index;
st->sample_index = start_index;
duration_us =
rtsp_scale_us(duration_units, st->timescale) > st->samples[start_index].pts_us
? rtsp_scale_us(duration_units, st->timescale) -
st->samples[start_index].pts_us
: rtsp_scale_us(duration_units, st->timescale);
active_count = sample_count - start_index;
if (active_count == 0) active_count = sample_count;
if (duration_us == 0) duration_us = 1000000ULL / 30ULL;
st->fps = (unsigned) ((active_count * 1000000ULL + duration_us / 2U) / duration_us);
if (st->fps == 0) st->fps = 30U;
mg_free(sizes);
mg_free(chunk_offsets);
mg_free(stsc_entries);
mg_free(pts);
return true;
fail:
mg_free(sizes);
mg_free(chunk_offsets);
mg_free(stsc_entries);
mg_free(pts);
mg_free(st->samples);
st->samples = NULL;
return false;
}
static bool rtsp_mp4_parse_audio_samples(struct rtsp_mp4_state *st,
const struct mp4_box *stbl) {
struct mp4_box stsz, stsc, stts, ctts, chunk_box;
uint32_t *sizes = NULL;
uint64_t *chunk_offsets = NULL, duration_units = 0;
struct rtsp_mp4_stsc *stsc_entries = NULL;
int64_t *pts = NULL, min_pts;
size_t sample_count = 0, chunk_count = 0, stsc_count = 0;
size_t i, chunk = 0, sample = 0;
bool has_ctts;
if (!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 's', 'z'),
&stsz) ||
!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 's', 'c'),
&stsc) ||
!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 't', 's'),
&stts)) {
return false;
}
has_ctts =
rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('c', 't', 't', 's'),
&ctts);
if (!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('s', 't', 'c', 'o'),
&chunk_box) &&
!rtsp_mp4_find_child(stbl->buf, stbl->len, MP4_TAG('c', 'o', '6', '4'),
&chunk_box)) {
return false;
}
sizes = rtsp_mp4_parse_stsz(&stsz, &sample_count);
chunk_offsets = rtsp_mp4_parse_chunk_offsets(&chunk_box, &chunk_count);
stsc_entries = rtsp_mp4_parse_stsc(&stsc, &stsc_count);
pts = rtsp_mp4_parse_pts(&stts, has_ctts ? &ctts : NULL, sample_count,
&duration_units);
st->audio_samples =
(struct rtsp_mp4_sample *) mg_calloc(sample_count, sizeof(*st->audio_samples));
if (sizes == NULL || chunk_offsets == NULL || stsc_entries == NULL || pts == NULL ||
st->audio_samples == NULL) {
goto fail;
}
for (i = 0; i < stsc_count; i++) {
uint32_t first_chunk = stsc_entries[i].first_chunk;
uint32_t last_chunk =
i + 1U < stsc_count ? stsc_entries[i + 1U].first_chunk - 1U
: (uint32_t) chunk_count;
uint32_t chunk_no;
if (first_chunk == 0 || first_chunk > last_chunk) goto fail;
for (chunk_no = first_chunk; chunk_no <= last_chunk; chunk_no++) {
uint64_t offset;
uint32_t sample_no;
if ((size_t) chunk_no > chunk_count) goto fail;
offset = chunk_offsets[chunk_no - 1U];
for (sample_no = 0; sample_no < stsc_entries[i].samples_per_chunk; sample_no++) {
if (sample >= sample_count) goto fail;
st->audio_samples[sample].offset = offset;
st->audio_samples[sample].size = sizes[sample];
st->audio_samples[sample].keyframe = true;
if (offset > st->file.len || sizes[sample] > st->file.len - (size_t) offset) {
goto fail;
}
offset += sizes[sample];
sample++;
}
chunk++;
}
}
if (sample != sample_count || chunk != chunk_count) goto fail;
min_pts = pts[0];
for (i = 0; i < sample_count; i++) {
if (pts[i] < min_pts) min_pts = pts[i];
}
for (i = 0; i < sample_count; i++) {
st->audio_samples[i].ts = (uint64_t) (pts[i] - min_pts);
st->audio_samples[i].pts_us =
rtsp_scale_us(st->audio_samples[i].ts, st->audio_timescale);
}
st->audio_sample_count = sample_count;
st->audio_sample_index = 0;
mg_free(sizes);
mg_free(chunk_offsets);
mg_free(stsc_entries);
mg_free(pts);
return true;
fail:
mg_free(sizes);
mg_free(chunk_offsets);
mg_free(stsc_entries);
mg_free(pts);
mg_free(st->audio_samples);
st->audio_samples = NULL;
return false;
}
static bool rtsp_mp4_parse_file(struct rtsp_mp4_state *st) {
struct mp4_box root_moov, trak;
size_t ofs = 0;
if (!rtsp_mp4_find_child((const uint8_t *) st->file.buf, st->file.len,
MP4_TAG('m', 'o', 'o', 'v'), &root_moov)) {
return false;
}
while (rtsp_mp4_next_box(root_moov.buf, root_moov.len, &ofs, &trak)) {
struct mp4_box mdia, mdhd, minf, stbl, stsd;
uint32_t track_type;
if (trak.type != MP4_TAG('t', 'r', 'a', 'k')) continue;
if (!rtsp_mp4_find_child(trak.buf, trak.len, MP4_TAG('m', 'd', 'i', 'a'),
&mdia) ||
!rtsp_mp4_find_child(mdia.buf, mdia.len, MP4_TAG('m', 'd', 'h', 'd'),
&mdhd) ||
!rtsp_mp4_find_child(mdia.buf, mdia.len, MP4_TAG('m', 'i', 'n', 'f'),
&minf) ||
!rtsp_mp4_find_child(minf.buf, minf.len, MP4_TAG('s', 't', 'b', 'l'),
&stbl) ||
!rtsp_mp4_find_child(stbl.buf, stbl.len, MP4_TAG('s', 't', 's', 'd'),
&stsd)) {
continue;
}
track_type = rtsp_mp4_track_type(&mdia);
if (track_type == MP4_TAG('v', 'i', 'd', 'e') && st->samples == NULL) {
if (!rtsp_mp4_parse_mdhd(st, &mdhd) || !rtsp_mp4_parse_stsd(st, &stsd) ||
!rtsp_mp4_parse_samples(st, &stbl)) {
return false;
}
} else if (track_type == MP4_TAG('s', 'o', 'u', 'n') &&
st->audio_samples == NULL) {
if (!rtsp_mp4_parse_audio_mdhd(st, &mdhd) ||
!rtsp_mp4_parse_audio_stsd(st, &stsd) ||
!rtsp_mp4_parse_audio_samples(st, &stbl)) {
st->audio_rate = 0;
st->audio_channels = 0;
mg_free(st->audio_config);
st->audio_config = NULL;
st->audio_config_len = 0;
mg_free(st->audio_samples);
st->audio_samples = NULL;
st->audio_sample_count = 0;
st->audio_sample_index = 0;
}
}
}
return st->samples != NULL && st->sps != NULL && st->pps != NULL;
}
static struct rtsp_mp4_state *rtsp_mp4_find_state(const char *path) {
struct rtsp_mp4_state *st;
for (st = s_rtsp_mp4_states; st != NULL; st = st->next) {
if (st->path != NULL && path != NULL && strcmp(st->path, path) == 0) return st;
}
return NULL;
}
static struct rtsp_mp4_state *rtsp_mp4_get_state(const char *path) {
struct rtsp_mp4_state *st;
if (path == NULL) return NULL;
st = rtsp_mp4_find_state(path);
if (st != NULL) return st;
st = (struct rtsp_mp4_state *) mg_calloc(1, sizeof(*st));
if (st == NULL) return NULL;
st->path = rtsp_strdup(path);
if (st->path == NULL) goto fail;
st->file = mg_file_read(&mg_fs_posix, path);
if (st->file.buf == NULL || st->file.len == 0) goto fail;
if (!rtsp_mp4_parse_file(st)) goto fail;
st->next = s_rtsp_mp4_states;
s_rtsp_mp4_states = st;
return st;
fail:
rtsp_mp4_free_state(st);
return NULL;
}
static void rtsp_mp4_reset(const char *path) {
struct rtsp_mp4_state *st = rtsp_mp4_find_state(path);
if (st == NULL) return;
st->sample_index = st->start_index;
st->audio_sample_index = 0;
}
static bool rtsp_mp4_ensure_au(struct rtsp_mp4_state *st, size_t cap) {
uint8_t *buf;
if (cap <= st->au_cap) return true;
buf = (uint8_t *) mg_calloc(cap, 1U);
if (buf == NULL) return false;
mg_free(st->au);
st->au = buf;
st->au_cap = cap;
return true;
}
bool mg_rtsp_get_mp4_frame(struct mg_rtsp_frame *frame, void *fn_data) {
const char *path = (const char *) fn_data;
struct rtsp_mp4_state *st = rtsp_mp4_get_state(path);
struct rtsp_mp4_sample *sample;
const uint8_t *src;
size_t remaining, au_len = 0, prefix_len = 0;
if (frame == NULL || st == NULL || st->sample_count == 0) return false;
if (st->sample_index >= st->sample_count) return false;
sample = &st->samples[st->sample_index];
prefix_len = sample->keyframe ? st->param_sets_len : 0;
if (!rtsp_mp4_ensure_au(st, prefix_len + sample->size * 2U + 16U))
return false;
if (prefix_len > 0) {
memcpy(st->au, st->param_sets, prefix_len);
au_len = prefix_len;
}
src = (const uint8_t *) st->file.buf + sample->offset;
remaining = sample->size;
while (remaining > (size_t) st->nal_len_size) {
uint32_t nal_len = 0;
unsigned i;
for (i = 0; i < st->nal_len_size; i++) nal_len = (nal_len << 8) | src[i];
src += st->nal_len_size;
remaining -= st->nal_len_size;
if (nal_len == 0 || nal_len > remaining || au_len + 4U + nal_len > st->au_cap)
return false;
memcpy(st->au + au_len, "\0\0\0\1", 4U);
au_len += 4U;
memcpy(st->au + au_len, src, nal_len);
au_len += nal_len;
src += nal_len;
remaining -= nal_len;
}
if (au_len == 0) return false;
frame->data = st->au;
frame->len = au_len;
frame->pts_us = sample->pts_us >= st->samples[st->start_index].pts_us
? sample->pts_us - st->samples[st->start_index].pts_us
: 0;
frame->keyframe = sample->keyframe;
st->sample_index++;
return true;
}
bool mg_rtsp_get_mp4_audio(struct mg_rtsp_audio *audio, void *fn_data) {
const char *path = (const char *) fn_data;
struct rtsp_mp4_state *st = rtsp_mp4_get_state(path);
struct rtsp_mp4_sample *sample;
if (audio == NULL || st == NULL || st->audio_samples == NULL ||
st->audio_sample_count == 0 || st->audio_sample_index >= st->audio_sample_count) {
return false;
}
sample = &st->audio_samples[st->audio_sample_index++];
audio->data = (const uint8_t *) st->file.buf + sample->offset;
audio->len = sample->size;
audio->pts_us = sample->pts_us;
return true;
}
static uint64_t rtsp_mp4_track_period_ms(const struct rtsp_mp4_sample *samples,
size_t sample_count, size_t sample_index,
uint64_t fallback_ms) {
uint64_t delta_us;
if (samples == NULL || sample_count == 0 || sample_index >= sample_count) {
return fallback_ms == 0 ? 1U : fallback_ms;
}
if (sample_index + 1U < sample_count &&
samples[sample_index + 1U].pts_us > samples[sample_index].pts_us) {
delta_us = samples[sample_index + 1U].pts_us - samples[sample_index].pts_us;
} else if (sample_index > 0 &&
samples[sample_index].pts_us > samples[sample_index - 1U].pts_us) {
delta_us = samples[sample_index].pts_us - samples[sample_index - 1U].pts_us;
} else {
delta_us = (fallback_ms == 0 ? 1U : fallback_ms) * 1000ULL;
}
return (delta_us + 500ULL) / 1000ULL == 0 ? 1U : (delta_us + 500ULL) / 1000ULL;
}
static void bw_init(struct h264_bw *bw, uint8_t *buf, size_t cap) {
memset(bw, 0, sizeof(*bw));
bw->buf = buf;
bw->cap = cap;
}
static void bw_put_bit(struct h264_bw *bw, unsigned bit) {
if (bw->oom) return;
if (bw->len >= bw->cap) {
bw->oom = true;
return;
}
if (bw->bitpos == 0) bw->buf[bw->len] = 0;
if (bit) bw->buf[bw->len] |= (uint8_t) (1U << (7U - bw->bitpos));
bw->bitpos++;
if (bw->bitpos == 8) {
bw->bitpos = 0;
bw->len++;
}
}
static void bw_put_bits(struct h264_bw *bw, unsigned count, uint32_t value) {
while (count > 0) {
count--;
bw_put_bit(bw, (value >> count) & 1U);
}
}
static void bw_put_ue(struct h264_bw *bw, uint32_t value) {
uint32_t code_num = value + 1U;
unsigned leading_zero_bits = 0;
uint32_t tmp = code_num;
while ((tmp >>= 1U) != 0U) leading_zero_bits++;
{
unsigned i;
for (i = 0; i < leading_zero_bits; i++) bw_put_bit(bw, 0);
}
bw_put_bits(bw, leading_zero_bits + 1U, code_num);
}
static void bw_put_se(struct h264_bw *bw, int32_t value) {
uint32_t code_num = value <= 0 ? (uint32_t) (-value * 2) : (uint32_t) (value * 2 - 1);
bw_put_ue(bw, code_num);
}
static void bw_align_zero(struct h264_bw *bw) {
if (bw->oom) return;
if (bw->bitpos != 0) {
bw->bitpos = 0;
bw->len++;
}
}
static void bw_put_byte(struct h264_bw *bw, uint8_t byte) {
if (bw->oom) return;
bw_align_zero(bw);
if (bw->len >= bw->cap) {
bw->oom = true;
return;
}
bw->buf[bw->len++] = byte;
}
static void bw_rbsp_trailing_bits(struct h264_bw *bw) {
bw_put_bit(bw, 1U);
while (bw->bitpos != 0) bw_put_bit(bw, 0U);
}
static size_t h264_nal_from_rbsp(uint8_t nal_header, const uint8_t *rbsp,
size_t rbsp_len, uint8_t *out, size_t out_cap) {
size_t i, len = 0, zeros = 0;
if (out_cap == 0) return 0;
out[len++] = nal_header;
for (i = 0; i < rbsp_len && len < out_cap; i++) {
uint8_t byte = rbsp[i];
if (zeros >= 2 && byte <= 3) {
if (len >= out_cap) return 0;
out[len++] = 3;
zeros = 0;
}
if (len >= out_cap) return 0;
out[len++] = byte;
zeros = byte == 0 ? zeros + 1 : 0;
}
return i == rbsp_len ? len : 0;
}
static bool h264_build_sps(struct h264_testsrc_state *st) {
struct h264_bw bw;
uint8_t rbsp[32];
bw_init(&bw, rbsp, sizeof(rbsp));
bw_put_bits(&bw, 8, 66U);
bw_put_bit(&bw, 1U);
bw_put_bit(&bw, 1U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_bits(&bw, 2, 0U);
bw_put_bits(&bw, 8, 31U);
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 2U);
bw_put_bit(&bw, 0U);
bw_put_ue(&bw, st->mb_width - 1U);
bw_put_ue(&bw, st->mb_height - 1U);
bw_put_bit(&bw, 1U);
bw_put_bit(&bw, 1U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_rbsp_trailing_bits(&bw);
if (bw.oom) return false;
st->sps_len = h264_nal_from_rbsp(0x67U, rbsp, bw.len, st->sps, sizeof(st->sps));
return st->sps_len > 0;
}
static bool h264_build_pps(struct h264_testsrc_state *st) {
struct h264_bw bw;
uint8_t rbsp[16];
bw_init(&bw, rbsp, sizeof(rbsp));
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_bits(&bw, 2, 0U);
bw_put_se(&bw, 0);
bw_put_se(&bw, 0);
bw_put_se(&bw, 0);
bw_put_bit(&bw, 1U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_rbsp_trailing_bits(&bw);
if (bw.oom) return false;
st->pps_len = h264_nal_from_rbsp(0x68U, rbsp, bw.len, st->pps, sizeof(st->pps));
return st->pps_len > 0;
}
static bool h264_testsrc_init(struct h264_testsrc_state *st, unsigned width,
unsigned height, unsigned fps) {
memset(st, 0, sizeof(*st));
st->width = width == 0 ? 640U : width;
st->height = height == 0 ? 480U : height;
st->fps = fps == 0 ? 30U : fps;
st->mb_width = (st->width + 15U) / 16U;
st->mb_height = (st->height + 15U) / 16U;
st->box_w = st->mb_width / 8U;
st->box_h = st->mb_height / 8U;
if (st->box_w < 4U) st->box_w = 4U;
if (st->box_h < 4U) st->box_h = 4U;
if (st->box_w > st->mb_width) st->box_w = st->mb_width;
if (st->box_h > st->mb_height) st->box_h = st->mb_height;
st->dx = 1;
st->dy = 1;
if (!h264_build_sps(st) || !h264_build_pps(st)) return false;
st->inited = true;
return true;
}
static void h264_append_start_code(uint8_t *buf, size_t *len) {
buf[(*len)++] = 0;
buf[(*len)++] = 0;
buf[(*len)++] = 0;
buf[(*len)++] = 1;
}
static void h264_emit_pcm_macroblock(struct h264_bw *bw,
const struct h264_color *color) {
unsigned i;
bw_put_ue(bw, 25U);
bw_align_zero(bw);
for (i = 0; i < 16U * 16U; i++) bw_put_byte(bw, color->y);
for (i = 0; i < 8U * 8U; i++) bw_put_byte(bw, color->cb);
for (i = 0; i < 8U * 8U; i++) bw_put_byte(bw, color->cr);
}
static bool h264_build_access_unit(struct h264_testsrc_state *st,
struct mg_rtsp_frame *frame) {
static const struct h264_color kGreen = {145U, 54U, 34U};
static const struct h264_color kYellow = {210U, 16U, 146U};
struct h264_bw bw;
uint8_t idr[H264_MAX_AU];
size_t au_len = 0, idr_len;
unsigned mb_x, mb_y;
bw_init(&bw, st->rbsp, sizeof(st->rbsp));
bw_put_ue(&bw, 0U);
bw_put_ue(&bw, 2U);
bw_put_ue(&bw, 0U);
bw_put_bits(&bw, 4U, 0U);
bw_put_ue(&bw, 0U);
bw_put_bits(&bw, 4U, 0U);
bw_put_bit(&bw, 0U);
bw_put_bit(&bw, 0U);
bw_put_se(&bw, 0);
bw_put_ue(&bw, 1U);
for (mb_y = 0; mb_y < st->mb_height; mb_y++) {
for (mb_x = 0; mb_x < st->mb_width; mb_x++) {
bool in_box = mb_x >= (unsigned) st->box_x &&
mb_x < (unsigned) st->box_x + st->box_w &&
mb_y >= (unsigned) st->box_y &&
mb_y < (unsigned) st->box_y + st->box_h;
h264_emit_pcm_macroblock(&bw, in_box ? &kYellow : &kGreen);
}
}
bw_rbsp_trailing_bits(&bw);
if (bw.oom) return false;
idr_len = h264_nal_from_rbsp(0x65U, st->rbsp, bw.len, idr, sizeof(idr));
if (idr_len == 0) return false;
h264_append_start_code(st->au, &au_len);
memcpy(st->au + au_len, st->sps, st->sps_len);
au_len += st->sps_len;
h264_append_start_code(st->au, &au_len);
memcpy(st->au + au_len, st->pps, st->pps_len);
au_len += st->pps_len;
h264_append_start_code(st->au, &au_len);
memcpy(st->au + au_len, idr, idr_len);
au_len += idr_len;
frame->data = st->au;
frame->len = au_len;
frame->pts_us = (st->frame_no * 1000000ULL) / st->fps;
frame->keyframe = true;
st->frame_no++;
st->box_x += st->dx;
st->box_y += st->dy;
if (st->box_x < 0) {
st->box_x = 0;
st->dx = 1;
} else if ((unsigned) st->box_x + st->box_w >= st->mb_width) {
st->box_x = (int) (st->mb_width - st->box_w);
st->dx = -1;
}
if (st->box_y < 0) {
st->box_y = 0;
st->dy = 1;
} else if ((unsigned) st->box_y + st->box_h >= st->mb_height) {
st->box_y = (int) (st->mb_height - st->box_h);
st->dy = -1;
}
return true;
}
bool mg_rtsp_h264_testsrc_next_frame(struct mg_rtsp_frame *frame, unsigned width,
unsigned height, unsigned fps) {
static struct h264_testsrc_state st;
if (frame == NULL) return false;
if (!st.inited || st.width != width || st.height != height || st.fps != fps) {
if (!h264_testsrc_init(&st, width, height, fps)) return false;
}
return h264_build_access_unit(&st, frame);
}
static size_t rtsp_hex_encode(const uint8_t *buf, size_t len, char *dst,
size_t dst_len) {
static const char *hex = "0123456789ABCDEF";
size_t i, out = 0;
if (dst_len == 0) return 0;
for (i = 0; i < len && out + 2U < dst_len; i++) {
dst[out++] = hex[buf[i] >> 4];
dst[out++] = hex[buf[i] & 0x0fU];
}
dst[out] = '\0';
return out;
}
static bool rtsp_aac_lc_config_parse(const uint8_t cfg[2], unsigned *rate,
unsigned *channels) {
static const unsigned rates[] = {96000U, 88200U, 64000U, 48000U, 44100U,
32000U, 24000U, 22050U, 16000U, 12000U,
11025U, 8000U, 7350U};
static const unsigned channel_counts[] = {0U, 1U, 2U, 3U, 4U, 5U, 6U, 8U};
unsigned aot = (cfg[0] >> 3) & 0x1fU;
unsigned sfi = ((unsigned) (cfg[0] & 0x07U) << 1) | (cfg[1] >> 7);
unsigned cc = (cfg[1] >> 3) & 0x0fU;
if (rate == NULL || channels == NULL) return false;
if (aot != 2U || sfi >= sizeof(rates) / sizeof(rates[0])) return false;
if (cc == 0U || cc >= sizeof(channel_counts) / sizeof(channel_counts[0])) {
return false;
}
*rate = rates[sfi];
*channels = channel_counts[cc];
return *channels > 0;
}
static uint64_t rtsp_aac_frame_period_ms(unsigned sample_rate) {
uint64_t period_ms;
if (sample_rate == 0U) return 20U;
period_ms = (1024000ULL + sample_rate / 2U) / sample_rate;
return period_ms == 0 ? 1U : period_ms;
}
static uint32_t rtsp_audio_rtp_timestamp(unsigned sample_rate, uint64_t pts_us) {
if (sample_rate == 0U) return 0U;
return (uint32_t) ((pts_us * sample_rate + 500000ULL) / 1000000ULL);
}
static bool rtsp_build_sdp(struct rtsp_server *srv) {
char sps64[128], pps64[128], profile_level_id[7];
char audio_cfg[128];
struct mg_rtsp_frame frame;
struct rtsp_nal nals[RTSP_MAX_NALS];
const uint8_t *sps = NULL, *pps = NULL;
struct rtsp_mp4_state *st = NULL, *audio_st = NULL;
size_t i, sps_len = 0, pps_len = 0, nals_count;
unsigned fps, audio_rate = 0, audio_channels = 0;
srv->has_audio = srv->opts.audio_fn != NULL;
if (srv->has_audio &&
!rtsp_aac_lc_config_parse(srv->opts.aac_lc_config, &audio_rate,
&audio_channels)) {
return false;
}
if (srv->opts.fn == mg_rtsp_get_mp4_frame && srv->opts.fn_data != NULL) {
st = rtsp_mp4_get_state((const char *) srv->opts.fn_data);
if (st == NULL || st->sps == NULL || st->pps == NULL) return false;
if (srv->opts.width == 0) srv->opts.width = st->width;
if (srv->opts.height == 0) srv->opts.height = st->height;
if (srv->opts.fps == 0) srv->opts.fps = st->fps;
sps = st->sps;
pps = st->pps;
sps_len = st->sps_len;
pps_len = st->pps_len;
} else {
if (srv->opts.fn == NULL) return false;
if (!srv->opts.fn(&frame, srv->opts.fn_data) || frame.data == NULL ||
frame.len == 0) {
return false;
}
nals_count = h264_split_annexb((const uint8_t *) frame.data, frame.len, nals,
sizeof(nals) / sizeof(nals[0]));
for (i = 0; i < nals_count; i++) {
if (nals[i].len == 0) continue;
switch (nals[i].ptr[0] & 0x1fU) {
case 7:
sps = nals[i].ptr;
sps_len = nals[i].len;
break;
case 8:
pps = nals[i].ptr;
pps_len = nals[i].len;
break;
default:
break;
}
}
if (sps == NULL || pps == NULL || sps_len < 4) return false;
}
fps = srv->opts.fps == 0 ? 30U : srv->opts.fps;
if (srv->has_audio && srv->opts.audio_fn == mg_rtsp_get_mp4_audio &&
srv->opts.audio_fn_data != NULL) {
audio_st = rtsp_mp4_get_state((const char *) srv->opts.audio_fn_data);
if (audio_st == NULL || audio_st->audio_samples == NULL ||
audio_st->audio_sample_count == 0) {
return false;
}
}
profile_level_id[0] = '\0';
mg_snprintf(profile_level_id, sizeof(profile_level_id), "%02X%02X%02X", sps[1],
sps[2], sps[3]);
sps64[mg_base64_encode(sps, sps_len, sps64, sizeof(sps64) - 1U)] = '\0';
pps64[mg_base64_encode(pps, pps_len, pps64, sizeof(pps64) - 1U)] = '\0';
mg_snprintf(
srv->sdp, sizeof(srv->sdp),
"v=0\r\n"
"o=- 0 0 IN IP4 0.0.0.0\r\n"
"s=Mongoose RTSP Stream\r\n"
"t=0 0\r\n"
"a=control:*\r\n"
"m=video 0 RTP/AVP %u\r\n"
"c=IN IP4 0.0.0.0\r\n"
"a=rtpmap:%u H264/90000\r\n"
"a=fmtp:%u packetization-mode=1;profile-level-id=%s;"
"sprop-parameter-sets=%s,%s\r\n"
"a=framerate:%u\r\n"
"a=framesize:%u %u-%u\r\n"
"a=control:trackID=0\r\n",
RTSP_VIDEO_RTP_PT, RTSP_VIDEO_RTP_PT, RTSP_VIDEO_RTP_PT, profile_level_id,
sps64, pps64, fps, RTSP_VIDEO_RTP_PT, srv->opts.width, srv->opts.height);
if (srv->has_audio) {
rtsp_hex_encode(srv->opts.aac_lc_config, sizeof(srv->opts.aac_lc_config),
audio_cfg, sizeof(audio_cfg));
mg_snprintf(
srv->sdp + strlen(srv->sdp), sizeof(srv->sdp) - strlen(srv->sdp),
"m=audio 0 RTP/AVP %u\r\n"
"c=IN IP4 0.0.0.0\r\n"
"a=rtpmap:%u MPEG4-GENERIC/%u/%u\r\n"
"a=fmtp:%u streamtype=5;profile-level-id=1;mode=AAC-hbr;"
"sizelength=13;indexlength=3;indexdeltalength=3;config=%s\r\n"
"a=control:trackID=1\r\n",
RTSP_AUDIO_RTP_PT, RTSP_AUDIO_RTP_PT, audio_rate, audio_channels,
RTSP_AUDIO_RTP_PT, audio_cfg);
}
return true;
}
static void rtsp_send_rtp_packet(struct mg_connection *c,
struct rtsp_track_conn *tc, uint8_t pt,
bool marker, uint32_t timestamp,
const void *payload, size_t payload_len) {
uint8_t packet[4 + 12 + RTSP_RTP_PAYLOAD_MAX + 2];
uint16_t packet_len = (uint16_t) (12U + payload_len);
uint16_t net16;
uint32_t net32;
if (payload_len > sizeof(packet) - 16U) return;
packet[0] = '$';
packet[1] = (uint8_t) tc->rtp_channel;
net16 = mg_htons(packet_len);
memcpy(packet + 2, &net16, sizeof(net16));
packet[4] = 0x80U;
packet[5] = (uint8_t) ((marker ? 0x80U : 0U) | pt);
net16 = mg_htons(tc->rtp_seq++);
memcpy(packet + 6, &net16, sizeof(net16));
net32 = mg_htonl(timestamp);
memcpy(packet + 8, &net32, sizeof(net32));
net32 = mg_htonl(tc->ssrc);
memcpy(packet + 12, &net32, sizeof(net32));
memcpy(packet + 16, payload, payload_len);
mg_send(c, packet, (size_t) packet_len + 4U);
}
static void rtsp_send_h264_nal(struct mg_connection *c,
struct rtsp_track_conn *tc, const uint8_t *nal,
size_t nal_len, bool last_nal,
uint32_t timestamp) {
if (nal_len == 0) return;
if (nal_len <= RTSP_RTP_PAYLOAD_MAX) {
rtsp_send_rtp_packet(c, tc, RTSP_VIDEO_RTP_PT, last_nal, timestamp, nal,
nal_len);
} else {
size_t off = 1;
uint8_t fu[2 + RTSP_RTP_PAYLOAD_MAX];
uint8_t nal_type = nal[0] & 0x1fU;
uint8_t nri = nal[0] & 0x60U;
size_t max_chunk = RTSP_RTP_PAYLOAD_MAX - 2U;
fu[0] = (uint8_t) (nri | 28U);
while (off < nal_len) {
size_t chunk = nal_len - off;
bool first = off == 1U;
bool last = off + chunk >= nal_len;
if (chunk > max_chunk) chunk = max_chunk;
last = off + chunk >= nal_len;
fu[1] = (uint8_t) ((first ? 0x80U : 0U) | (last ? 0x40U : 0U) | nal_type);
memcpy(fu + 2, nal + off, chunk);
rtsp_send_rtp_packet(c, tc, RTSP_VIDEO_RTP_PT, last_nal && last, timestamp,
fu, chunk + 2U);
off += chunk;
}
}
}
static void rtsp_send_access_unit(struct mg_connection *c,
struct rtsp_track_conn *tc,
const struct mg_rtsp_frame *frame) {
struct rtsp_nal nals[RTSP_MAX_NALS];
size_t i, count;
uint32_t timestamp =
(uint32_t) ((frame->pts_us * RTSP_VIDEO_RTP_CLOCK) / 1000000ULL);
count = h264_split_annexb((const uint8_t *) frame->data, frame->len, nals,
sizeof(nals) / sizeof(nals[0]));
for (i = 0; i < count; i++) {
rtsp_send_h264_nal(c, tc, nals[i].ptr, nals[i].len, i + 1U == count,
timestamp);
}
}
static void rtsp_send_audio_sample(struct mg_connection *c,
struct rtsp_track_conn *tc,
const uint8_t *sample, size_t sample_len,
uint32_t timestamp) {
uint8_t payload[4 + RTSP_RTP_PAYLOAD_MAX];
if (sample == NULL || sample_len == 0 || sample_len + 4U > sizeof(payload)) return;
payload[0] = 0;
payload[1] = 16;
payload[2] = (uint8_t) (sample_len >> 5);
payload[3] = (uint8_t) ((sample_len & 0x1fU) << 3);
memcpy(payload + 4, sample, sample_len);
rtsp_send_rtp_packet(c, tc, RTSP_AUDIO_RTP_PT, true, timestamp, payload,
sample_len + 4U);
}
static void rtsp_handle_options(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[192];
(void) rc;
mg_snprintf(headers, sizeof(headers),
"Public: OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN, "
"GET_PARAMETER\r\n");
rtsp_send_status(c, req, 200, "OK", headers);
}
static void rtsp_handle_describe(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[128];
if (!rtsp_path_eq(req->uri, rc->srv->path)) {
rtsp_send_status(c, req, 404, "Not Found", NULL);
return;
}
mg_snprintf(headers, sizeof(headers),
"Content-Type: application/sdp\r\n"
"Content-Base: %.*s/\r\n",
(int) req->uri.len, req->uri.buf);
rtsp_send_response(c, req, 200, "OK", headers, rc->srv->sdp,
strlen(rc->srv->sdp));
}
static bool rtsp_any_setup_done(const struct rtsp_conn *rc) {
size_t i;
for (i = 0; i < RTSP_TRACK_COUNT; i++) {
if (rc->tracks[i].setup_done) return true;
}
return false;
}
static void rtsp_handle_setup(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[160];
int track_id = rtsp_track_path_eq(req->uri, rc->srv->path);
struct rtsp_track_conn *tc;
if (track_id < 0 || (unsigned) track_id >= RTSP_TRACK_COUNT ||
((unsigned) track_id == RTSP_AUDIO_TRACK && !rc->srv->has_audio)) {
rtsp_send_status(c, req, 404, "Not Found", NULL);
return;
}
if (!rtsp_casencontains(req->transport, "RTP/AVP/TCP")) {
rtsp_send_status(c, req, 461, "Unsupported Transport", NULL);
return;
}
tc = &rc->tracks[track_id];
rtsp_parse_interleaved_channels(req->transport, &tc->rtp_channel, &tc->rtcp_channel);
tc->setup_done = true;
tc->ended = false;
mg_snprintf(headers, sizeof(headers),
"Transport: RTP/AVP/TCP;unicast;interleaved=%u-%u\r\n"
"Session: %s\r\n",
tc->rtp_channel, tc->rtcp_channel, rc->session_id);
rtsp_send_status(c, req, 200, "OK", headers);
}
static void rtsp_handle_play(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[128];
size_t i;
uint64_t now_ms;
if (!rtsp_any_setup_done(rc)) {
rtsp_send_status(c, req, 455, "Method Not Valid In This State", NULL);
return;
}
if (!rtsp_session_matches(rc, req->session)) {
rtsp_send_status(c, req, 454, "Session Not Found", NULL);
return;
}
rc->playing = true;
now_ms = mg_millis();
for (i = 0; i < RTSP_TRACK_COUNT; i++) {
if (rc->tracks[i].setup_done) {
rc->tracks[i].deadline_ms = now_ms;
rc->tracks[i].ended = false;
}
}
if (rc->srv->opts.fn == mg_rtsp_get_mp4_frame && rc->srv->opts.fn_data != NULL) {
rtsp_mp4_reset((const char *) rc->srv->opts.fn_data);
}
if (rc->srv->opts.audio_fn == mg_rtsp_get_mp4_audio &&
rc->srv->opts.audio_fn_data != NULL) {
rtsp_mp4_reset((const char *) rc->srv->opts.audio_fn_data);
}
mg_snprintf(headers, sizeof(headers), "Session: %s\r\nRange: npt=0.000-\r\n",
rc->session_id);
rtsp_send_status(c, req, 200, "OK", headers);
}
static void rtsp_handle_pause(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[64];
if (!rtsp_session_matches(rc, req->session)) {
rtsp_send_status(c, req, 454, "Session Not Found", NULL);
return;
}
rc->playing = false;
mg_snprintf(headers, sizeof(headers), "Session: %s\r\n", rc->session_id);
rtsp_send_status(c, req, 200, "OK", headers);
}
static void rtsp_handle_teardown(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[64];
if (!rtsp_session_matches(rc, req->session)) {
rtsp_send_status(c, req, 454, "Session Not Found", NULL);
return;
}
rc->playing = false;
mg_snprintf(headers, sizeof(headers), "Session: %s\r\n", rc->session_id);
rtsp_send_status(c, req, 200, "OK", headers);
c->is_draining = 1;
}
static void rtsp_handle_get_parameter(struct mg_connection *c,
struct rtsp_conn *rc,
const struct rtsp_request *req) {
char headers[64];
(void) rc;
mg_snprintf(headers, sizeof(headers), "Session: %s\r\n", rc->session_id);
rtsp_send_status(c, req, 200, "OK", headers);
}
static void rtsp_dispatch_request(struct mg_connection *c, struct rtsp_conn *rc,
const struct rtsp_request *req) {
if (rtsp_caseeq(req->method, "OPTIONS")) {
rtsp_handle_options(c, rc, req);
} else if (rtsp_caseeq(req->method, "DESCRIBE")) {
rtsp_handle_describe(c, rc, req);
} else if (rtsp_caseeq(req->method, "SETUP")) {
rtsp_handle_setup(c, rc, req);
} else if (rtsp_caseeq(req->method, "PLAY")) {
rtsp_handle_play(c, rc, req);
} else if (rtsp_caseeq(req->method, "PAUSE")) {
rtsp_handle_pause(c, rc, req);
} else if (rtsp_caseeq(req->method, "TEARDOWN")) {
rtsp_handle_teardown(c, rc, req);
} else if (rtsp_caseeq(req->method, "GET_PARAMETER")) {
rtsp_handle_get_parameter(c, rc, req);
} else {
rtsp_send_status(c, req, 405, "Method Not Allowed", NULL);
}
}
static void rtsp_handle_read(struct mg_connection *c) {
struct rtsp_conn *rc = (struct rtsp_conn *) c->fn_data;
for (;;) {
if (c->recv.len >= 4 && ((uint8_t *) c->recv.buf)[0] == '$') {
size_t frame_len =
((size_t) ((uint8_t *) c->recv.buf)[2] << 8) | ((uint8_t *) c->recv.buf)[3];
if (c->recv.len < frame_len + 4U) return;
mg_iobuf_del(&c->recv, 0, frame_len + 4U);
continue;
}
{
struct rtsp_request req;
int result = rtsp_parse_request((const char *) c->recv.buf, c->recv.len, &req);
if (result == 0) return;
if (result < 0) {
c->is_closing = 1;
return;
}
rtsp_dispatch_request(c, rc, &req);
mg_iobuf_del(&c->recv, 0, req.msg_len);
}
}
}
static void rtsp_handle_poll(struct mg_connection *c, uint64_t now_ms) {
struct rtsp_conn *rc = (struct rtsp_conn *) c->fn_data;
struct rtsp_mp4_state *video_st = NULL, *audio_st = NULL;
unsigned audio_rate = 0, audio_channels = 0;
unsigned fps = rc->srv->opts.fps == 0 ? 30U : rc->srv->opts.fps;
uint64_t video_fallback_ms = 1000U / fps;
uint64_t audio_fallback_ms = 20U;
unsigned burst = 0, max_burst = 128U;
size_t send_limit = 256U * 1024U;
if (!rc->playing) return;
if (!rc->tracks[RTSP_VIDEO_TRACK].setup_done &&
!rc->tracks[RTSP_AUDIO_TRACK].setup_done) {
return;
}
if (video_fallback_ms == 0) video_fallback_ms = 1;
if (rc->srv->opts.fn == NULL) return;
if (c->send.len >= send_limit) return;
if (rc->srv->opts.fn == mg_rtsp_get_mp4_frame && rc->srv->opts.fn_data != NULL) {
video_st = rtsp_mp4_get_state((const char *) rc->srv->opts.fn_data);
if (video_st == NULL) {
rc->playing = false;
c->is_draining = 1;
return;
}
}
if (rc->srv->has_audio) {
if (!rtsp_aac_lc_config_parse(rc->srv->opts.aac_lc_config, &audio_rate,
&audio_channels)) {
rc->playing = false;
c->is_draining = 1;
return;
}
(void) audio_channels;
audio_fallback_ms = rtsp_aac_frame_period_ms(audio_rate);
if (rc->srv->opts.audio_fn == mg_rtsp_get_mp4_audio &&
rc->srv->opts.audio_fn_data != NULL) {
audio_st = rtsp_mp4_get_state((const char *) rc->srv->opts.audio_fn_data);
if (audio_st == NULL) {
rc->playing = false;
c->is_draining = 1;
return;
}
}
}
if (rc->tracks[RTSP_VIDEO_TRACK].setup_done && video_st != NULL &&
video_st->sample_index >= video_st->sample_count) {
rc->tracks[RTSP_VIDEO_TRACK].ended = true;
}
if (rc->tracks[RTSP_AUDIO_TRACK].setup_done && audio_st != NULL &&
(audio_st->audio_samples == NULL ||
audio_st->audio_sample_index >= audio_st->audio_sample_count)) {
rc->tracks[RTSP_AUDIO_TRACK].ended = true;
}
while (rc->tracks[RTSP_VIDEO_TRACK].setup_done &&
!rc->tracks[RTSP_VIDEO_TRACK].ended && c->send.len < send_limit &&
mg_timer_expired(&rc->tracks[RTSP_VIDEO_TRACK].deadline_ms,
video_st != NULL
? rtsp_mp4_track_period_ms(
video_st->samples, video_st->sample_count,
video_st->sample_index, video_fallback_ms)
: video_fallback_ms,
now_ms)) {
struct mg_rtsp_frame frame;
if (!rc->srv->opts.fn(&frame, rc->srv->opts.fn_data) || frame.data == NULL ||
frame.len == 0) {
rc->tracks[RTSP_VIDEO_TRACK].ended = true;
break;
}
rtsp_send_access_unit(c, &rc->tracks[RTSP_VIDEO_TRACK], &frame);
if (++burst >= max_burst) break;
}
while (rc->srv->has_audio && rc->tracks[RTSP_AUDIO_TRACK].setup_done &&
!rc->tracks[RTSP_AUDIO_TRACK].ended && c->send.len < send_limit &&
mg_timer_expired(&rc->tracks[RTSP_AUDIO_TRACK].deadline_ms,
audio_st != NULL
? rtsp_mp4_track_period_ms(
audio_st->audio_samples,
audio_st->audio_sample_count,
audio_st->audio_sample_index,
audio_fallback_ms)
: audio_fallback_ms,
now_ms)) {
struct mg_rtsp_audio audio;
if (rc->srv->opts.audio_fn == NULL ||
!rc->srv->opts.audio_fn(&audio, rc->srv->opts.audio_fn_data) ||
audio.data == NULL || audio.len == 0) {
rc->tracks[RTSP_AUDIO_TRACK].ended = true;
break;
}
rtsp_send_audio_sample(c, &rc->tracks[RTSP_AUDIO_TRACK], audio.data, audio.len,
rtsp_audio_rtp_timestamp(audio_rate, audio.pts_us));
if (++burst >= max_burst) break;
}
if ((!rc->tracks[RTSP_VIDEO_TRACK].setup_done ||
rc->tracks[RTSP_VIDEO_TRACK].ended) &&
(!rc->tracks[RTSP_AUDIO_TRACK].setup_done ||
rc->tracks[RTSP_AUDIO_TRACK].ended)) {
rc->playing = false;
c->is_draining = 1;
}
}
static void rtsp_free_server(struct rtsp_server *srv) {
if (srv == NULL) return;
mg_free(srv->path);
mg_free(srv);
}
static void rtsp_fn(struct mg_connection *c, int ev, void *ev_data) {
if (c->is_listening) {
if (ev == MG_EV_CLOSE) rtsp_free_server((struct rtsp_server *) c->fn_data);
return;
}
switch (ev) {
case MG_EV_ACCEPT: {
struct rtsp_server *srv = (struct rtsp_server *) c->fn_data;
struct rtsp_conn *rc =
(struct rtsp_conn *) mg_calloc(1, sizeof(struct rtsp_conn));
if (rc == NULL) {
c->is_closing = 1;
break;
}
rc->srv = srv;
rc->tracks[RTSP_VIDEO_TRACK].rtp_channel = 0;
rc->tracks[RTSP_VIDEO_TRACK].rtcp_channel = 1;
rc->tracks[RTSP_VIDEO_TRACK].rtp_seq = (uint16_t) c->id;
rc->tracks[RTSP_VIDEO_TRACK].ssrc = 0x13572468U ^ (uint32_t) c->id;
rc->tracks[RTSP_AUDIO_TRACK].rtp_channel = 2;
rc->tracks[RTSP_AUDIO_TRACK].rtcp_channel = 3;
rc->tracks[RTSP_AUDIO_TRACK].rtp_seq = (uint16_t) (c->id ^ 0x4000U);
rc->tracks[RTSP_AUDIO_TRACK].ssrc = 0x24681357U ^ (uint32_t) c->id;
mg_snprintf(rc->session_id, sizeof(rc->session_id), "%lu", c->id);
c->fn_data = rc;
break;
}
case MG_EV_READ:
rtsp_handle_read(c);
break;
case MG_EV_POLL:
rtsp_handle_poll(c, *(uint64_t *) ev_data);
break;
case MG_EV_CLOSE:
mg_free(c->fn_data);
break;
default:
break;
}
}
struct mg_connection *mg_rtsp_listen(struct mg_mgr *mgr, const char *url,
const struct mg_rtsp_opts *opts) {
struct mg_connection *c;
struct rtsp_server *srv;
if (mgr == NULL || url == NULL || opts == NULL || opts->fn == NULL) return NULL;
srv = (struct rtsp_server *) mg_calloc(1, sizeof(*srv));
if (srv == NULL) return NULL;
srv->opts = *opts;
srv->path = rtsp_strdup(mg_url_uri(url));
if (srv->path == NULL || !rtsp_build_sdp(srv)) {
rtsp_free_server(srv);
return NULL;
}
c = mg_listen(mgr, url, rtsp_fn, srv);
if (c == NULL) {
rtsp_free_server(srv);
return NULL;
}
return c;
}
Reference in new issue View Git Blame Copy Permalink