git.sesse.net Git - ffmpeg/blob - libavformat/sdp.c

   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 "avformat.h"
  25 #include "internal.h"
  26 #include "avc.h"
  27 #include "rtp.h"
  28
  29 #if CONFIG_RTP_MUXER
  30 #define MAX_EXTRADATA_SIZE ((INT_MAX - 10) / 2)
  31
  32 struct sdp_session_level {
  33     int sdp_version;      /**< protocol version (currently 0) */
  34     int id;               /**< session ID */
  35     int version;          /**< session version */
  36     int start_time;       /**< session start time (NTP time, in seconds),
  37                                or 0 in case of permanent session */
  38     int end_time;         /**< session end time (NTP time, in seconds),
  39                                or 0 if the session is not bounded */
  40     int ttl;              /**< TTL, in case of multicast stream */
  41     const char *user;     /**< username of the session's creator */
  42     const char *src_addr; /**< IP address of the machine from which the session was created */
  43     const char *dst_addr; /**< destination IP address (can be multicast) */
  44     const char *name;     /**< session name (can be an empty string) */
  45 };
  46
  47 static void sdp_write_address(char *buff, int size, const char *dest_addr, int ttl)
  48 {
  49     if (dest_addr) {
  50         if (ttl > 0) {
  51             av_strlcatf(buff, size, "c=IN IP4 %s/%d\r\n", dest_addr, ttl);
  52         } else {
  53             av_strlcatf(buff, size, "c=IN IP4 %s\r\n", dest_addr);
  54         }
  55     }
  56 }
  57
  58 static void sdp_write_header(char *buff, int size, struct sdp_session_level *s)
  59 {
  60     av_strlcatf(buff, size, "v=%d\r\n"
  61                             "o=- %d %d IN IP4 %s\r\n"
  62                             "s=%s\r\n",
  63                             s->sdp_version,
  64                             s->id, s->version, s->src_addr,
  65                             s->name);
  66     sdp_write_address(buff, size, s->dst_addr, s->ttl);
  67     av_strlcatf(buff, size, "t=%d %d\r\n"
  68                             "a=tool:libavformat " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\r\n",
  69                             s->start_time, s->end_time);
  70 }
  71
  72 static int sdp_get_address(char *dest_addr, int size, int *ttl, const char *url)
  73 {
  74     int port;
  75     const char *p;
  76     char proto[32];
  77
  78     url_split(proto, sizeof(proto), NULL, 0, dest_addr, size, &port, NULL, 0, url);
  79
  80     *ttl = 0;
  81
  82     if (strcmp(proto, "rtp")) {
  83         /* The url isn't for the actual rtp sessions,
  84          * don't parse out anything else than the destination.
  85          */
  86         return 0;
  87     }
  88
  89     p = strchr(url, '?');
  90     if (p) {
  91         char buff[64];
  92         int is_multicast = find_info_tag(buff, sizeof(buff), "multicast", p);
  93
  94         if (is_multicast) {
  95             if (find_info_tag(buff, sizeof(buff), "ttl", p)) {
  96                 *ttl = strtol(buff, NULL, 10);
  97             } else {
  98                 *ttl = 5;
  99             }
 100         }
 101     }
 102
 103     return port;
 104 }
 105
 106 #define MAX_PSET_SIZE 1024
 107 static char *extradata2psets(AVCodecContext *c)
 108 {
 109     char *psets, *p;
 110     const uint8_t *r;
 111     const char *pset_string = "; sprop-parameter-sets=";
 112
 113     if (c->extradata_size > MAX_EXTRADATA_SIZE) {
 114         av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
 115
 116         return NULL;
 117     }
 118
 119     psets = av_mallocz(MAX_PSET_SIZE);
 120     if (psets == NULL) {
 121         av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
 122         return NULL;
 123     }
 124     memcpy(psets, pset_string, strlen(pset_string));
 125     p = psets + strlen(pset_string);
 126     r = ff_avc_find_startcode(c->extradata, c->extradata + c->extradata_size);
 127     while (r < c->extradata + c->extradata_size) {
 128         const uint8_t *r1;
 129         uint8_t nal_type;
 130
 131         while (!*(r++));
 132         nal_type = *r & 0x1f;
 133         r1 = ff_avc_find_startcode(r, c->extradata + c->extradata_size);
 134         if (nal_type != 7 && nal_type != 8) { /* Only output SPS and PPS */
 135             r = r1;
 136             continue;
 137         }
 138         if (p != (psets + strlen(pset_string))) {
 139             *p = ',';
 140             p++;
 141         }
 142         if (av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r) == NULL) {
 143             av_log(c, AV_LOG_ERROR, "Cannot Base64-encode %td %td!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
 144             av_free(psets);
 145
 146             return NULL;
 147         }
 148         p += strlen(p);
 149         r = r1;
 150     }
 151
 152     return psets;
 153 }
 154
 155 static char *extradata2config(AVCodecContext *c)
 156 {
 157     char *config;
 158
 159     if (c->extradata_size > MAX_EXTRADATA_SIZE) {
 160         av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
 161
 162         return NULL;
 163     }
 164     config = av_malloc(10 + c->extradata_size * 2);
 165     if (config == NULL) {
 166         av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
 167         return NULL;
 168     }
 169     memcpy(config, "; config=", 9);
 170     ff_data_to_hex(config + 9, c->extradata, c->extradata_size);
 171     config[9 + c->extradata_size * 2] = 0;
 172
 173     return config;
 174 }
 175
 176 static char *sdp_write_media_attributes(char *buff, int size, AVCodecContext *c, int payload_type)
 177 {
 178     char *config = NULL;
 179
 180     switch (c->codec_id) {
 181         case CODEC_ID_H264:
 182             if (c->extradata_size) {
 183                 config = extradata2psets(c);
 184             }
 185             av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
 186                                     "a=fmtp:%d packetization-mode=1%s\r\n",
 187                                      payload_type,
 188                                      payload_type, config ? config : "");
 189             break;
 190         case CODEC_ID_H263:
 191         case CODEC_ID_H263P:
 192             av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n", payload_type);
 193             break;
 194         case CODEC_ID_MPEG4:
 195             if (c->extradata_size) {
 196                 config = extradata2config(c);
 197             }
 198             av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
 199                                     "a=fmtp:%d profile-level-id=1%s\r\n",
 200                                      payload_type,
 201                                      payload_type, config ? config : "");
 202             break;
 203         case CODEC_ID_AAC:
 204             if (c->extradata_size) {
 205                 config = extradata2config(c);
 206             } else {
 207                 /* FIXME: maybe we can forge config information based on the
 208                  *        codec parameters...
 209                  */
 210                 av_log(c, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
 211                 return NULL;
 212             }
 213             if (config == NULL) {
 214                 return NULL;
 215             }
 216             av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
 217                                     "a=fmtp:%d profile-level-id=1;"
 218                                     "mode=AAC-hbr;sizelength=13;indexlength=3;"
 219                                     "indexdeltalength=3%s\r\n",
 220                                      payload_type, c->sample_rate, c->channels,
 221                                      payload_type, config);
 222             break;
 223         case CODEC_ID_PCM_S16BE:
 224             if (payload_type >= RTP_PT_PRIVATE)
 225                 av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
 226                                          payload_type,
 227                                          c->sample_rate, c->channels);
 228             break;
 229         case CODEC_ID_PCM_MULAW:
 230             if (payload_type >= RTP_PT_PRIVATE)
 231                 av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
 232                                          payload_type,
 233                                          c->sample_rate, c->channels);
 234             break;
 235         case CODEC_ID_PCM_ALAW:
 236             if (payload_type >= RTP_PT_PRIVATE)
 237                 av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
 238                                          payload_type,
 239                                          c->sample_rate, c->channels);
 240             break;
 241         case CODEC_ID_AMR_NB:
 242             av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
 243                                     "a=fmtp:%d octet-align=1\r\n",
 244                                      payload_type, c->sample_rate, c->channels,
 245                                      payload_type);
 246             break;
 247         case CODEC_ID_AMR_WB:
 248             av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
 249                                     "a=fmtp:%d octet-align=1\r\n",
 250                                      payload_type, c->sample_rate, c->channels,
 251                                      payload_type);
 252             break;
 253         default:
 254             /* Nothing special to do here... */
 255             break;
 256     }
 257
 258     av_free(config);
 259
 260     return buff;
 261 }
 262
 263 static void sdp_write_media(char *buff, int size, AVCodecContext *c, const char *dest_addr, int port, int ttl)
 264 {
 265     const char *type;
 266     int payload_type;
 267
 268     payload_type = ff_rtp_get_payload_type(c);
 269     if (payload_type < 0) {
 270         payload_type = RTP_PT_PRIVATE + (c->codec_type == CODEC_TYPE_AUDIO);
 271     }
 272
 273     switch (c->codec_type) {
 274         case CODEC_TYPE_VIDEO   : type = "video"      ; break;
 275         case CODEC_TYPE_AUDIO   : type = "audio"      ; break;
 276         case CODEC_TYPE_SUBTITLE: type = "text"       ; break;
 277         default                 : type = "application"; break;
 278     }
 279
 280     av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
 281     sdp_write_address(buff, size, dest_addr, ttl);
 282     if (c->bit_rate) {
 283         av_strlcatf(buff, size, "b=AS:%d\r\n", c->bit_rate / 1000);
 284     }
 285
 286     sdp_write_media_attributes(buff, size, c, payload_type);
 287 }
 288
 289 int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size)
 290 {
 291     AVMetadataTag *title = av_metadata_get(ac[0]->metadata, "title", NULL, 0);
 292     struct sdp_session_level s;
 293     int i, j, port, ttl;
 294     char dst[32];
 295
 296     memset(buff, 0, size);
 297     memset(&s, 0, sizeof(struct sdp_session_level));
 298     s.user = "-";
 299     s.src_addr = "127.0.0.1";    /* FIXME: Properly set this */
 300     s.name = title ? title->value : "No Name";
 301
 302     port = 0;
 303     ttl = 0;
 304     if (n_files == 1) {
 305         port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->filename);
 306         if (port > 0) {
 307             s.dst_addr = dst;
 308             s.ttl = ttl;
 309         }
 310     }
 311     sdp_write_header(buff, size, &s);
 312
 313     dst[0] = 0;
 314     for (i = 0; i < n_files; i++) {
 315         if (n_files != 1) {
 316             port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->filename);
 317         }
 318         for (j = 0; j < ac[i]->nb_streams; j++) {
 319             sdp_write_media(buff, size,
 320                                   ac[i]->streams[j]->codec, dst[0] ? dst : NULL,
 321                                   (port > 0) ? port + j * 2 : 0, ttl);
 322             if (port <= 0) {
 323                 av_strlcatf(buff, size,
 324                                    "a=control:streamid=%d\r\n", i + j);
 325             }
 326         }
 327     }
 328
 329     return 0;
 330 }
 331 #else
 332 int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size)
 333 {
 334     return AVERROR(ENOSYS);
 335 }
 336 #endif