rtpenc.c 20.5 KB
Newer Older
1 2
/*
 * RTP output format
3
 * Copyright (c) 2002 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9 10 11
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
12
 * Libav is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19 20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
21

22 23
#include "avformat.h"
#include "mpegts.h"
24
#include "internal.h"
25
#include "libavutil/mathematics.h"
26
#include "libavutil/random_seed.h"
27
#include "libavutil/opt.h"
28

29
#include "rtpenc.h"
30

31
static const AVOption options[] = {
32
    FF_RTP_FLAG_OPTS(RTPMuxContext, flags),
33 34
    { "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext, payload_type), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM },
    { "ssrc", "Stream identifier", offsetof(RTPMuxContext, ssrc), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
35
    { "cname", "CNAME to include in RTCP SR packets", offsetof(RTPMuxContext, cname), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
36
    { "seq", "Starting sequence number", offsetof(RTPMuxContext, seq), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 65535, AV_OPT_FLAG_ENCODING_PARAM },
37 38 39 40 41 42 43 44 45 46
    { NULL },
};

static const AVClass rtp_muxer_class = {
    .class_name = "RTP muxer",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

47 48
#define RTCP_SR_SIZE 28

49
static int is_supported(enum AVCodecID id)
50 51
{
    switch(id) {
52
    case AV_CODEC_ID_H261:
53 54 55
    case AV_CODEC_ID_H263:
    case AV_CODEC_ID_H263P:
    case AV_CODEC_ID_H264:
56
    case AV_CODEC_ID_HEVC:
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
    case AV_CODEC_ID_MPEG1VIDEO:
    case AV_CODEC_ID_MPEG2VIDEO:
    case AV_CODEC_ID_MPEG4:
    case AV_CODEC_ID_AAC:
    case AV_CODEC_ID_MP2:
    case AV_CODEC_ID_MP3:
    case AV_CODEC_ID_PCM_ALAW:
    case AV_CODEC_ID_PCM_MULAW:
    case AV_CODEC_ID_PCM_S8:
    case AV_CODEC_ID_PCM_S16BE:
    case AV_CODEC_ID_PCM_S16LE:
    case AV_CODEC_ID_PCM_U16BE:
    case AV_CODEC_ID_PCM_U16LE:
    case AV_CODEC_ID_PCM_U8:
    case AV_CODEC_ID_MPEG2TS:
    case AV_CODEC_ID_AMR_NB:
    case AV_CODEC_ID_AMR_WB:
    case AV_CODEC_ID_VORBIS:
    case AV_CODEC_ID_THEORA:
    case AV_CODEC_ID_VP8:
    case AV_CODEC_ID_ADPCM_G722:
    case AV_CODEC_ID_ADPCM_G726:
    case AV_CODEC_ID_ILBC:
80
    case AV_CODEC_ID_MJPEG:
81
    case AV_CODEC_ID_SPEEX:
82
    case AV_CODEC_ID_OPUS:
83 84 85 86 87 88
        return 1;
    default:
        return 0;
    }
}

89 90
static int rtp_write_header(AVFormatContext *s1)
{
91
    RTPMuxContext *s = s1->priv_data;
92
    int n, ret = AVERROR(EINVAL);
93 94
    AVStream *st;

95 96 97 98
    if (s1->nb_streams != 1) {
        av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");
        return AVERROR(EINVAL);
    }
99
    st = s1->streams[0];
100 101
    if (!is_supported(st->codecpar->codec_id)) {
        av_log(s1, AV_LOG_ERROR, "Unsupported codec %x\n", st->codecpar->codec_id);
102 103 104

        return -1;
    }
105

106 107 108
    if (s->payload_type < 0) {
        /* Re-validate non-dynamic payload types */
        if (st->id < RTP_PT_PRIVATE)
109
            st->id = ff_rtp_get_payload_type(s1, st->codecpar, -1);
110 111 112 113 114 115 116

        s->payload_type = st->id;
    } else {
        /* private option takes priority */
        st->id = s->payload_type;
    }

117
    s->base_timestamp = av_get_random_seed();
118 119
    s->timestamp = s->base_timestamp;
    s->cur_timestamp = 0;
120 121
    if (!s->ssrc)
        s->ssrc = av_get_random_seed();
122
    s->first_packet = 1;
123
    s->first_rtcp_ntp_time = ff_ntp_time();
124 125 126 127
    if (s1->start_time_realtime)
        /* Round the NTP time to whole milliseconds. */
        s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
                                 NTP_OFFSET_US;
128 129 130 131 132 133 134
    // Pick a random sequence start number, but in the lower end of the
    // available range, so that any wraparound doesn't happen immediately.
    // (Immediate wraparound would be an issue for SRTP.)
    if (s->seq < 0)
        s->seq = av_get_random_seed() & 0x0fff;
    else
        s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval
135

136
    if (s1->packet_size) {
137
        if (s1->pb->max_packet_size)
138 139
            s1->packet_size = FFMIN(s1->packet_size,
                                    s1->pb->max_packet_size);
140
    } else
141 142 143
        s1->packet_size = s1->pb->max_packet_size;
    if (s1->packet_size <= 12) {
        av_log(s1, AV_LOG_ERROR, "Max packet size %d too low\n", s1->packet_size);
144
        return AVERROR(EIO);
145
    }
146
    s->buf = av_malloc(s1->packet_size);
147
    if (!s->buf) {
148 149
        return AVERROR(ENOMEM);
    }
150
    s->max_payload_size = s1->packet_size - 12;
151

152 153
    if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
        avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
154 155 156 157
    } else {
        avpriv_set_pts_info(st, 32, 1, 90000);
    }
    s->buf_ptr = s->buf;
158
    switch(st->codecpar->codec_id) {
159 160
    case AV_CODEC_ID_MP2:
    case AV_CODEC_ID_MP3:
161
        s->buf_ptr = s->buf + 4;
162
        avpriv_set_pts_info(st, 32, 1, 90000);
163
        break;
164 165
    case AV_CODEC_ID_MPEG1VIDEO:
    case AV_CODEC_ID_MPEG2VIDEO:
166
        break;
167
    case AV_CODEC_ID_MPEG2TS:
168 169 170 171 172
        n = s->max_payload_size / TS_PACKET_SIZE;
        if (n < 1)
            n = 1;
        s->max_payload_size = n * TS_PACKET_SIZE;
        break;
173 174 175
    case AV_CODEC_ID_H261:
        if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
            av_log(s, AV_LOG_ERROR,
176
                   "Packetizing H.261 is experimental and produces incorrect "
177 178 179 180 181 182 183
                   "packetization for cases where GOBs don't fit into packets "
                   "(even though most receivers may handle it just fine). "
                   "Please set -f_strict experimental in order to enable it.\n");
            ret = AVERROR_EXPERIMENTAL;
            goto fail;
        }
        break;
184
    case AV_CODEC_ID_H264:
185
        /* check for H.264 MP4 syntax */
186 187
        if (st->codecpar->extradata_size > 4 && st->codecpar->extradata[0] == 1) {
            s->nal_length_size = (st->codecpar->extradata[4] & 0x03) + 1;
188 189
        }
        break;
190 191
    case AV_CODEC_ID_HEVC:
        /* Only check for the standardized hvcC version of extradata, keeping
192
         * things simple and similar to the avcC/H.264 case above, instead
193 194
         * of trying to handle the pre-standardization versions (as in
         * libavcodec/hevc.c). */
195 196
        if (st->codecpar->extradata_size > 21 && st->codecpar->extradata[0] == 1) {
            s->nal_length_size = (st->codecpar->extradata[21] & 0x03) + 1;
197 198
        }
        break;
199 200
    case AV_CODEC_ID_VORBIS:
    case AV_CODEC_ID_THEORA:
201
        s->max_frames_per_packet = 15;
202
        break;
203
    case AV_CODEC_ID_ADPCM_G722:
204 205
        /* Due to a historical error, the clock rate for G722 in RTP is
         * 8000, even if the sample rate is 16000. See RFC 3551. */
206
        avpriv_set_pts_info(st, 32, 1, 8000);
207
        break;
208
    case AV_CODEC_ID_OPUS:
209
        if (st->codecpar->channels > 2) {
210 211 212 213 214 215 216 217
            av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");
            goto fail;
        }
        /* The opus RTP RFC says that all opus streams should use 48000 Hz
         * as clock rate, since all opus sample rates can be expressed in
         * this clock rate, and sample rate changes on the fly are supported. */
        avpriv_set_pts_info(st, 32, 1, 48000);
        break;
218
    case AV_CODEC_ID_ILBC:
219
        if (st->codecpar->block_align != 38 && st->codecpar->block_align != 50) {
220 221 222
            av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
            goto fail;
        }
223
        s->max_frames_per_packet = s->max_payload_size / st->codecpar->block_align;
224
        break;
225 226
    case AV_CODEC_ID_AMR_NB:
    case AV_CODEC_ID_AMR_WB:
227
        s->max_frames_per_packet = 50;
228
        if (st->codecpar->codec_id == AV_CODEC_ID_AMR_NB)
229 230 231 232 233 234
            n = 31;
        else
            n = 61;
        /* max_header_toc_size + the largest AMR payload must fit */
        if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
            av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
235
            goto fail;
236
        }
237
        if (st->codecpar->channels != 1) {
238
            av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
239
            goto fail;
240
        }
241
        break;
242
    case AV_CODEC_ID_AAC:
243
        s->max_frames_per_packet = 50;
244
        break;
245 246 247 248 249
    default:
        break;
    }

    return 0;
250 251 252

fail:
    av_freep(&s->buf);
253
    return ret;
254 255 256
}

/* send an rtcp sender report packet */
257
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
258
{
259
    RTPMuxContext *s = s1->priv_data;
260 261
    uint32_t rtp_ts;

262
    av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
263 264

    s->last_rtcp_ntp_time = ntp_time;
265
    rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
266
                          s1->streams[0]->time_base) + s->base_timestamp;
267
    avio_w8(s1->pb, RTP_VERSION << 6);
268 269 270
    avio_w8(s1->pb, RTCP_SR);
    avio_wb16(s1->pb, 6); /* length in words - 1 */
    avio_wb32(s1->pb, s->ssrc);
271
    avio_wb64(s1->pb, NTP_TO_RTP_FORMAT(ntp_time));
272 273 274
    avio_wb32(s1->pb, rtp_ts);
    avio_wb32(s1->pb, s->packet_count);
    avio_wb32(s1->pb, s->octet_count);
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290

    if (s->cname) {
        int len = FFMIN(strlen(s->cname), 255);
        avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
        avio_w8(s1->pb, RTCP_SDES);
        avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */

        avio_wb32(s1->pb, s->ssrc);
        avio_w8(s1->pb, 0x01); /* CNAME */
        avio_w8(s1->pb, len);
        avio_write(s1->pb, s->cname, len);
        avio_w8(s1->pb, 0); /* END */
        for (len = (7 + len) % 4; len % 4; len++)
            avio_w8(s1->pb, 0);
    }

291 292 293 294 295 296 297
    if (bye) {
        avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
        avio_w8(s1->pb, RTCP_BYE);
        avio_wb16(s1->pb, 1); /* length in words - 1 */
        avio_wb32(s1->pb, s->ssrc);
    }

298
    avio_flush(s1->pb);
299 300 301 302 303 304
}

/* send an rtp packet. sequence number is incremented, but the caller
   must update the timestamp itself */
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
{
305
    RTPMuxContext *s = s1->priv_data;
306

307
    av_log(s1, AV_LOG_TRACE, "rtp_send_data size=%d\n", len);
308 309

    /* build the RTP header */
310
    avio_w8(s1->pb, RTP_VERSION << 6);
311 312 313 314
    avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
    avio_wb16(s1->pb, s->seq);
    avio_wb32(s1->pb, s->timestamp);
    avio_wb32(s1->pb, s->ssrc);
315

316
    avio_write(s1->pb, buf1, len);
317
    avio_flush(s1->pb);
318

319
    s->seq = (s->seq + 1) & 0xffff;
320 321 322 323 324 325
    s->octet_count += len;
    s->packet_count++;
}

/* send an integer number of samples and compute time stamp and fill
   the rtp send buffer before sending. */
326 327
static int rtp_send_samples(AVFormatContext *s1,
                            const uint8_t *buf1, int size, int sample_size_bits)
328
{
329
    RTPMuxContext *s = s1->priv_data;
330
    int len, max_packet_size, n;
331 332
    /* Calculate the number of bytes to get samples aligned on a byte border */
    int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8);
333

334 335 336
    max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;
    /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
    if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0)
337
        return AVERROR(EINVAL);
338 339 340 341 342 343 344 345 346 347
    n = 0;
    while (size > 0) {
        s->buf_ptr = s->buf;
        len = FFMIN(max_packet_size, size);

        /* copy data */
        memcpy(s->buf_ptr, buf1, len);
        s->buf_ptr += len;
        buf1 += len;
        size -= len;
348
        s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;
349 350 351
        ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
        n += (s->buf_ptr - s->buf);
    }
352
    return 0;
353 354 355 356 357
}

static void rtp_send_mpegaudio(AVFormatContext *s1,
                               const uint8_t *buf1, int size)
{
358
    RTPMuxContext *s = s1->priv_data;
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
    int len, count, max_packet_size;

    max_packet_size = s->max_payload_size;

    /* test if we must flush because not enough space */
    len = (s->buf_ptr - s->buf);
    if ((len + size) > max_packet_size) {
        if (len > 4) {
            ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
            s->buf_ptr = s->buf + 4;
        }
    }
    if (s->buf_ptr == s->buf + 4) {
        s->timestamp = s->cur_timestamp;
    }

    /* add the packet */
    if (size > max_packet_size) {
        /* big packet: fragment */
        count = 0;
        while (size > 0) {
            len = max_packet_size - 4;
            if (len > size)
                len = size;
            /* build fragmented packet */
            s->buf[0] = 0;
            s->buf[1] = 0;
            s->buf[2] = count >> 8;
            s->buf[3] = count;
            memcpy(s->buf + 4, buf1, len);
            ff_rtp_send_data(s1, s->buf, len + 4, 0);
            size -= len;
            buf1 += len;
            count += len;
        }
    } else {
        if (s->buf_ptr == s->buf + 4) {
            /* no fragmentation possible */
            s->buf[0] = 0;
            s->buf[1] = 0;
            s->buf[2] = 0;
            s->buf[3] = 0;
        }
        memcpy(s->buf_ptr, buf1, size);
        s->buf_ptr += size;
    }
}

static void rtp_send_raw(AVFormatContext *s1,
                         const uint8_t *buf1, int size)
{
410
    RTPMuxContext *s = s1->priv_data;
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
    int len, max_packet_size;

    max_packet_size = s->max_payload_size;

    while (size > 0) {
        len = max_packet_size;
        if (len > size)
            len = size;

        s->timestamp = s->cur_timestamp;
        ff_rtp_send_data(s1, buf1, len, (len == size));

        buf1 += len;
        size -= len;
    }
}

/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
static void rtp_send_mpegts_raw(AVFormatContext *s1,
                                const uint8_t *buf1, int size)
{
432
    RTPMuxContext *s = s1->priv_data;
433 434
    int len, out_len;

435
    s->timestamp = s->cur_timestamp;
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
    while (size >= TS_PACKET_SIZE) {
        len = s->max_payload_size - (s->buf_ptr - s->buf);
        if (len > size)
            len = size;
        memcpy(s->buf_ptr, buf1, len);
        buf1 += len;
        size -= len;
        s->buf_ptr += len;

        out_len = s->buf_ptr - s->buf;
        if (out_len >= s->max_payload_size) {
            ff_rtp_send_data(s1, s->buf, out_len, 0);
            s->buf_ptr = s->buf;
        }
    }
}

453 454 455 456
static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
{
    RTPMuxContext *s = s1->priv_data;
    AVStream *st = s1->streams[0];
457 458
    int frame_duration = av_get_audio_frame_duration2(st->codecpar, 0);
    int frame_size = st->codecpar->block_align;
459 460 461
    int frames = size / frame_size;

    while (frames > 0) {
462 463 464 465 466 467
        if (s->num_frames > 0 &&
            av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,
                          s1->max_delay, AV_TIME_BASE_Q) >= 0) {
            ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
            s->num_frames = 0;
        }
468 469 470 471 472

        if (!s->num_frames) {
            s->buf_ptr = s->buf;
            s->timestamp = s->cur_timestamp;
        }
473 474 475 476 477 478
        memcpy(s->buf_ptr, buf, frame_size);
        frames--;
        s->num_frames++;
        s->buf_ptr       += frame_size;
        buf              += frame_size;
        s->cur_timestamp += frame_duration;
479 480 481 482 483 484 485 486 487

        if (s->num_frames == s->max_frames_per_packet) {
            ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
            s->num_frames = 0;
        }
    }
    return 0;
}

488 489
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
{
490
    RTPMuxContext *s = s1->priv_data;
491 492 493 494
    AVStream *st = s1->streams[0];
    int rtcp_bytes;
    int size= pkt->size;

495
    av_log(s1, AV_LOG_TRACE, "%d: write len=%d\n", pkt->stream_index, size);
496 497 498

    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
        RTCP_TX_RATIO_DEN;
499 500 501
    if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
                            (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&
        !(s->flags & FF_RTP_FLAG_SKIP_RTCP)) {
502
        rtcp_send_sr(s1, ff_ntp_time(), 0);
503 504 505 506 507
        s->last_octet_count = s->octet_count;
        s->first_packet = 0;
    }
    s->cur_timestamp = s->base_timestamp + pkt->pts;

508
    switch(st->codecpar->codec_id) {
509 510 511 512
    case AV_CODEC_ID_PCM_MULAW:
    case AV_CODEC_ID_PCM_ALAW:
    case AV_CODEC_ID_PCM_U8:
    case AV_CODEC_ID_PCM_S8:
513
        return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->channels);
514 515 516 517
    case AV_CODEC_ID_PCM_U16BE:
    case AV_CODEC_ID_PCM_U16LE:
    case AV_CODEC_ID_PCM_S16BE:
    case AV_CODEC_ID_PCM_S16LE:
518
        return rtp_send_samples(s1, pkt->data, size, 16 * st->codecpar->channels);
519
    case AV_CODEC_ID_ADPCM_G722:
520 521
        /* The actual sample size is half a byte per sample, but since the
         * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
522 523
         * the correct parameter for send_samples_bits is 8 bits per stream
         * clock. */
524
        return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->channels);
525
    case AV_CODEC_ID_ADPCM_G726:
526
        return rtp_send_samples(s1, pkt->data, size,
527
                                st->codecpar->bits_per_coded_sample * st->codecpar->channels);
528 529
    case AV_CODEC_ID_MP2:
    case AV_CODEC_ID_MP3:
530
        rtp_send_mpegaudio(s1, pkt->data, size);
531
        break;
532 533
    case AV_CODEC_ID_MPEG1VIDEO:
    case AV_CODEC_ID_MPEG2VIDEO:
534
        ff_rtp_send_mpegvideo(s1, pkt->data, size);
535
        break;
536
    case AV_CODEC_ID_AAC:
537 538 539 540
        if (s->flags & FF_RTP_FLAG_MP4A_LATM)
            ff_rtp_send_latm(s1, pkt->data, size);
        else
            ff_rtp_send_aac(s1, pkt->data, size);
541
        break;
542 543
    case AV_CODEC_ID_AMR_NB:
    case AV_CODEC_ID_AMR_WB:
544
        ff_rtp_send_amr(s1, pkt->data, size);
545
        break;
546
    case AV_CODEC_ID_MPEG2TS:
547
        rtp_send_mpegts_raw(s1, pkt->data, size);
548
        break;
549
    case AV_CODEC_ID_H264:
550
        ff_rtp_send_h264_hevc(s1, pkt->data, size);
551
        break;
552 553 554
    case AV_CODEC_ID_H261:
        ff_rtp_send_h261(s1, pkt->data, size);
        break;
555
    case AV_CODEC_ID_H263:
556
        if (s->flags & FF_RTP_FLAG_RFC2190) {
557 558 559 560 561
            int mb_info_size = 0;
            const uint8_t *mb_info =
                av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,
                                        &mb_info_size);
            ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);
562 563 564
            break;
        }
        /* Fallthrough */
565
    case AV_CODEC_ID_H263P:
566
        ff_rtp_send_h263(s1, pkt->data, size);
567
        break;
568
    case AV_CODEC_ID_HEVC:
569
        ff_rtp_send_h264_hevc(s1, pkt->data, size);
570
        break;
571 572
    case AV_CODEC_ID_VORBIS:
    case AV_CODEC_ID_THEORA:
573 574
        ff_rtp_send_xiph(s1, pkt->data, size);
        break;
575
    case AV_CODEC_ID_VP8:
576 577
        ff_rtp_send_vp8(s1, pkt->data, size);
        break;
578
    case AV_CODEC_ID_ILBC:
579 580
        rtp_send_ilbc(s1, pkt->data, size);
        break;
581 582 583
    case AV_CODEC_ID_MJPEG:
        ff_rtp_send_jpeg(s1, pkt->data, size);
        break;
584 585 586 587 588 589 590 591
    case AV_CODEC_ID_OPUS:
        if (size > s->max_payload_size) {
            av_log(s1, AV_LOG_ERROR,
                   "Packet size %d too large for max RTP payload size %d\n",
                   size, s->max_payload_size);
            return AVERROR(EINVAL);
        }
        /* Intentional fallthrough */
592 593
    default:
        /* better than nothing : send the codec raw data */
594
        rtp_send_raw(s1, pkt->data, size);
595 596 597 598 599
        break;
    }
    return 0;
}

600 601 602 603
static int rtp_write_trailer(AVFormatContext *s1)
{
    RTPMuxContext *s = s1->priv_data;

604 605 606 607
    /* If the caller closes and recreates ->pb, this might actually
     * be NULL here even if it was successfully allocated at the start. */
    if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))
        rtcp_send_sr(s1, ff_ntp_time(), 1);
608 609 610 611 612
    av_freep(&s->buf);

    return 0;
}

613
AVOutputFormat ff_rtp_muxer = {
614
    .name              = "rtp",
615
    .long_name         = NULL_IF_CONFIG_SMALL("RTP output"),
616
    .priv_data_size    = sizeof(RTPMuxContext),
617 618
    .audio_codec       = AV_CODEC_ID_PCM_MULAW,
    .video_codec       = AV_CODEC_ID_MPEG4,
619 620 621
    .write_header      = rtp_write_header,
    .write_packet      = rtp_write_packet,
    .write_trailer     = rtp_write_trailer,
622
    .priv_class        = &rtp_muxer_class,
623
    .flags             = AVFMT_TS_NONSTRICT,
624
};