Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * RTP output format
  3.  * Copyright (c) 2002 Fabrice Bellard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include "avformat.h"
  23. #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.     { "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext, payload_type), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM },
  34.     { "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.     { NULL },
  38. };
  39.  
  40. static const AVClass rtp_muxer_class = {
  41.     .class_name = "RTP muxer",
  42.     .item_name  = av_default_item_name,
  43.     .option     = options,
  44.     .version    = LIBAVUTIL_VERSION_INT,
  45. };
  46.  
  47. #define RTCP_SR_SIZE 28
  48.  
  49. static int is_supported(enum AVCodecID id)
  50. {
  51.     switch(id) {
  52.     case AV_CODEC_ID_H261:
  53.     case AV_CODEC_ID_H263:
  54.     case AV_CODEC_ID_H263P:
  55.     case AV_CODEC_ID_H264:
  56.     case AV_CODEC_ID_HEVC:
  57.     case AV_CODEC_ID_MPEG1VIDEO:
  58.     case AV_CODEC_ID_MPEG2VIDEO:
  59.     case AV_CODEC_ID_MPEG4:
  60.     case AV_CODEC_ID_AAC:
  61.     case AV_CODEC_ID_MP2:
  62.     case AV_CODEC_ID_MP3:
  63.     case AV_CODEC_ID_PCM_ALAW:
  64.     case AV_CODEC_ID_PCM_MULAW:
  65.     case AV_CODEC_ID_PCM_S8:
  66.     case AV_CODEC_ID_PCM_S16BE:
  67.     case AV_CODEC_ID_PCM_S16LE:
  68.     case AV_CODEC_ID_PCM_U16BE:
  69.     case AV_CODEC_ID_PCM_U16LE:
  70.     case AV_CODEC_ID_PCM_U8:
  71.     case AV_CODEC_ID_MPEG2TS:
  72.     case AV_CODEC_ID_AMR_NB:
  73.     case AV_CODEC_ID_AMR_WB:
  74.     case AV_CODEC_ID_VORBIS:
  75.     case AV_CODEC_ID_THEORA:
  76.     case AV_CODEC_ID_VP8:
  77.     case AV_CODEC_ID_ADPCM_G722:
  78.     case AV_CODEC_ID_ADPCM_G726:
  79.     case AV_CODEC_ID_ILBC:
  80.     case AV_CODEC_ID_MJPEG:
  81.     case AV_CODEC_ID_SPEEX:
  82.     case AV_CODEC_ID_OPUS:
  83.         return 1;
  84.     default:
  85.         return 0;
  86.     }
  87. }
  88.  
  89. static int rtp_write_header(AVFormatContext *s1)
  90. {
  91.     RTPMuxContext *s = s1->priv_data;
  92.     int n, ret = AVERROR(EINVAL);
  93.     AVStream *st;
  94.  
  95.     if (s1->nb_streams != 1) {
  96.         av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");
  97.         return AVERROR(EINVAL);
  98.     }
  99.     st = s1->streams[0];
  100.     if (!is_supported(st->codec->codec_id)) {
  101.         av_log(s1, AV_LOG_ERROR, "Unsupported codec %s\n", avcodec_get_name(st->codec->codec_id));
  102.  
  103.         return -1;
  104.     }
  105.  
  106.     if (s->payload_type < 0) {
  107.         /* Re-validate non-dynamic payload types */
  108.         if (st->id < RTP_PT_PRIVATE)
  109.             st->id = ff_rtp_get_payload_type(s1, st->codec, -1);
  110.  
  111.         s->payload_type = st->id;
  112.     } else {
  113.         /* private option takes priority */
  114.         st->id = s->payload_type;
  115.     }
  116.  
  117.     s->base_timestamp = av_get_random_seed();
  118.     s->timestamp = s->base_timestamp;
  119.     s->cur_timestamp = 0;
  120.     if (!s->ssrc)
  121.         s->ssrc = av_get_random_seed();
  122.     s->first_packet = 1;
  123.     s->first_rtcp_ntp_time = ff_ntp_time();
  124.     if (s1->start_time_realtime != 0  &&  s1->start_time_realtime != AV_NOPTS_VALUE)
  125.         /* Round the NTP time to whole milliseconds. */
  126.         s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
  127.                                  NTP_OFFSET_US;
  128.     // Pick a random sequence start number, but in the lower end of the
  129.     // available range, so that any wraparound doesn't happen immediately.
  130.     // (Immediate wraparound would be an issue for SRTP.)
  131.     if (s->seq < 0) {
  132.         if (s1->flags & AVFMT_FLAG_BITEXACT) {
  133.             s->seq = 0;
  134.         } else
  135.             s->seq = av_get_random_seed() & 0x0fff;
  136.     } else
  137.         s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval
  138.  
  139.     if (s1->packet_size) {
  140.         if (s1->pb->max_packet_size)
  141.             s1->packet_size = FFMIN(s1->packet_size,
  142.                                     s1->pb->max_packet_size);
  143.     } else
  144.         s1->packet_size = s1->pb->max_packet_size;
  145.     if (s1->packet_size <= 12) {
  146.         av_log(s1, AV_LOG_ERROR, "Max packet size %d too low\n", s1->packet_size);
  147.         return AVERROR(EIO);
  148.     }
  149.     s->buf = av_malloc(s1->packet_size);
  150.     if (!s->buf) {
  151.         return AVERROR(ENOMEM);
  152.     }
  153.     s->max_payload_size = s1->packet_size - 12;
  154.  
  155.     if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
  156.         avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
  157.     } else {
  158.         avpriv_set_pts_info(st, 32, 1, 90000);
  159.     }
  160.     s->buf_ptr = s->buf;
  161.     switch(st->codec->codec_id) {
  162.     case AV_CODEC_ID_MP2:
  163.     case AV_CODEC_ID_MP3:
  164.         s->buf_ptr = s->buf + 4;
  165.         avpriv_set_pts_info(st, 32, 1, 90000);
  166.         break;
  167.     case AV_CODEC_ID_MPEG1VIDEO:
  168.     case AV_CODEC_ID_MPEG2VIDEO:
  169.         break;
  170.     case AV_CODEC_ID_MPEG2TS:
  171.         n = s->max_payload_size / TS_PACKET_SIZE;
  172.         if (n < 1)
  173.             n = 1;
  174.         s->max_payload_size = n * TS_PACKET_SIZE;
  175.         break;
  176.     case AV_CODEC_ID_H261:
  177.         if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
  178.             av_log(s, AV_LOG_ERROR,
  179.                    "Packetizing H261 is experimental and produces incorrect "
  180.                    "packetization for cases where GOBs don't fit into packets "
  181.                    "(even though most receivers may handle it just fine). "
  182.                    "Please set -f_strict experimental in order to enable it.\n");
  183.             ret = AVERROR_EXPERIMENTAL;
  184.             goto fail;
  185.         }
  186.         break;
  187.     case AV_CODEC_ID_H264:
  188.         /* check for H.264 MP4 syntax */
  189.         if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) {
  190.             s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1;
  191.         }
  192.         break;
  193.     case AV_CODEC_ID_HEVC:
  194.         /* Only check for the standardized hvcC version of extradata, keeping
  195.          * things simple and similar to the avcC/H264 case above, instead
  196.          * of trying to handle the pre-standardization versions (as in
  197.          * libavcodec/hevc.c). */
  198.         if (st->codec->extradata_size > 21 && st->codec->extradata[0] == 1) {
  199.             s->nal_length_size = (st->codec->extradata[21] & 0x03) + 1;
  200.         }
  201.         break;
  202.     case AV_CODEC_ID_VORBIS:
  203.     case AV_CODEC_ID_THEORA:
  204.         s->max_frames_per_packet = 15;
  205.         break;
  206.     case AV_CODEC_ID_ADPCM_G722:
  207.         /* Due to a historical error, the clock rate for G722 in RTP is
  208.          * 8000, even if the sample rate is 16000. See RFC 3551. */
  209.         avpriv_set_pts_info(st, 32, 1, 8000);
  210.         break;
  211.     case AV_CODEC_ID_OPUS:
  212.         if (st->codec->channels > 2) {
  213.             av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");
  214.             goto fail;
  215.         }
  216.         /* The opus RTP RFC says that all opus streams should use 48000 Hz
  217.          * as clock rate, since all opus sample rates can be expressed in
  218.          * this clock rate, and sample rate changes on the fly are supported. */
  219.         avpriv_set_pts_info(st, 32, 1, 48000);
  220.         break;
  221.     case AV_CODEC_ID_ILBC:
  222.         if (st->codec->block_align != 38 && st->codec->block_align != 50) {
  223.             av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
  224.             goto fail;
  225.         }
  226.         s->max_frames_per_packet = s->max_payload_size / st->codec->block_align;
  227.         break;
  228.     case AV_CODEC_ID_AMR_NB:
  229.     case AV_CODEC_ID_AMR_WB:
  230.         s->max_frames_per_packet = 50;
  231.         if (st->codec->codec_id == AV_CODEC_ID_AMR_NB)
  232.             n = 31;
  233.         else
  234.             n = 61;
  235.         /* max_header_toc_size + the largest AMR payload must fit */
  236.         if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
  237.             av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
  238.             goto fail;
  239.         }
  240.         if (st->codec->channels != 1) {
  241.             av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
  242.             goto fail;
  243.         }
  244.         break;
  245.     case AV_CODEC_ID_AAC:
  246.         s->max_frames_per_packet = 50;
  247.         break;
  248.     default:
  249.         break;
  250.     }
  251.  
  252.     return 0;
  253.  
  254. fail:
  255.     av_freep(&s->buf);
  256.     return ret;
  257. }
  258.  
  259. /* send an rtcp sender report packet */
  260. static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
  261. {
  262.     RTPMuxContext *s = s1->priv_data;
  263.     uint32_t rtp_ts;
  264.  
  265.     av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
  266.  
  267.     s->last_rtcp_ntp_time = ntp_time;
  268.     rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
  269.                           s1->streams[0]->time_base) + s->base_timestamp;
  270.     avio_w8(s1->pb, RTP_VERSION << 6);
  271.     avio_w8(s1->pb, RTCP_SR);
  272.     avio_wb16(s1->pb, 6); /* length in words - 1 */
  273.     avio_wb32(s1->pb, s->ssrc);
  274.     avio_wb64(s1->pb, NTP_TO_RTP_FORMAT(ntp_time));
  275.     avio_wb32(s1->pb, rtp_ts);
  276.     avio_wb32(s1->pb, s->packet_count);
  277.     avio_wb32(s1->pb, s->octet_count);
  278.  
  279.     if (s->cname) {
  280.         int len = FFMIN(strlen(s->cname), 255);
  281.         avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
  282.         avio_w8(s1->pb, RTCP_SDES);
  283.         avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */
  284.  
  285.         avio_wb32(s1->pb, s->ssrc);
  286.         avio_w8(s1->pb, 0x01); /* CNAME */
  287.         avio_w8(s1->pb, len);
  288.         avio_write(s1->pb, s->cname, len);
  289.         avio_w8(s1->pb, 0); /* END */
  290.         for (len = (7 + len) % 4; len % 4; len++)
  291.             avio_w8(s1->pb, 0);
  292.     }
  293.  
  294.     if (bye) {
  295.         avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
  296.         avio_w8(s1->pb, RTCP_BYE);
  297.         avio_wb16(s1->pb, 1); /* length in words - 1 */
  298.         avio_wb32(s1->pb, s->ssrc);
  299.     }
  300.  
  301.     avio_flush(s1->pb);
  302. }
  303.  
  304. /* send an rtp packet. sequence number is incremented, but the caller
  305.    must update the timestamp itself */
  306. void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
  307. {
  308.     RTPMuxContext *s = s1->priv_data;
  309.  
  310.     av_log(s1, AV_LOG_TRACE, "rtp_send_data size=%d\n", len);
  311.  
  312.     /* build the RTP header */
  313.     avio_w8(s1->pb, RTP_VERSION << 6);
  314.     avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
  315.     avio_wb16(s1->pb, s->seq);
  316.     avio_wb32(s1->pb, s->timestamp);
  317.     avio_wb32(s1->pb, s->ssrc);
  318.  
  319.     avio_write(s1->pb, buf1, len);
  320.     avio_flush(s1->pb);
  321.  
  322.     s->seq = (s->seq + 1) & 0xffff;
  323.     s->octet_count += len;
  324.     s->packet_count++;
  325. }
  326.  
  327. /* send an integer number of samples and compute time stamp and fill
  328.    the rtp send buffer before sending. */
  329. static int rtp_send_samples(AVFormatContext *s1,
  330.                             const uint8_t *buf1, int size, int sample_size_bits)
  331. {
  332.     RTPMuxContext *s = s1->priv_data;
  333.     int len, max_packet_size, n;
  334.     /* Calculate the number of bytes to get samples aligned on a byte border */
  335.     int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8);
  336.  
  337.     max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;
  338.     /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
  339.     if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0)
  340.         return AVERROR(EINVAL);
  341.     n = 0;
  342.     while (size > 0) {
  343.         s->buf_ptr = s->buf;
  344.         len = FFMIN(max_packet_size, size);
  345.  
  346.         /* copy data */
  347.         memcpy(s->buf_ptr, buf1, len);
  348.         s->buf_ptr += len;
  349.         buf1 += len;
  350.         size -= len;
  351.         s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;
  352.         ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
  353.         n += (s->buf_ptr - s->buf);
  354.     }
  355.     return 0;
  356. }
  357.  
  358. static void rtp_send_mpegaudio(AVFormatContext *s1,
  359.                                const uint8_t *buf1, int size)
  360. {
  361.     RTPMuxContext *s = s1->priv_data;
  362.     int len, count, max_packet_size;
  363.  
  364.     max_packet_size = s->max_payload_size;
  365.  
  366.     /* test if we must flush because not enough space */
  367.     len = (s->buf_ptr - s->buf);
  368.     if ((len + size) > max_packet_size) {
  369.         if (len > 4) {
  370.             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
  371.             s->buf_ptr = s->buf + 4;
  372.         }
  373.     }
  374.     if (s->buf_ptr == s->buf + 4) {
  375.         s->timestamp = s->cur_timestamp;
  376.     }
  377.  
  378.     /* add the packet */
  379.     if (size > max_packet_size) {
  380.         /* big packet: fragment */
  381.         count = 0;
  382.         while (size > 0) {
  383.             len = max_packet_size - 4;
  384.             if (len > size)
  385.                 len = size;
  386.             /* build fragmented packet */
  387.             s->buf[0] = 0;
  388.             s->buf[1] = 0;
  389.             s->buf[2] = count >> 8;
  390.             s->buf[3] = count;
  391.             memcpy(s->buf + 4, buf1, len);
  392.             ff_rtp_send_data(s1, s->buf, len + 4, 0);
  393.             size -= len;
  394.             buf1 += len;
  395.             count += len;
  396.         }
  397.     } else {
  398.         if (s->buf_ptr == s->buf + 4) {
  399.             /* no fragmentation possible */
  400.             s->buf[0] = 0;
  401.             s->buf[1] = 0;
  402.             s->buf[2] = 0;
  403.             s->buf[3] = 0;
  404.         }
  405.         memcpy(s->buf_ptr, buf1, size);
  406.         s->buf_ptr += size;
  407.     }
  408. }
  409.  
  410. static void rtp_send_raw(AVFormatContext *s1,
  411.                          const uint8_t *buf1, int size)
  412. {
  413.     RTPMuxContext *s = s1->priv_data;
  414.     int len, max_packet_size;
  415.  
  416.     max_packet_size = s->max_payload_size;
  417.  
  418.     while (size > 0) {
  419.         len = max_packet_size;
  420.         if (len > size)
  421.             len = size;
  422.  
  423.         s->timestamp = s->cur_timestamp;
  424.         ff_rtp_send_data(s1, buf1, len, (len == size));
  425.  
  426.         buf1 += len;
  427.         size -= len;
  428.     }
  429. }
  430.  
  431. /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
  432. static void rtp_send_mpegts_raw(AVFormatContext *s1,
  433.                                 const uint8_t *buf1, int size)
  434. {
  435.     RTPMuxContext *s = s1->priv_data;
  436.     int len, out_len;
  437.  
  438.     s->timestamp = s->cur_timestamp;
  439.     while (size >= TS_PACKET_SIZE) {
  440.         len = s->max_payload_size - (s->buf_ptr - s->buf);
  441.         if (len > size)
  442.             len = size;
  443.         memcpy(s->buf_ptr, buf1, len);
  444.         buf1 += len;
  445.         size -= len;
  446.         s->buf_ptr += len;
  447.  
  448.         out_len = s->buf_ptr - s->buf;
  449.         if (out_len >= s->max_payload_size) {
  450.             ff_rtp_send_data(s1, s->buf, out_len, 0);
  451.             s->buf_ptr = s->buf;
  452.         }
  453.     }
  454. }
  455.  
  456. static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
  457. {
  458.     RTPMuxContext *s = s1->priv_data;
  459.     AVStream *st = s1->streams[0];
  460.     int frame_duration = av_get_audio_frame_duration(st->codec, 0);
  461.     int frame_size = st->codec->block_align;
  462.     int frames = size / frame_size;
  463.  
  464.     while (frames > 0) {
  465.         if (s->num_frames > 0 &&
  466.             av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,
  467.                           s1->max_delay, AV_TIME_BASE_Q) >= 0) {
  468.             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
  469.             s->num_frames = 0;
  470.         }
  471.  
  472.         if (!s->num_frames) {
  473.             s->buf_ptr = s->buf;
  474.             s->timestamp = s->cur_timestamp;
  475.         }
  476.         memcpy(s->buf_ptr, buf, frame_size);
  477.         frames--;
  478.         s->num_frames++;
  479.         s->buf_ptr       += frame_size;
  480.         buf              += frame_size;
  481.         s->cur_timestamp += frame_duration;
  482.  
  483.         if (s->num_frames == s->max_frames_per_packet) {
  484.             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
  485.             s->num_frames = 0;
  486.         }
  487.     }
  488.     return 0;
  489. }
  490.  
  491. static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
  492. {
  493.     RTPMuxContext *s = s1->priv_data;
  494.     AVStream *st = s1->streams[0];
  495.     int rtcp_bytes;
  496.     int size= pkt->size;
  497.  
  498.     av_log(s1, AV_LOG_TRACE, "%d: write len=%d\n", pkt->stream_index, size);
  499.  
  500.     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
  501.         RTCP_TX_RATIO_DEN;
  502.     if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
  503.                             (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&
  504.         !(s->flags & FF_RTP_FLAG_SKIP_RTCP)) {
  505.         rtcp_send_sr(s1, ff_ntp_time(), 0);
  506.         s->last_octet_count = s->octet_count;
  507.         s->first_packet = 0;
  508.     }
  509.     s->cur_timestamp = s->base_timestamp + pkt->pts;
  510.  
  511.     switch(st->codec->codec_id) {
  512.     case AV_CODEC_ID_PCM_MULAW:
  513.     case AV_CODEC_ID_PCM_ALAW:
  514.     case AV_CODEC_ID_PCM_U8:
  515.     case AV_CODEC_ID_PCM_S8:
  516.         return rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);
  517.     case AV_CODEC_ID_PCM_U16BE:
  518.     case AV_CODEC_ID_PCM_U16LE:
  519.     case AV_CODEC_ID_PCM_S16BE:
  520.     case AV_CODEC_ID_PCM_S16LE:
  521.         return rtp_send_samples(s1, pkt->data, size, 16 * st->codec->channels);
  522.     case AV_CODEC_ID_ADPCM_G722:
  523.         /* The actual sample size is half a byte per sample, but since the
  524.          * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
  525.          * the correct parameter for send_samples_bits is 8 bits per stream
  526.          * clock. */
  527.         return rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);
  528.     case AV_CODEC_ID_ADPCM_G726:
  529.         return rtp_send_samples(s1, pkt->data, size,
  530.                                 st->codec->bits_per_coded_sample * st->codec->channels);
  531.     case AV_CODEC_ID_MP2:
  532.     case AV_CODEC_ID_MP3:
  533.         rtp_send_mpegaudio(s1, pkt->data, size);
  534.         break;
  535.     case AV_CODEC_ID_MPEG1VIDEO:
  536.     case AV_CODEC_ID_MPEG2VIDEO:
  537.         ff_rtp_send_mpegvideo(s1, pkt->data, size);
  538.         break;
  539.     case AV_CODEC_ID_AAC:
  540.         if (s->flags & FF_RTP_FLAG_MP4A_LATM)
  541.             ff_rtp_send_latm(s1, pkt->data, size);
  542.         else
  543.             ff_rtp_send_aac(s1, pkt->data, size);
  544.         break;
  545.     case AV_CODEC_ID_AMR_NB:
  546.     case AV_CODEC_ID_AMR_WB:
  547.         ff_rtp_send_amr(s1, pkt->data, size);
  548.         break;
  549.     case AV_CODEC_ID_MPEG2TS:
  550.         rtp_send_mpegts_raw(s1, pkt->data, size);
  551.         break;
  552.     case AV_CODEC_ID_H264:
  553.         ff_rtp_send_h264_hevc(s1, pkt->data, size);
  554.         break;
  555.     case AV_CODEC_ID_H261:
  556.         ff_rtp_send_h261(s1, pkt->data, size);
  557.         break;
  558.     case AV_CODEC_ID_H263:
  559.         if (s->flags & FF_RTP_FLAG_RFC2190) {
  560.             int mb_info_size = 0;
  561.             const uint8_t *mb_info =
  562.                 av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,
  563.                                         &mb_info_size);
  564.             ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);
  565.             break;
  566.         }
  567.         /* Fallthrough */
  568.     case AV_CODEC_ID_H263P:
  569.         ff_rtp_send_h263(s1, pkt->data, size);
  570.         break;
  571.     case AV_CODEC_ID_HEVC:
  572.         ff_rtp_send_h264_hevc(s1, pkt->data, size);
  573.         break;
  574.     case AV_CODEC_ID_VORBIS:
  575.     case AV_CODEC_ID_THEORA:
  576.         ff_rtp_send_xiph(s1, pkt->data, size);
  577.         break;
  578.     case AV_CODEC_ID_VP8:
  579.         ff_rtp_send_vp8(s1, pkt->data, size);
  580.         break;
  581.     case AV_CODEC_ID_ILBC:
  582.         rtp_send_ilbc(s1, pkt->data, size);
  583.         break;
  584.     case AV_CODEC_ID_MJPEG:
  585.         ff_rtp_send_jpeg(s1, pkt->data, size);
  586.         break;
  587.     case AV_CODEC_ID_OPUS:
  588.         if (size > s->max_payload_size) {
  589.             av_log(s1, AV_LOG_ERROR,
  590.                    "Packet size %d too large for max RTP payload size %d\n",
  591.                    size, s->max_payload_size);
  592.             return AVERROR(EINVAL);
  593.         }
  594.         /* Intentional fallthrough */
  595.     default:
  596.         /* better than nothing : send the codec raw data */
  597.         rtp_send_raw(s1, pkt->data, size);
  598.         break;
  599.     }
  600.     return 0;
  601. }
  602.  
  603. static int rtp_write_trailer(AVFormatContext *s1)
  604. {
  605.     RTPMuxContext *s = s1->priv_data;
  606.  
  607.     /* If the caller closes and recreates ->pb, this might actually
  608.      * be NULL here even if it was successfully allocated at the start. */
  609.     if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))
  610.         rtcp_send_sr(s1, ff_ntp_time(), 1);
  611.     av_freep(&s->buf);
  612.  
  613.     return 0;
  614. }
  615.  
  616. AVOutputFormat ff_rtp_muxer = {
  617.     .name              = "rtp",
  618.     .long_name         = NULL_IF_CONFIG_SMALL("RTP output"),
  619.     .priv_data_size    = sizeof(RTPMuxContext),
  620.     .audio_codec       = AV_CODEC_ID_PCM_MULAW,
  621.     .video_codec       = AV_CODEC_ID_MPEG4,
  622.     .write_header      = rtp_write_header,
  623.     .write_packet      = rtp_write_packet,
  624.     .write_trailer     = rtp_write_trailer,
  625.     .priv_class        = &rtp_muxer_class,
  626.     .flags             = AVFMT_TS_NONSTRICT,
  627. };
  628.