sdp.c
Go to the documentation of this file.
1 /*
2  * copyright (c) 2007 Luca Abeni
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; 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 "rtp.h"
33 #if CONFIG_NETWORK
34 #include "network.h"
35 #endif
36 
37 #if CONFIG_RTP_MUXER
38 #define MAX_EXTRADATA_SIZE ((INT_MAX - 10) / 2)
39 
40 struct sdp_session_level {
41  int sdp_version;
42  int id;
43  int version;
44  int start_time;
46  int end_time;
48  int ttl;
49  const char *user;
50  const char *src_addr;
51  const char *src_type;
52  const char *dst_addr;
53  const char *dst_type;
54  const char *name;
55 };
56 
57 static void sdp_write_address(char *buff, int size, const char *dest_addr,
58  const char *dest_type, int ttl)
59 {
60  if (dest_addr) {
61  if (!dest_type)
62  dest_type = "IP4";
63  if (ttl > 0 && !strcmp(dest_type, "IP4")) {
64  /* The TTL should only be specified for IPv4 multicast addresses,
65  * not for IPv6. */
66  av_strlcatf(buff, size, "c=IN %s %s/%d\r\n", dest_type, dest_addr, ttl);
67  } else {
68  av_strlcatf(buff, size, "c=IN %s %s\r\n", dest_type, dest_addr);
69  }
70  }
71 }
72 
73 static void sdp_write_header(char *buff, int size, struct sdp_session_level *s)
74 {
75  av_strlcatf(buff, size, "v=%d\r\n"
76  "o=- %d %d IN %s %s\r\n"
77  "s=%s\r\n",
78  s->sdp_version,
79  s->id, s->version, s->src_type, s->src_addr,
80  s->name);
81  sdp_write_address(buff, size, s->dst_addr, s->dst_type, s->ttl);
82  av_strlcatf(buff, size, "t=%d %d\r\n"
83  "a=tool:libavformat " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\r\n",
84  s->start_time, s->end_time);
85 }
86 
87 #if CONFIG_NETWORK
88 static int resolve_destination(char *dest_addr, int size, char *type,
89  int type_size)
90 {
91  struct addrinfo hints, *ai;
92  int is_multicast;
93 
94  av_strlcpy(type, "IP4", type_size);
95  if (!dest_addr[0])
96  return 0;
97 
98  /* Resolve the destination, since it must be written
99  * as a numeric IP address in the SDP. */
100 
101  memset(&hints, 0, sizeof(hints));
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")) {
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  const char *pset_string = "; sprop-parameter-sets=";
159  uint8_t *orig_extradata = NULL;
160  int orig_extradata_size = 0;
161 
162  if (c->extradata_size > MAX_EXTRADATA_SIZE) {
163  av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
164 
165  return NULL;
166  }
167  if (c->extradata[0] == 1) {
168  uint8_t *dummy_p;
169  int dummy_int;
170  AVBitStreamFilterContext *bsfc= av_bitstream_filter_init("h264_mp4toannexb");
171 
172  if (!bsfc) {
173  av_log(c, AV_LOG_ERROR, "Cannot open the h264_mp4toannexb BSF!\n");
174 
175  return NULL;
176  }
177 
178  orig_extradata_size = c->extradata_size;
179  orig_extradata = av_mallocz(orig_extradata_size +
181  if (!orig_extradata) {
183  return NULL;
184  }
185  memcpy(orig_extradata, c->extradata, orig_extradata_size);
186  av_bitstream_filter_filter(bsfc, c, NULL, &dummy_p, &dummy_int, NULL, 0, 0);
188  }
189 
190  psets = av_mallocz(MAX_PSET_SIZE);
191  if (psets == NULL) {
192  av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
193  av_free(orig_extradata);
194  return NULL;
195  }
196  memcpy(psets, pset_string, strlen(pset_string));
197  p = psets + strlen(pset_string);
199  while (r < c->extradata + c->extradata_size) {
200  const uint8_t *r1;
201  uint8_t nal_type;
202 
203  while (!*(r++));
204  nal_type = *r & 0x1f;
206  if (nal_type != 7 && nal_type != 8) { /* Only output SPS and PPS */
207  r = r1;
208  continue;
209  }
210  if (p != (psets + strlen(pset_string))) {
211  *p = ',';
212  p++;
213  }
214  if (av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r) == NULL) {
215  av_log(c, AV_LOG_ERROR, "Cannot Base64-encode %td %td!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
216  av_free(psets);
217 
218  return NULL;
219  }
220  p += strlen(p);
221  r = r1;
222  }
223  if (orig_extradata) {
224  av_free(c->extradata);
225  c->extradata = orig_extradata;
226  c->extradata_size = orig_extradata_size;
227  }
228 
229  return psets;
230 }
231 
232 static char *extradata2config(AVCodecContext *c)
233 {
234  char *config;
235 
236  if (c->extradata_size > MAX_EXTRADATA_SIZE) {
237  av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
238 
239  return NULL;
240  }
241  config = av_malloc(10 + c->extradata_size * 2);
242  if (config == NULL) {
243  av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
244  return NULL;
245  }
246  memcpy(config, "; config=", 9);
247  ff_data_to_hex(config + 9, c->extradata, c->extradata_size, 0);
248  config[9 + c->extradata_size * 2] = 0;
249 
250  return config;
251 }
252 
253 static char *xiph_extradata2config(AVCodecContext *c)
254 {
255  char *config, *encoded_config;
256  uint8_t *header_start[3];
257  int headers_len, header_len[3], config_len;
258  int first_header_size;
259 
260  switch (c->codec_id) {
261  case CODEC_ID_THEORA:
262  first_header_size = 42;
263  break;
264  case CODEC_ID_VORBIS:
265  first_header_size = 30;
266  break;
267  default:
268  av_log(c, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
269  return NULL;
270  }
271 
273  first_header_size, header_start,
274  header_len) < 0) {
275  av_log(c, AV_LOG_ERROR, "Extradata corrupt.\n");
276  return NULL;
277  }
278 
279  headers_len = header_len[0] + header_len[2];
280  config_len = 4 + // count
281  3 + // ident
282  2 + // packet size
283  1 + // header count
284  2 + // header size
285  headers_len; // and the rest
286 
287  config = av_malloc(config_len);
288  if (!config)
289  goto xiph_fail;
290 
291  encoded_config = av_malloc(AV_BASE64_SIZE(config_len));
292  if (!encoded_config) {
293  av_free(config);
294  goto xiph_fail;
295  }
296 
297  config[0] = config[1] = config[2] = 0;
298  config[3] = 1;
299  config[4] = (RTP_XIPH_IDENT >> 16) & 0xff;
300  config[5] = (RTP_XIPH_IDENT >> 8) & 0xff;
301  config[6] = (RTP_XIPH_IDENT ) & 0xff;
302  config[7] = (headers_len >> 8) & 0xff;
303  config[8] = headers_len & 0xff;
304  config[9] = 2;
305  config[10] = header_len[0];
306  config[11] = 0; // size of comment header; nonexistent
307  memcpy(config + 12, header_start[0], header_len[0]);
308  memcpy(config + 12 + header_len[0], header_start[2], header_len[2]);
309 
310  av_base64_encode(encoded_config, AV_BASE64_SIZE(config_len),
311  config, config_len);
312  av_free(config);
313 
314  return encoded_config;
315 
316 xiph_fail:
317  av_log(c, AV_LOG_ERROR,
318  "Not enough memory for configuration string\n");
319  return NULL;
320 }
321 
322 static int latm_context2profilelevel(AVCodecContext *c)
323 {
324  /* MP4A-LATM
325  * The RTP payload format specification is described in RFC 3016
326  * The encoding specifications are provided in ISO/IEC 14496-3 */
327 
328  int profile_level = 0x2B;
329 
330  /* TODO: AAC Profile only supports AAC LC Object Type.
331  * Different Object Types should implement different Profile Levels */
332 
333  if (c->sample_rate <= 24000) {
334  if (c->channels <= 2)
335  profile_level = 0x28; // AAC Profile, Level 1
336  } else if (c->sample_rate <= 48000) {
337  if (c->channels <= 2) {
338  profile_level = 0x29; // AAC Profile, Level 2
339  } else if (c->channels <= 5) {
340  profile_level = 0x2A; // AAC Profile, Level 4
341  }
342  } else if (c->sample_rate <= 96000) {
343  if (c->channels <= 5) {
344  profile_level = 0x2B; // AAC Profile, Level 5
345  }
346  }
347 
348  return profile_level;
349 }
350 
351 static char *latm_context2config(AVCodecContext *c)
352 {
353  /* MP4A-LATM
354  * The RTP payload format specification is described in RFC 3016
355  * The encoding specifications are provided in ISO/IEC 14496-3 */
356 
357  uint8_t config_byte[6];
358  int rate_index;
359  char *config;
360 
361  for (rate_index = 0; rate_index < 16; rate_index++)
362  if (avpriv_mpeg4audio_sample_rates[rate_index] == c->sample_rate)
363  break;
364  if (rate_index == 16) {
365  av_log(c, AV_LOG_ERROR, "Unsupported sample rate\n");
366  return NULL;
367  }
368 
369  config_byte[0] = 0x40;
370  config_byte[1] = 0;
371  config_byte[2] = 0x20 | rate_index;
372  config_byte[3] = c->channels << 4;
373  config_byte[4] = 0x3f;
374  config_byte[5] = 0xc0;
375 
376  config = av_malloc(6*2+1);
377  if (!config) {
378  av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
379  return NULL;
380  }
381  ff_data_to_hex(config, config_byte, 6, 1);
382  config[12] = 0;
383 
384  return config;
385 }
386 
387 static char *sdp_write_media_attributes(char *buff, int size, AVCodecContext *c, int payload_type, AVFormatContext *fmt)
388 {
389  char *config = NULL;
390 
391  switch (c->codec_id) {
392  case CODEC_ID_H264:
393  if (c->extradata_size) {
394  config = extradata2psets(c);
395  }
396  av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
397  "a=fmtp:%d packetization-mode=1%s\r\n",
398  payload_type,
399  payload_type, config ? config : "");
400  break;
401  case CODEC_ID_H263:
402  case CODEC_ID_H263P:
403  /* a=framesize is required by 3GPP TS 26.234 (PSS). It
404  * actually specifies the maximum video size, but we only know
405  * the current size. This is required for playback on Android
406  * stagefright and on Samsung bada. */
407  av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
408  "a=framesize:%d %d-%d\r\n",
409  payload_type,
410  payload_type, c->width, c->height);
411  break;
412  case CODEC_ID_MPEG4:
413  if (c->extradata_size) {
414  config = extradata2config(c);
415  }
416  av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
417  "a=fmtp:%d profile-level-id=1%s\r\n",
418  payload_type,
419  payload_type, config ? config : "");
420  break;
421  case CODEC_ID_AAC:
422  if (fmt && fmt->oformat->priv_class &&
423  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
424  config = latm_context2config(c);
425  if (!config)
426  return NULL;
427  av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
428  "a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
429  payload_type, c->sample_rate, c->channels,
430  payload_type, latm_context2profilelevel(c), config);
431  } else {
432  if (c->extradata_size) {
433  config = extradata2config(c);
434  } else {
435  /* FIXME: maybe we can forge config information based on the
436  * codec parameters...
437  */
438  av_log(c, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
439  return NULL;
440  }
441  if (config == NULL) {
442  return NULL;
443  }
444  av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
445  "a=fmtp:%d profile-level-id=1;"
446  "mode=AAC-hbr;sizelength=13;indexlength=3;"
447  "indexdeltalength=3%s\r\n",
448  payload_type, c->sample_rate, c->channels,
449  payload_type, config);
450  }
451  break;
452  case CODEC_ID_PCM_S16BE:
453  if (payload_type >= RTP_PT_PRIVATE)
454  av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
455  payload_type,
456  c->sample_rate, c->channels);
457  break;
458  case CODEC_ID_PCM_MULAW:
459  if (payload_type >= RTP_PT_PRIVATE)
460  av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
461  payload_type,
462  c->sample_rate, c->channels);
463  break;
464  case CODEC_ID_PCM_ALAW:
465  if (payload_type >= RTP_PT_PRIVATE)
466  av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
467  payload_type,
468  c->sample_rate, c->channels);
469  break;
470  case CODEC_ID_AMR_NB:
471  av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
472  "a=fmtp:%d octet-align=1\r\n",
473  payload_type, c->sample_rate, c->channels,
474  payload_type);
475  break;
476  case CODEC_ID_AMR_WB:
477  av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
478  "a=fmtp:%d octet-align=1\r\n",
479  payload_type, c->sample_rate, c->channels,
480  payload_type);
481  break;
482  case CODEC_ID_VORBIS:
483  if (c->extradata_size)
484  config = xiph_extradata2config(c);
485  else
486  av_log(c, AV_LOG_ERROR, "Vorbis configuration info missing\n");
487  if (!config)
488  return NULL;
489 
490  av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
491  "a=fmtp:%d configuration=%s\r\n",
492  payload_type, c->sample_rate, c->channels,
493  payload_type, config);
494  break;
495  case CODEC_ID_THEORA: {
496  const char *pix_fmt;
497  if (c->extradata_size)
498  config = xiph_extradata2config(c);
499  else
500  av_log(c, AV_LOG_ERROR, "Theora configuation info missing\n");
501  if (!config)
502  return NULL;
503 
504  switch (c->pix_fmt) {
505  case PIX_FMT_YUV420P:
506  pix_fmt = "YCbCr-4:2:0";
507  break;
508  case PIX_FMT_YUV422P:
509  pix_fmt = "YCbCr-4:2:2";
510  break;
511  case PIX_FMT_YUV444P:
512  pix_fmt = "YCbCr-4:4:4";
513  break;
514  default:
515  av_log(c, AV_LOG_ERROR, "Unsupported pixel format.\n");
516  return NULL;
517  }
518 
519  av_strlcatf(buff, size, "a=rtpmap:%d theora/90000\r\n"
520  "a=fmtp:%d delivery-method=inline; "
521  "width=%d; height=%d; sampling=%s; "
522  "configuration=%s\r\n",
523  payload_type, payload_type,
524  c->width, c->height, pix_fmt, config);
525  break;
526  }
527  case CODEC_ID_VP8:
528  av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
529  payload_type);
530  break;
531  case CODEC_ID_ADPCM_G722:
532  if (payload_type >= RTP_PT_PRIVATE)
533  av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
534  payload_type,
535  8000, c->channels);
536  break;
537  case CODEC_ID_ADPCM_G726: {
538  if (payload_type >= RTP_PT_PRIVATE)
539  av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
540  payload_type,
542  c->sample_rate);
543  break;
544  }
545  default:
546  /* Nothing special to do here... */
547  break;
548  }
549 
550  av_free(config);
551 
552  return buff;
553 }
554 
555 void ff_sdp_write_media(char *buff, int size, AVCodecContext *c, const char *dest_addr, const char *dest_type, int port, int ttl, AVFormatContext *fmt)
556 {
557  const char *type;
558  int payload_type;
559 
560  payload_type = ff_rtp_get_payload_type(fmt, c);
561 
562  switch (c->codec_type) {
563  case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
564  case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
565  case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
566  default : type = "application"; break;
567  }
568 
569  av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
570  sdp_write_address(buff, size, dest_addr, dest_type, ttl);
571  if (c->bit_rate) {
572  av_strlcatf(buff, size, "b=AS:%d\r\n", c->bit_rate / 1000);
573  }
574 
575  sdp_write_media_attributes(buff, size, c, payload_type, fmt);
576 }
577 
578 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
579 {
580  AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
581  struct sdp_session_level s;
582  int i, j, port, ttl, is_multicast;
583  char dst[32], dst_type[5];
584 
585  memset(buf, 0, size);
586  memset(&s, 0, sizeof(struct sdp_session_level));
587  s.user = "-";
588  s.src_addr = "127.0.0.1"; /* FIXME: Properly set this */
589  s.src_type = "IP4";
590  s.name = title ? title->value : "No Name";
591 
592  port = 0;
593  ttl = 0;
594  if (n_files == 1) {
595  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->filename);
596  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
597  sizeof(dst_type));
598  if (!is_multicast)
599  ttl = 0;
600  if (dst[0]) {
601  s.dst_addr = dst;
602  s.dst_type = dst_type;
603  s.ttl = ttl;
604  if (!strcmp(dst_type, "IP6")) {
605  s.src_addr = "::1";
606  s.src_type = "IP6";
607  }
608  }
609  }
610  sdp_write_header(buf, size, &s);
611 
612  dst[0] = 0;
613  for (i = 0; i < n_files; i++) {
614  if (n_files != 1) {
615  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->filename);
616  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
617  sizeof(dst_type));
618  if (!is_multicast)
619  ttl = 0;
620  }
621  for (j = 0; j < ac[i]->nb_streams; j++) {
622  ff_sdp_write_media(buf, size,
623  ac[i]->streams[j]->codec, dst[0] ? dst : NULL,
624  dst_type, (port > 0) ? port + j * 2 : 0, ttl,
625  ac[i]);
626  if (port <= 0) {
627  av_strlcatf(buf, size,
628  "a=control:streamid=%d\r\n", i + j);
629  }
630  }
631  }
632 
633  return 0;
634 }
635 #else
636 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
637 {
638  return AVERROR(ENOSYS);
639 }
640 
641 void ff_sdp_write_media(char *buff, int size, AVCodecContext *c, const char *dest_addr, const char *dest_type, int port, int ttl, AVFormatContext *fmt)
642 {
643 }
644 #endif
645 
646 #if FF_API_SDP_CREATE
647 int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size)
648 {
649  return av_sdp_create(ac, n_files, buff, size);
650 }
651 #endif