Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * copyright (c) 2007 Luca Abeni
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #include <string.h>
  22. #include "libavutil/avstring.h"
  23. #include "libavutil/base64.h"
  24. #include "libavutil/dict.h"
  25. #include "libavutil/parseutils.h"
  26. #include "libavutil/opt.h"
  27. #include "libavcodec/xiph.h"
  28. #include "libavcodec/mpeg4audio.h"
  29. #include "avformat.h"
  30. #include "internal.h"
  31. #include "avc.h"
  32. #include "hevc.h"
  33. #include "rtp.h"
  34. #if CONFIG_NETWORK
  35. #include "network.h"
  36. #endif
  37.  
  38. #if CONFIG_RTP_MUXER
  39. #define MAX_EXTRADATA_SIZE ((INT_MAX - 10) / 2)
  40.  
  41. struct sdp_session_level {
  42.     int sdp_version;      /**< protocol version (currently 0) */
  43.     int id;               /**< session ID */
  44.     int version;          /**< session version */
  45.     int start_time;       /**< session start time (NTP time, in seconds),
  46.                                or 0 in case of permanent session */
  47.     int end_time;         /**< session end time (NTP time, in seconds),
  48.                                or 0 if the session is not bounded */
  49.     int ttl;              /**< TTL, in case of multicast stream */
  50.     const char *user;     /**< username of the session's creator */
  51.     const char *src_addr; /**< IP address of the machine from which the session was created */
  52.     const char *src_type; /**< address type of src_addr */
  53.     const char *dst_addr; /**< destination IP address (can be multicast) */
  54.     const char *dst_type; /**< destination IP address type */
  55.     const char *name;     /**< session name (can be an empty string) */
  56. };
  57.  
  58. static void sdp_write_address(char *buff, int size, const char *dest_addr,
  59.                               const char *dest_type, int ttl)
  60. {
  61.     if (dest_addr) {
  62.         if (!dest_type)
  63.             dest_type = "IP4";
  64.         if (ttl > 0 && !strcmp(dest_type, "IP4")) {
  65.             /* The TTL should only be specified for IPv4 multicast addresses,
  66.              * not for IPv6. */
  67.             av_strlcatf(buff, size, "c=IN %s %s/%d\r\n", dest_type, dest_addr, ttl);
  68.         } else {
  69.             av_strlcatf(buff, size, "c=IN %s %s\r\n", dest_type, dest_addr);
  70.         }
  71.     }
  72. }
  73.  
  74. static void sdp_write_header(char *buff, int size, struct sdp_session_level *s)
  75. {
  76.     av_strlcatf(buff, size, "v=%d\r\n"
  77.                             "o=- %d %d IN %s %s\r\n"
  78.                             "s=%s\r\n",
  79.                             s->sdp_version,
  80.                             s->id, s->version, s->src_type, s->src_addr,
  81.                             s->name);
  82.     sdp_write_address(buff, size, s->dst_addr, s->dst_type, s->ttl);
  83.     av_strlcatf(buff, size, "t=%d %d\r\n"
  84.                             "a=tool:libavformat " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\r\n",
  85.                             s->start_time, s->end_time);
  86. }
  87.  
  88. #if CONFIG_NETWORK
  89. static int resolve_destination(char *dest_addr, int size, char *type,
  90.                                int type_size)
  91. {
  92.     struct addrinfo hints = { 0 }, *ai;
  93.     int is_multicast;
  94.  
  95.     av_strlcpy(type, "IP4", type_size);
  96.     if (!dest_addr[0])
  97.         return 0;
  98.  
  99.     /* Resolve the destination, since it must be written
  100.      * as a numeric IP address in the SDP. */
  101.  
  102.     if (getaddrinfo(dest_addr, NULL, &hints, &ai))
  103.         return 0;
  104.     getnameinfo(ai->ai_addr, ai->ai_addrlen, dest_addr, size,
  105.                 NULL, 0, NI_NUMERICHOST);
  106. #ifdef AF_INET6
  107.     if (ai->ai_family == AF_INET6)
  108.         av_strlcpy(type, "IP6", type_size);
  109. #endif
  110.     is_multicast = ff_is_multicast_address(ai->ai_addr);
  111.     freeaddrinfo(ai);
  112.     return is_multicast;
  113. }
  114. #else
  115. static int resolve_destination(char *dest_addr, int size, char *type,
  116.                                int type_size)
  117. {
  118.     return 0;
  119. }
  120. #endif
  121.  
  122. static int sdp_get_address(char *dest_addr, int size, int *ttl, const char *url)
  123. {
  124.     int port;
  125.     const char *p;
  126.     char proto[32];
  127.  
  128.     av_url_split(proto, sizeof(proto), NULL, 0, dest_addr, size, &port, NULL, 0, url);
  129.  
  130.     *ttl = 0;
  131.  
  132.     if (strcmp(proto, "rtp") && strcmp(proto, "srtp")) {
  133.         /* The url isn't for the actual rtp sessions,
  134.          * don't parse out anything else than the destination.
  135.          */
  136.         return 0;
  137.     }
  138.  
  139.     p = strchr(url, '?');
  140.     if (p) {
  141.         char buff[64];
  142.  
  143.         if (av_find_info_tag(buff, sizeof(buff), "ttl", p)) {
  144.             *ttl = strtol(buff, NULL, 10);
  145.         } else {
  146.             *ttl = 5;
  147.         }
  148.     }
  149.  
  150.     return port;
  151. }
  152.  
  153. #define MAX_PSET_SIZE 1024
  154. static char *extradata2psets(AVCodecContext *c)
  155. {
  156.     char *psets, *p;
  157.     const uint8_t *r;
  158.     static const char pset_string[] = "; sprop-parameter-sets=";
  159.     static const char profile_string[] = "; profile-level-id=";
  160.     uint8_t *extradata = c->extradata;
  161.     int extradata_size = c->extradata_size;
  162.     uint8_t *tmpbuf = NULL;
  163.     const uint8_t *sps = NULL, *sps_end;
  164.  
  165.     if (c->extradata_size > MAX_EXTRADATA_SIZE) {
  166.         av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
  167.  
  168.         return NULL;
  169.     }
  170.     if (c->extradata[0] == 1) {
  171.         if (ff_avc_write_annexb_extradata(c->extradata, &extradata,
  172.                                           &extradata_size))
  173.             return NULL;
  174.         tmpbuf = extradata;
  175.     }
  176.  
  177.     psets = av_mallocz(MAX_PSET_SIZE);
  178.     if (!psets) {
  179.         av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
  180.         av_free(tmpbuf);
  181.         return NULL;
  182.     }
  183.     memcpy(psets, pset_string, strlen(pset_string));
  184.     p = psets + strlen(pset_string);
  185.     r = ff_avc_find_startcode(extradata, extradata + extradata_size);
  186.     while (r < extradata + extradata_size) {
  187.         const uint8_t *r1;
  188.         uint8_t nal_type;
  189.  
  190.         while (!*(r++));
  191.         nal_type = *r & 0x1f;
  192.         r1 = ff_avc_find_startcode(r, extradata + extradata_size);
  193.         if (nal_type != 7 && nal_type != 8) { /* Only output SPS and PPS */
  194.             r = r1;
  195.             continue;
  196.         }
  197.         if (p != (psets + strlen(pset_string))) {
  198.             *p = ',';
  199.             p++;
  200.         }
  201.         if (!sps) {
  202.             sps = r;
  203.             sps_end = r1;
  204.         }
  205.         if (!av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r)) {
  206.             av_log(c, AV_LOG_ERROR, "Cannot Base64-encode %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
  207.             av_free(psets);
  208.             av_free(tmpbuf);
  209.  
  210.             return NULL;
  211.         }
  212.         p += strlen(p);
  213.         r = r1;
  214.     }
  215.     if (sps && sps_end - sps >= 4) {
  216.         memcpy(p, profile_string, strlen(profile_string));
  217.         p += strlen(p);
  218.         ff_data_to_hex(p, sps + 1, 3, 0);
  219.         p[6] = '\0';
  220.     }
  221.     av_free(tmpbuf);
  222.  
  223.     return psets;
  224. }
  225.  
  226. static char *extradata2psets_hevc(AVCodecContext *c)
  227. {
  228.     char *psets;
  229.     uint8_t *extradata = c->extradata;
  230.     int extradata_size = c->extradata_size;
  231.     uint8_t *tmpbuf = NULL;
  232.     int ps_pos[3] = { 0 };
  233.     static const char * const ps_names[3] = { "vps", "sps", "pps" };
  234.     int num_arrays, num_nalus;
  235.     int pos, i, j;
  236.  
  237.     // Convert to hvcc format. Since we need to group multiple NALUs of
  238.     // the same type, and we might need to convert from one format to the
  239.     // other anyway, we get away with a little less work by using the hvcc
  240.     // format.
  241.     if (c->extradata[0] != 1) {
  242.         AVIOContext *pb;
  243.         if (avio_open_dyn_buf(&pb) < 0)
  244.             return NULL;
  245.         if (ff_isom_write_hvcc(pb, c->extradata, c->extradata_size, 0) < 0) {
  246.             avio_close_dyn_buf(pb, &tmpbuf);
  247.             goto err;
  248.         }
  249.         extradata_size = avio_close_dyn_buf(pb, &extradata);
  250.         tmpbuf = extradata;
  251.     }
  252.  
  253.     if (extradata_size < 23)
  254.         goto err;
  255.  
  256.     num_arrays = extradata[22];
  257.     pos = 23;
  258.     for (i = 0; i < num_arrays; i++) {
  259.         int num_nalus, nalu_type;
  260.         if (pos + 3 > extradata_size)
  261.             goto err;
  262.         nalu_type = extradata[pos] & 0x3f;
  263.         // Not including libavcodec/hevc.h to avoid confusion between
  264.         // NAL_* with the same name for both H264 and HEVC.
  265.         if (nalu_type == 32) // VPS
  266.             ps_pos[0] = pos;
  267.         else if (nalu_type == 33) // SPS
  268.             ps_pos[1] = pos;
  269.         else if (nalu_type == 34) // PPS
  270.             ps_pos[2] = pos;
  271.         num_nalus = AV_RB16(&extradata[pos + 1]);
  272.         pos += 3;
  273.         for (j = 0; j < num_nalus; j++) {
  274.             int len;
  275.             if (pos + 2 > extradata_size)
  276.                 goto err;
  277.             len = AV_RB16(&extradata[pos]);
  278.             pos += 2;
  279.             if (pos + len > extradata_size)
  280.                 goto err;
  281.             pos += len;
  282.         }
  283.     }
  284.     if (!ps_pos[0] || !ps_pos[1] || !ps_pos[2])
  285.         goto err;
  286.  
  287.     psets = av_mallocz(MAX_PSET_SIZE);
  288.     if (!psets)
  289.         goto err;
  290.     psets[0] = '\0';
  291.  
  292.     for (i = 0; i < 3; i++) {
  293.         pos = ps_pos[i];
  294.  
  295.         if (i > 0)
  296.             av_strlcat(psets, "; ", MAX_PSET_SIZE);
  297.         av_strlcatf(psets, MAX_PSET_SIZE, "sprop-%s=", ps_names[i]);
  298.  
  299.         // Skipping boundary checks in the input here; we've already traversed
  300.         // the whole hvcc structure above without issues
  301.         num_nalus = AV_RB16(&extradata[pos + 1]);
  302.         pos += 3;
  303.         for (j = 0; j < num_nalus; j++) {
  304.             int len = AV_RB16(&extradata[pos]);
  305.             int strpos;
  306.             pos += 2;
  307.             if (j > 0)
  308.                 av_strlcat(psets, ",", MAX_PSET_SIZE);
  309.             strpos = strlen(psets);
  310.             if (!av_base64_encode(psets + strpos, MAX_PSET_SIZE - strpos,
  311.                                   &extradata[pos], len)) {
  312.                 av_free(psets);
  313.                 goto err;
  314.             }
  315.             pos += len;
  316.         }
  317.     }
  318.     av_free(tmpbuf);
  319.  
  320.     return psets;
  321.  
  322. err:
  323.     av_free(tmpbuf);
  324.     return NULL;
  325. }
  326.  
  327. static char *extradata2config(AVCodecContext *c)
  328. {
  329.     char *config;
  330.  
  331.     if (c->extradata_size > MAX_EXTRADATA_SIZE) {
  332.         av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
  333.  
  334.         return NULL;
  335.     }
  336.     config = av_malloc(10 + c->extradata_size * 2);
  337.     if (!config) {
  338.         av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
  339.         return NULL;
  340.     }
  341.     memcpy(config, "; config=", 9);
  342.     ff_data_to_hex(config + 9, c->extradata, c->extradata_size, 0);
  343.     config[9 + c->extradata_size * 2] = 0;
  344.  
  345.     return config;
  346. }
  347.  
  348. static char *xiph_extradata2config(AVCodecContext *c)
  349. {
  350.     char *config, *encoded_config;
  351.     const uint8_t *header_start[3];
  352.     int headers_len, header_len[3], config_len;
  353.     int first_header_size;
  354.  
  355.     switch (c->codec_id) {
  356.     case AV_CODEC_ID_THEORA:
  357.         first_header_size = 42;
  358.         break;
  359.     case AV_CODEC_ID_VORBIS:
  360.         first_header_size = 30;
  361.         break;
  362.     default:
  363.         av_log(c, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
  364.         return NULL;
  365.     }
  366.  
  367.     if (avpriv_split_xiph_headers(c->extradata, c->extradata_size,
  368.                               first_header_size, header_start,
  369.                               header_len) < 0) {
  370.         av_log(c, AV_LOG_ERROR, "Extradata corrupt.\n");
  371.         return NULL;
  372.     }
  373.  
  374.     headers_len = header_len[0] + header_len[2];
  375.     config_len = 4 +          // count
  376.                  3 +          // ident
  377.                  2 +          // packet size
  378.                  1 +          // header count
  379.                  2 +          // header size
  380.                  headers_len; // and the rest
  381.  
  382.     config = av_malloc(config_len);
  383.     if (!config)
  384.         goto xiph_fail;
  385.  
  386.     encoded_config = av_malloc(AV_BASE64_SIZE(config_len));
  387.     if (!encoded_config) {
  388.         av_free(config);
  389.         goto xiph_fail;
  390.     }
  391.  
  392.     config[0] = config[1] = config[2] = 0;
  393.     config[3] = 1;
  394.     config[4] = (RTP_XIPH_IDENT >> 16) & 0xff;
  395.     config[5] = (RTP_XIPH_IDENT >>  8) & 0xff;
  396.     config[6] = (RTP_XIPH_IDENT      ) & 0xff;
  397.     config[7] = (headers_len >> 8) & 0xff;
  398.     config[8] = headers_len & 0xff;
  399.     config[9] = 2;
  400.     config[10] = header_len[0];
  401.     config[11] = 0; // size of comment header; nonexistent
  402.     memcpy(config + 12, header_start[0], header_len[0]);
  403.     memcpy(config + 12 + header_len[0], header_start[2], header_len[2]);
  404.  
  405.     av_base64_encode(encoded_config, AV_BASE64_SIZE(config_len),
  406.                      config, config_len);
  407.     av_free(config);
  408.  
  409.     return encoded_config;
  410.  
  411. xiph_fail:
  412.     av_log(c, AV_LOG_ERROR,
  413.            "Not enough memory for configuration string\n");
  414.     return NULL;
  415. }
  416.  
  417. static int latm_context2profilelevel(AVCodecContext *c)
  418. {
  419.     /* MP4A-LATM
  420.      * The RTP payload format specification is described in RFC 3016
  421.      * The encoding specifications are provided in ISO/IEC 14496-3 */
  422.  
  423.     int profile_level = 0x2B;
  424.  
  425.     /* TODO: AAC Profile only supports AAC LC Object Type.
  426.      * Different Object Types should implement different Profile Levels */
  427.  
  428.     if (c->sample_rate <= 24000) {
  429.         if (c->channels <= 2)
  430.             profile_level = 0x28; // AAC Profile, Level 1
  431.     } else if (c->sample_rate <= 48000) {
  432.         if (c->channels <= 2) {
  433.             profile_level = 0x29; // AAC Profile, Level 2
  434.         } else if (c->channels <= 5) {
  435.             profile_level = 0x2A; // AAC Profile, Level 4
  436.         }
  437.     } else if (c->sample_rate <= 96000) {
  438.         if (c->channels <= 5) {
  439.             profile_level = 0x2B; // AAC Profile, Level 5
  440.         }
  441.     }
  442.  
  443.     return profile_level;
  444. }
  445.  
  446. static char *latm_context2config(AVCodecContext *c)
  447. {
  448.     /* MP4A-LATM
  449.      * The RTP payload format specification is described in RFC 3016
  450.      * The encoding specifications are provided in ISO/IEC 14496-3 */
  451.  
  452.     uint8_t config_byte[6];
  453.     int rate_index;
  454.     char *config;
  455.  
  456.     for (rate_index = 0; rate_index < 16; rate_index++)
  457.         if (avpriv_mpeg4audio_sample_rates[rate_index] == c->sample_rate)
  458.             break;
  459.     if (rate_index == 16) {
  460.         av_log(c, AV_LOG_ERROR, "Unsupported sample rate\n");
  461.         return NULL;
  462.     }
  463.  
  464.     config_byte[0] = 0x40;
  465.     config_byte[1] = 0;
  466.     config_byte[2] = 0x20 | rate_index;
  467.     config_byte[3] = c->channels << 4;
  468.     config_byte[4] = 0x3f;
  469.     config_byte[5] = 0xc0;
  470.  
  471.     config = av_malloc(6*2+1);
  472.     if (!config) {
  473.         av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
  474.         return NULL;
  475.     }
  476.     ff_data_to_hex(config, config_byte, 6, 1);
  477.     config[12] = 0;
  478.  
  479.     return config;
  480. }
  481.  
  482. static char *sdp_write_media_attributes(char *buff, int size, AVCodecContext *c, int payload_type, AVFormatContext *fmt)
  483. {
  484.     char *config = NULL;
  485.  
  486.     switch (c->codec_id) {
  487.         case AV_CODEC_ID_H264: {
  488.             int mode = 1;
  489.             if (fmt && fmt->oformat && fmt->oformat->priv_class &&
  490.                 av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
  491.                 mode = 0;
  492.             if (c->extradata_size) {
  493.                 config = extradata2psets(c);
  494.             }
  495.             av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
  496.                                     "a=fmtp:%d packetization-mode=%d%s\r\n",
  497.                                      payload_type,
  498.                                      payload_type, mode, config ? config : "");
  499.             break;
  500.         }
  501.         case AV_CODEC_ID_H261:
  502.         {
  503.             const char *pic_fmt = NULL;
  504.             /* only QCIF and CIF are specified as supported in RFC 4587 */
  505.             if (c->width == 176 && c->height == 144)
  506.                 pic_fmt = "QCIF=1";
  507.             else if (c->width == 352 && c->height == 288)
  508.                 pic_fmt = "CIF=1";
  509.             if (payload_type >= RTP_PT_PRIVATE)
  510.                 av_strlcatf(buff, size, "a=rtpmap:%d H261/90000\r\n", payload_type);
  511.             if (pic_fmt)
  512.                 av_strlcatf(buff, size, "a=fmtp:%d %s\r\n", payload_type, pic_fmt);
  513.             break;
  514.         }
  515.         case AV_CODEC_ID_H263:
  516.         case AV_CODEC_ID_H263P:
  517.             /* a=framesize is required by 3GPP TS 26.234 (PSS). It
  518.              * actually specifies the maximum video size, but we only know
  519.              * the current size. This is required for playback on Android
  520.              * stagefright and on Samsung bada. */
  521.             if (!fmt || !fmt->oformat->priv_class ||
  522.                 !av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") ||
  523.                 c->codec_id == AV_CODEC_ID_H263P)
  524.             av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
  525.                                     "a=framesize:%d %d-%d\r\n",
  526.                                     payload_type,
  527.                                     payload_type, c->width, c->height);
  528.             break;
  529.         case AV_CODEC_ID_HEVC:
  530.             if (c->extradata_size)
  531.                 config = extradata2psets_hevc(c);
  532.             av_strlcatf(buff, size, "a=rtpmap:%d H265/90000\r\n", payload_type);
  533.             if (config)
  534.                 av_strlcatf(buff, size, "a=fmtp:%d %s\r\n",
  535.                                          payload_type, config);
  536.             break;
  537.         case AV_CODEC_ID_MPEG4:
  538.             if (c->extradata_size) {
  539.                 config = extradata2config(c);
  540.             }
  541.             av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
  542.                                     "a=fmtp:%d profile-level-id=1%s\r\n",
  543.                                      payload_type,
  544.                                      payload_type, config ? config : "");
  545.             break;
  546.         case AV_CODEC_ID_AAC:
  547.             if (fmt && fmt->oformat && fmt->oformat->priv_class &&
  548.                 av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
  549.                 config = latm_context2config(c);
  550.                 if (!config)
  551.                     return NULL;
  552.                 av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
  553.                                         "a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
  554.                                          payload_type, c->sample_rate, c->channels,
  555.                                          payload_type, latm_context2profilelevel(c), config);
  556.             } else {
  557.                 if (c->extradata_size) {
  558.                     config = extradata2config(c);
  559.                 } else {
  560.                     /* FIXME: maybe we can forge config information based on the
  561.                      *        codec parameters...
  562.                      */
  563.                     av_log(c, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
  564.                     return NULL;
  565.                 }
  566.                 if (!config) {
  567.                     return NULL;
  568.                 }
  569.                 av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
  570.                                         "a=fmtp:%d profile-level-id=1;"
  571.                                         "mode=AAC-hbr;sizelength=13;indexlength=3;"
  572.                                         "indexdeltalength=3%s\r\n",
  573.                                          payload_type, c->sample_rate, c->channels,
  574.                                          payload_type, config);
  575.             }
  576.             break;
  577.         case AV_CODEC_ID_PCM_S16BE:
  578.             if (payload_type >= RTP_PT_PRIVATE)
  579.                 av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
  580.                                          payload_type,
  581.                                          c->sample_rate, c->channels);
  582.             break;
  583.         case AV_CODEC_ID_PCM_MULAW:
  584.             if (payload_type >= RTP_PT_PRIVATE)
  585.                 av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
  586.                                          payload_type,
  587.                                          c->sample_rate, c->channels);
  588.             break;
  589.         case AV_CODEC_ID_PCM_ALAW:
  590.             if (payload_type >= RTP_PT_PRIVATE)
  591.                 av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
  592.                                          payload_type,
  593.                                          c->sample_rate, c->channels);
  594.             break;
  595.         case AV_CODEC_ID_AMR_NB:
  596.             av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
  597.                                     "a=fmtp:%d octet-align=1\r\n",
  598.                                      payload_type, c->sample_rate, c->channels,
  599.                                      payload_type);
  600.             break;
  601.         case AV_CODEC_ID_AMR_WB:
  602.             av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
  603.                                     "a=fmtp:%d octet-align=1\r\n",
  604.                                      payload_type, c->sample_rate, c->channels,
  605.                                      payload_type);
  606.             break;
  607.         case AV_CODEC_ID_VORBIS:
  608.             if (c->extradata_size)
  609.                 config = xiph_extradata2config(c);
  610.             else
  611.                 av_log(c, AV_LOG_ERROR, "Vorbis configuration info missing\n");
  612.             if (!config)
  613.                 return NULL;
  614.  
  615.             av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
  616.                                     "a=fmtp:%d configuration=%s\r\n",
  617.                                     payload_type, c->sample_rate, c->channels,
  618.                                     payload_type, config);
  619.             break;
  620.         case AV_CODEC_ID_THEORA: {
  621.             const char *pix_fmt;
  622.             switch (c->pix_fmt) {
  623.             case AV_PIX_FMT_YUV420P:
  624.                 pix_fmt = "YCbCr-4:2:0";
  625.                 break;
  626.             case AV_PIX_FMT_YUV422P:
  627.                 pix_fmt = "YCbCr-4:2:2";
  628.                 break;
  629.             case AV_PIX_FMT_YUV444P:
  630.                 pix_fmt = "YCbCr-4:4:4";
  631.                 break;
  632.             default:
  633.                 av_log(c, AV_LOG_ERROR, "Unsupported pixel format.\n");
  634.                 return NULL;
  635.             }
  636.  
  637.             if (c->extradata_size)
  638.                 config = xiph_extradata2config(c);
  639.             else
  640.                 av_log(c, AV_LOG_ERROR, "Theora configuation info missing\n");
  641.             if (!config)
  642.                 return NULL;
  643.  
  644.             av_strlcatf(buff, size, "a=rtpmap:%d theora/90000\r\n"
  645.                                     "a=fmtp:%d delivery-method=inline; "
  646.                                     "width=%d; height=%d; sampling=%s; "
  647.                                     "configuration=%s\r\n",
  648.                                     payload_type, payload_type,
  649.                                     c->width, c->height, pix_fmt, config);
  650.             break;
  651.         }
  652.         case AV_CODEC_ID_VP8:
  653.             av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
  654.                                      payload_type);
  655.             break;
  656.         case AV_CODEC_ID_MJPEG:
  657.             if (payload_type >= RTP_PT_PRIVATE)
  658.                 av_strlcatf(buff, size, "a=rtpmap:%d JPEG/90000\r\n",
  659.                                          payload_type);
  660.             break;
  661.         case AV_CODEC_ID_ADPCM_G722:
  662.             if (payload_type >= RTP_PT_PRIVATE)
  663.                 av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
  664.                                          payload_type,
  665.                                          8000, c->channels);
  666.             break;
  667.         case AV_CODEC_ID_ADPCM_G726: {
  668.             if (payload_type >= RTP_PT_PRIVATE)
  669.                 av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
  670.                                          payload_type,
  671.                                          c->bits_per_coded_sample*8,
  672.                                          c->sample_rate);
  673.             break;
  674.         }
  675.         case AV_CODEC_ID_ILBC:
  676.             av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
  677.                                     "a=fmtp:%d mode=%d\r\n",
  678.                                      payload_type, c->sample_rate,
  679.                                      payload_type, c->block_align == 38 ? 20 : 30);
  680.             break;
  681.         case AV_CODEC_ID_SPEEX:
  682.             av_strlcatf(buff, size, "a=rtpmap:%d speex/%d\r\n",
  683.                                      payload_type, c->sample_rate);
  684.             if (c->codec) {
  685.                 const char *mode;
  686.                 uint64_t vad_option;
  687.  
  688.                 if (c->flags & AV_CODEC_FLAG_QSCALE)
  689.                       mode = "on";
  690.                 else if (!av_opt_get_int(c, "vad", AV_OPT_FLAG_ENCODING_PARAM, &vad_option) && vad_option)
  691.                       mode = "vad";
  692.                 else
  693.                       mode = "off";
  694.  
  695.                 av_strlcatf(buff, size, "a=fmtp:%d vbr=%s\r\n",
  696.                                         payload_type, mode);
  697.             }
  698.             break;
  699.         case AV_CODEC_ID_OPUS:
  700.             /* The opus RTP draft says that all opus streams MUST be declared
  701.                as stereo, to avoid negotiation failures. The actual number of
  702.                channels can change on a packet-by-packet basis. The number of
  703.                channels a receiver prefers to receive or a sender plans to send
  704.                can be declared via fmtp parameters (both default to mono), but
  705.                receivers MUST be able to receive and process stereo packets. */
  706.             av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
  707.                                      payload_type);
  708.             if (c->channels == 2) {
  709.                 av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo:1\r\n",
  710.                                          payload_type);
  711.             }
  712.             break;
  713.         default:
  714.             /* Nothing special to do here... */
  715.             break;
  716.     }
  717.  
  718.     av_free(config);
  719.  
  720.     return buff;
  721. }
  722.  
  723. void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
  724.                         const char *dest_addr, const char *dest_type,
  725.                         int port, int ttl, AVFormatContext *fmt)
  726. {
  727.     AVCodecContext *c = st->codec;
  728.     const char *type;
  729.     int payload_type;
  730.  
  731.     payload_type = ff_rtp_get_payload_type(fmt, c, idx);
  732.  
  733.     switch (c->codec_type) {
  734.         case AVMEDIA_TYPE_VIDEO   : type = "video"      ; break;
  735.         case AVMEDIA_TYPE_AUDIO   : type = "audio"      ; break;
  736.         case AVMEDIA_TYPE_SUBTITLE: type = "text"       ; break;
  737.         default                 : type = "application"; break;
  738.     }
  739.  
  740.     av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
  741.     sdp_write_address(buff, size, dest_addr, dest_type, ttl);
  742.     if (c->bit_rate) {
  743.         av_strlcatf(buff, size, "b=AS:%d\r\n", c->bit_rate / 1000);
  744.     }
  745.  
  746.     sdp_write_media_attributes(buff, size, c, payload_type, fmt);
  747. }
  748.  
  749. int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
  750. {
  751.     AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
  752.     struct sdp_session_level s = { 0 };
  753.     int i, j, port, ttl, is_multicast, index = 0;
  754.     char dst[32], dst_type[5];
  755.  
  756.     memset(buf, 0, size);
  757.     s.user = "-";
  758.     s.src_addr = "127.0.0.1";    /* FIXME: Properly set this */
  759.     s.src_type = "IP4";
  760.     s.name = title ? title->value : "No Name";
  761.  
  762.     port = 0;
  763.     ttl = 0;
  764.     if (n_files == 1) {
  765.         port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->filename);
  766.         is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
  767.                                            sizeof(dst_type));
  768.         if (!is_multicast)
  769.             ttl = 0;
  770.         if (dst[0]) {
  771.             s.dst_addr = dst;
  772.             s.dst_type = dst_type;
  773.             s.ttl = ttl;
  774.             if (!strcmp(dst_type, "IP6")) {
  775.                 s.src_addr = "::1";
  776.                 s.src_type = "IP6";
  777.             }
  778.         }
  779.     }
  780.     sdp_write_header(buf, size, &s);
  781.  
  782.     dst[0] = 0;
  783.     for (i = 0; i < n_files; i++) {
  784.         if (n_files != 1) {
  785.             port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->filename);
  786.             is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
  787.                                                sizeof(dst_type));
  788.             if (!is_multicast)
  789.                 ttl = 0;
  790.         }
  791.         for (j = 0; j < ac[i]->nb_streams; j++) {
  792.             ff_sdp_write_media(buf, size, ac[i]->streams[j], index++,
  793.                                dst[0] ? dst : NULL, dst_type,
  794.                                (port > 0) ? port + j * 2 : 0,
  795.                                ttl, ac[i]);
  796.             if (port <= 0) {
  797.                 av_strlcatf(buf, size,
  798.                                    "a=control:streamid=%d\r\n", i + j);
  799.             }
  800.             if (ac[i]->pb && ac[i]->pb->av_class) {
  801.                 uint8_t *crypto_suite = NULL, *crypto_params = NULL;
  802.                 av_opt_get(ac[i]->pb, "srtp_out_suite",  AV_OPT_SEARCH_CHILDREN,
  803.                            &crypto_suite);
  804.                 av_opt_get(ac[i]->pb, "srtp_out_params", AV_OPT_SEARCH_CHILDREN,
  805.                            &crypto_params);
  806.                 if (crypto_suite && crypto_suite[0])
  807.                     av_strlcatf(buf, size,
  808.                                 "a=crypto:1 %s inline:%s\r\n",
  809.                                 crypto_suite, crypto_params);
  810.                 av_free(crypto_suite);
  811.                 av_free(crypto_params);
  812.             }
  813.         }
  814.     }
  815.  
  816.     return 0;
  817. }
  818. #else
  819. int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
  820. {
  821.     return AVERROR(ENOSYS);
  822. }
  823.  
  824. void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
  825.                         const char *dest_addr, const char *dest_type,
  826.                         int port, int ttl, AVFormatContext *fmt)
  827. {
  828. }
  829. #endif
  830.