rtpenc.c 20.6 KB
Newer Older
1 2
/*
 * RTP output format
3
 * Copyright (c) 2002 Fabrice Bellard
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * 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.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * 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
 * License along with FFmpeg; if not, write to the Free Software
 * 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 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
    case AV_CODEC_ID_H263:
    case AV_CODEC_ID_H263P:
    case AV_CODEC_ID_H264:
    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:
78
    case AV_CODEC_ID_MJPEG:
79
    case AV_CODEC_ID_SPEEX:
80
    case AV_CODEC_ID_OPUS:
81 82 83 84 85 86
        return 1;
    default:
        return 0;
    }
}

87 88
static int rtp_write_header(AVFormatContext *s1)
{
89
    RTPMuxContext *s = s1->priv_data;
90
    int n;
91 92
    AVStream *st;

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

        return -1;
    }
103

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

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

115
    s->base_timestamp = av_get_random_seed();
116 117
    s->timestamp = s->base_timestamp;
    s->cur_timestamp = 0;
118 119
    if (!s->ssrc)
        s->ssrc = av_get_random_seed();
120
    s->first_packet = 1;
121
    s->first_rtcp_ntp_time = ff_ntp_time();
122 123 124 125
    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;
126 127 128
    // 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.)
129 130 131 132 133 134
    if (s->seq < 0) {
        if (st->codec->flags & CODEC_FLAG_BITEXACT) {
            s->seq = 0;
        } else
            s->seq = av_get_random_seed() & 0x0fff;
    } else
135
        s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval
136

137
    if (s1->packet_size) {
138
        if (s1->pb->max_packet_size)
139 140
            s1->packet_size = FFMIN(s1->packet_size,
                                    s1->pb->max_packet_size);
141
    } else
142 143 144
        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);
145
        return AVERROR(EIO);
146
    }
147
    s->buf = av_malloc(s1->packet_size);
148 149 150
    if (s->buf == NULL) {
        return AVERROR(ENOMEM);
    }
151
    s->max_payload_size = s1->packet_size - 12;
152 153

    s->max_frames_per_packet = 0;
154
    if (s1->max_delay > 0) {
155
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
156 157 158 159
            int frame_size = av_get_audio_frame_duration(st->codec, 0);
            if (!frame_size)
                frame_size = st->codec->frame_size;
            if (frame_size == 0) {
160 161
                av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
            } else {
162 163 164
                s->max_frames_per_packet =
                        av_rescale_q_rnd(s1->max_delay,
                                         AV_TIME_BASE_Q,
165
                                         (AVRational){ frame_size, st->codec->sample_rate },
166
                                         AV_ROUND_DOWN);
167 168
            }
        }
169
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
170
            /* FIXME: We should round down here... */
171
            s->max_frames_per_packet = av_rescale_q(s1->max_delay, (AVRational){1, 1000000}, st->codec->time_base);
172 173 174
        }
    }

175
    avpriv_set_pts_info(st, 32, 1, 90000);
176
    switch(st->codec->codec_id) {
177 178
    case AV_CODEC_ID_MP2:
    case AV_CODEC_ID_MP3:
179 180
        s->buf_ptr = s->buf + 4;
        break;
181 182
    case AV_CODEC_ID_MPEG1VIDEO:
    case AV_CODEC_ID_MPEG2VIDEO:
183
        break;
184
    case AV_CODEC_ID_MPEG2TS:
185 186 187 188 189 190
        n = s->max_payload_size / TS_PACKET_SIZE;
        if (n < 1)
            n = 1;
        s->max_payload_size = n * TS_PACKET_SIZE;
        s->buf_ptr = s->buf;
        break;
191
    case AV_CODEC_ID_H264:
192
        /* check for H.264 MP4 syntax */
193
        if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) {
194 195 196
            s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1;
        }
        break;
197 198
    case AV_CODEC_ID_VORBIS:
    case AV_CODEC_ID_THEORA:
199 200 201 202 203
        if (!s->max_frames_per_packet) s->max_frames_per_packet = 15;
        s->max_frames_per_packet = av_clip(s->max_frames_per_packet, 1, 15);
        s->max_payload_size -= 6; // ident+frag+tdt/vdt+pkt_num+pkt_length
        s->num_frames = 0;
        goto defaultcase;
204
    case AV_CODEC_ID_ADPCM_G722:
205 206
        /* Due to a historical error, the clock rate for G722 in RTP is
         * 8000, even if the sample rate is 16000. See RFC 3551. */
207
        avpriv_set_pts_info(st, 32, 1, 8000);
208
        break;
209 210 211 212 213 214 215 216 217 218
    case AV_CODEC_ID_OPUS:
        if (st->codec->channels > 2) {
            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;
219
    case AV_CODEC_ID_ILBC:
220 221 222 223 224 225 226 227 228
        if (st->codec->block_align != 38 && st->codec->block_align != 50) {
            av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
            goto fail;
        }
        if (!s->max_frames_per_packet)
            s->max_frames_per_packet = 1;
        s->max_frames_per_packet = FFMIN(s->max_frames_per_packet,
                                         s->max_payload_size / st->codec->block_align);
        goto defaultcase;
229 230
    case AV_CODEC_ID_AMR_NB:
    case AV_CODEC_ID_AMR_WB:
231 232
        if (!s->max_frames_per_packet)
            s->max_frames_per_packet = 12;
233
        if (st->codec->codec_id == AV_CODEC_ID_AMR_NB)
234 235 236 237 238 239
            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");
240
            goto fail;
241 242 243
        }
        if (st->codec->channels != 1) {
            av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
244
            goto fail;
245
        }
246
    case AV_CODEC_ID_AAC:
247
        s->num_frames = 0;
248
    default:
249
defaultcase:
250
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
251
            avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
252 253 254 255 256 257
        }
        s->buf_ptr = s->buf;
        break;
    }

    return 0;
258 259 260 261

fail:
    av_freep(&s->buf);
    return AVERROR(EINVAL);
262 263 264
}

/* send an rtcp sender report packet */
265
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
266
{
267
    RTPMuxContext *s = s1->priv_data;
268 269
    uint32_t rtp_ts;

270
    av_dlog(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
271 272

    s->last_rtcp_ntp_time = ntp_time;
273
    rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
274
                          s1->streams[0]->time_base) + s->base_timestamp;
275
    avio_w8(s1->pb, RTP_VERSION << 6);
276 277 278
    avio_w8(s1->pb, RTCP_SR);
    avio_wb16(s1->pb, 6); /* length in words - 1 */
    avio_wb32(s1->pb, s->ssrc);
279
    avio_wb64(s1->pb, NTP_TO_RTP_FORMAT(ntp_time));
280 281 282
    avio_wb32(s1->pb, rtp_ts);
    avio_wb32(s1->pb, s->packet_count);
    avio_wb32(s1->pb, s->octet_count);
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

    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);
    }

299 300 301 302 303 304 305
    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);
    }

306
    avio_flush(s1->pb);
307 308 309 310 311 312
}

/* 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)
{
313
    RTPMuxContext *s = s1->priv_data;
314

315
    av_dlog(s1, "rtp_send_data size=%d\n", len);
316 317

    /* build the RTP header */
318
    avio_w8(s1->pb, RTP_VERSION << 6);
319 320 321 322
    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);
323

324
    avio_write(s1->pb, buf1, len);
325
    avio_flush(s1->pb);
326

327
    s->seq = (s->seq + 1) & 0xffff;
328 329 330 331 332 333
    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. */
334 335
static int rtp_send_samples(AVFormatContext *s1,
                            const uint8_t *buf1, int size, int sample_size_bits)
336
{
337
    RTPMuxContext *s = s1->priv_data;
338
    int len, max_packet_size, n;
339 340
    /* 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);
341

342 343 344
    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)
345
        return AVERROR(EINVAL);
346 347 348 349 350 351 352 353 354 355
    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;
356
        s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;
357 358 359
        ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
        n += (s->buf_ptr - s->buf);
    }
360
    return 0;
361 362 363 364 365
}

static void rtp_send_mpegaudio(AVFormatContext *s1,
                               const uint8_t *buf1, int size)
{
366
    RTPMuxContext *s = s1->priv_data;
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 410 411 412 413 414 415 416 417
    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)
{
418
    RTPMuxContext *s = s1->priv_data;
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
    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)
{
440
    RTPMuxContext *s = s1->priv_data;
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
    int len, out_len;

    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;
        }
    }
}

460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
{
    RTPMuxContext *s = s1->priv_data;
    AVStream *st = s1->streams[0];
    int frame_duration = av_get_audio_frame_duration(st->codec, 0);
    int frame_size = st->codec->block_align;
    int frames = size / frame_size;

    while (frames > 0) {
        int n = FFMIN(s->max_frames_per_packet - s->num_frames, frames);

        if (!s->num_frames) {
            s->buf_ptr = s->buf;
            s->timestamp = s->cur_timestamp;
        }
        memcpy(s->buf_ptr, buf, n * frame_size);
        frames           -= n;
        s->num_frames    += n;
        s->buf_ptr       += n * frame_size;
        buf              += n * frame_size;
        s->cur_timestamp += n * frame_duration;

        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;
}

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

497
    av_dlog(s1, "%d: write len=%d\n", pkt->stream_index, size);
498 499 500

    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
        RTCP_TX_RATIO_DEN;
501 502 503
    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)) {
504
        rtcp_send_sr(s1, ff_ntp_time(), 0);
505 506 507 508 509 510
        s->last_octet_count = s->octet_count;
        s->first_packet = 0;
    }
    s->cur_timestamp = s->base_timestamp + pkt->pts;

    switch(st->codec->codec_id) {
511 512 513 514
    case AV_CODEC_ID_PCM_MULAW:
    case AV_CODEC_ID_PCM_ALAW:
    case AV_CODEC_ID_PCM_U8:
    case AV_CODEC_ID_PCM_S8:
515
        return rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);
516 517 518 519
    case AV_CODEC_ID_PCM_U16BE:
    case AV_CODEC_ID_PCM_U16LE:
    case AV_CODEC_ID_PCM_S16BE:
    case AV_CODEC_ID_PCM_S16LE:
520
        return rtp_send_samples(s1, pkt->data, size, 16 * st->codec->channels);
521
    case AV_CODEC_ID_ADPCM_G722:
522 523
        /* 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,
524 525
         * the correct parameter for send_samples_bits is 8 bits per stream
         * clock. */
526
        return rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);
527
    case AV_CODEC_ID_ADPCM_G726:
528 529
        return rtp_send_samples(s1, pkt->data, size,
                                st->codec->bits_per_coded_sample * st->codec->channels);
530 531
    case AV_CODEC_ID_MP2:
    case AV_CODEC_ID_MP3:
532
        rtp_send_mpegaudio(s1, pkt->data, size);
533
        break;
534 535
    case AV_CODEC_ID_MPEG1VIDEO:
    case AV_CODEC_ID_MPEG2VIDEO:
536
        ff_rtp_send_mpegvideo(s1, pkt->data, size);
537
        break;
538
    case AV_CODEC_ID_AAC:
539
        if (s->flags & FF_RTP_FLAG_MP4A_LATM)
540 541 542
            ff_rtp_send_latm(s1, pkt->data, size);
        else
            ff_rtp_send_aac(s1, pkt->data, size);
543
        break;
544 545
    case AV_CODEC_ID_AMR_NB:
    case AV_CODEC_ID_AMR_WB:
546
        ff_rtp_send_amr(s1, pkt->data, size);
547
        break;
548
    case AV_CODEC_ID_MPEG2TS:
549
        rtp_send_mpegts_raw(s1, pkt->data, size);
550
        break;
551
    case AV_CODEC_ID_H264:
552
        ff_rtp_send_h264(s1, pkt->data, size);
553
        break;
554
    case AV_CODEC_ID_H263:
555
        if (s->flags & FF_RTP_FLAG_RFC2190) {
556 557 558 559
            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);
560 561 562 563
            if (!mb_info) {
                av_log(s1, AV_LOG_ERROR, "failed to allocate side data\n");
                return AVERROR(ENOMEM);
            }
564
            ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);
565 566 567
            break;
        }
        /* Fallthrough */
568
    case AV_CODEC_ID_H263P:
569
        ff_rtp_send_h263(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
};