FFmpeg
sdp.c
Go to the documentation of this file.
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(AVFormatContext *s, AVCodecParameters *par)
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 = par->extradata;
161  int extradata_size = par->extradata_size;
162  uint8_t *tmpbuf = NULL;
163  const uint8_t *sps = NULL, *sps_end;
164 
165  if (par->extradata_size > MAX_EXTRADATA_SIZE) {
166  av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
167 
168  return NULL;
169  }
170  if (par->extradata[0] == 1) {
171  if (ff_avc_write_annexb_extradata(par->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(s, 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(s, 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(AVCodecParameters *par)
227 {
228  char *psets;
229  uint8_t *extradata = par->extradata;
230  int extradata_size = par->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 (par->extradata[0] != 1) {
242  AVIOContext *pb;
243  if (avio_open_dyn_buf(&pb) < 0)
244  return NULL;
245  if (ff_isom_write_hvcc(pb, par->extradata, par->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 H.264 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(AVFormatContext *s, AVCodecParameters *par)
328 {
329  char *config;
330 
331  if (par->extradata_size > MAX_EXTRADATA_SIZE) {
332  av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
333 
334  return NULL;
335  }
336  config = av_malloc(10 + par->extradata_size * 2);
337  if (!config) {
338  av_log(s, 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, par->extradata, par->extradata_size, 0);
343  config[9 + par->extradata_size * 2] = 0;
344 
345  return config;
346 }
347 
348 static char *xiph_extradata2config(AVFormatContext *s, AVCodecParameters *par)
349 {
350  uint8_t *config;
351  char *encoded_config;
352  const uint8_t *header_start[3];
353  int headers_len, header_len[3], config_len;
354  int first_header_size;
355 
356  switch (par->codec_id) {
357  case AV_CODEC_ID_THEORA:
358  first_header_size = 42;
359  break;
360  case AV_CODEC_ID_VORBIS:
361  first_header_size = 30;
362  break;
363  default:
364  av_log(s, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
365  return NULL;
366  }
367 
369  first_header_size, header_start,
370  header_len) < 0) {
371  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
372  return NULL;
373  }
374 
375  headers_len = header_len[0] + header_len[2];
376  config_len = 4 + // count
377  3 + // ident
378  2 + // packet size
379  1 + // header count
380  2 + // header size
381  headers_len; // and the rest
382 
383  config = av_malloc(config_len);
384  if (!config)
385  goto xiph_fail;
386 
387  encoded_config = av_malloc(AV_BASE64_SIZE(config_len));
388  if (!encoded_config) {
389  av_free(config);
390  goto xiph_fail;
391  }
392 
393  config[0] = config[1] = config[2] = 0;
394  config[3] = 1;
395  config[4] = (RTP_XIPH_IDENT >> 16) & 0xff;
396  config[5] = (RTP_XIPH_IDENT >> 8) & 0xff;
397  config[6] = (RTP_XIPH_IDENT ) & 0xff;
398  config[7] = (headers_len >> 8) & 0xff;
399  config[8] = headers_len & 0xff;
400  config[9] = 2;
401  config[10] = header_len[0];
402  config[11] = 0; // size of comment header; nonexistent
403  memcpy(config + 12, header_start[0], header_len[0]);
404  memcpy(config + 12 + header_len[0], header_start[2], header_len[2]);
405 
406  av_base64_encode(encoded_config, AV_BASE64_SIZE(config_len),
407  config, config_len);
408  av_free(config);
409 
410  return encoded_config;
411 
412 xiph_fail:
413  av_log(s, AV_LOG_ERROR,
414  "Not enough memory for configuration string\n");
415  return NULL;
416 }
417 
418 static int latm_context2profilelevel(AVCodecParameters *par)
419 {
420  /* MP4A-LATM
421  * The RTP payload format specification is described in RFC 3016
422  * The encoding specifications are provided in ISO/IEC 14496-3 */
423 
424  int profile_level = 0x2B;
425 
426  /* TODO: AAC Profile only supports AAC LC Object Type.
427  * Different Object Types should implement different Profile Levels */
428 
429  if (par->sample_rate <= 24000) {
430  if (par->channels <= 2)
431  profile_level = 0x28; // AAC Profile, Level 1
432  } else if (par->sample_rate <= 48000) {
433  if (par->channels <= 2) {
434  profile_level = 0x29; // AAC Profile, Level 2
435  } else if (par->channels <= 5) {
436  profile_level = 0x2A; // AAC Profile, Level 4
437  }
438  } else if (par->sample_rate <= 96000) {
439  if (par->channels <= 5) {
440  profile_level = 0x2B; // AAC Profile, Level 5
441  }
442  }
443 
444  return profile_level;
445 }
446 
447 static char *latm_context2config(AVFormatContext *s, AVCodecParameters *par)
448 {
449  /* MP4A-LATM
450  * The RTP payload format specification is described in RFC 3016
451  * The encoding specifications are provided in ISO/IEC 14496-3 */
452 
453  uint8_t config_byte[6];
454  int rate_index;
455  char *config;
456 
457  for (rate_index = 0; rate_index < 16; rate_index++)
458  if (avpriv_mpeg4audio_sample_rates[rate_index] == par->sample_rate)
459  break;
460  if (rate_index == 16) {
461  av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
462  return NULL;
463  }
464 
465  config_byte[0] = 0x40;
466  config_byte[1] = 0;
467  config_byte[2] = 0x20 | rate_index;
468  config_byte[3] = par->channels << 4;
469  config_byte[4] = 0x3f;
470  config_byte[5] = 0xc0;
471 
472  config = av_malloc(6*2+1);
473  if (!config) {
474  av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
475  return NULL;
476  }
477  ff_data_to_hex(config, config_byte, 6, 1);
478  config[12] = 0;
479 
480  return config;
481 }
482 
483 static char *sdp_write_media_attributes(char *buff, int size, AVStream *st, int payload_type, AVFormatContext *fmt)
484 {
485  char *config = NULL;
486  AVCodecParameters *p = st->codecpar;
487 
488  switch (p->codec_id) {
489  case AV_CODEC_ID_DIRAC:
490  av_strlcatf(buff, size, "a=rtpmap:%d VC2/90000\r\n", payload_type);
491  break;
492  case AV_CODEC_ID_H264: {
493  int mode = 1;
494  if (fmt && fmt->oformat && fmt->oformat->priv_class &&
495  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
496  mode = 0;
497  if (p->extradata_size) {
498  config = extradata2psets(fmt, p);
499  }
500  av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
501  "a=fmtp:%d packetization-mode=%d%s\r\n",
502  payload_type,
503  payload_type, mode, config ? config : "");
504  break;
505  }
506  case AV_CODEC_ID_H261:
507  {
508  const char *pic_fmt = NULL;
509  /* only QCIF and CIF are specified as supported in RFC 4587 */
510  if (p->width == 176 && p->height == 144)
511  pic_fmt = "QCIF=1";
512  else if (p->width == 352 && p->height == 288)
513  pic_fmt = "CIF=1";
514  if (payload_type >= RTP_PT_PRIVATE)
515  av_strlcatf(buff, size, "a=rtpmap:%d H261/90000\r\n", payload_type);
516  if (pic_fmt)
517  av_strlcatf(buff, size, "a=fmtp:%d %s\r\n", payload_type, pic_fmt);
518  break;
519  }
520  case AV_CODEC_ID_H263:
521  case AV_CODEC_ID_H263P:
522  /* a=framesize is required by 3GPP TS 26.234 (PSS). It
523  * actually specifies the maximum video size, but we only know
524  * the current size. This is required for playback on Android
525  * stagefright and on Samsung bada. */
526  if (!fmt || !fmt->oformat->priv_class ||
527  !av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") ||
529  av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
530  "a=framesize:%d %d-%d\r\n",
531  payload_type,
532  payload_type, p->width, p->height);
533  break;
534  case AV_CODEC_ID_HEVC:
535  if (p->extradata_size)
536  config = extradata2psets_hevc(p);
537  av_strlcatf(buff, size, "a=rtpmap:%d H265/90000\r\n", payload_type);
538  if (config)
539  av_strlcatf(buff, size, "a=fmtp:%d %s\r\n",
540  payload_type, config);
541  break;
542  case AV_CODEC_ID_MPEG4:
543  if (p->extradata_size) {
544  config = extradata2config(fmt, p);
545  }
546  av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
547  "a=fmtp:%d profile-level-id=1%s\r\n",
548  payload_type,
549  payload_type, config ? config : "");
550  break;
551  case AV_CODEC_ID_AAC:
552  if (fmt && fmt->oformat && fmt->oformat->priv_class &&
553  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
554  config = latm_context2config(fmt, p);
555  if (!config)
556  return NULL;
557  av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
558  "a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
559  payload_type, p->sample_rate, p->channels,
560  payload_type, latm_context2profilelevel(p), config);
561  } else {
562  if (p->extradata_size) {
563  config = extradata2config(fmt, p);
564  } else {
565  /* FIXME: maybe we can forge config information based on the
566  * codec parameters...
567  */
568  av_log(fmt, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
569  return NULL;
570  }
571  if (!config) {
572  return NULL;
573  }
574  av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
575  "a=fmtp:%d profile-level-id=1;"
576  "mode=AAC-hbr;sizelength=13;indexlength=3;"
577  "indexdeltalength=3%s\r\n",
578  payload_type, p->sample_rate, p->channels,
579  payload_type, config);
580  }
581  break;
583  if (payload_type >= RTP_PT_PRIVATE)
584  av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
585  payload_type,
586  p->sample_rate, p->channels);
587  break;
589  if (payload_type >= RTP_PT_PRIVATE)
590  av_strlcatf(buff, size, "a=rtpmap:%d L24/%d/%d\r\n",
591  payload_type,
592  p->sample_rate, p->channels);
593  break;
595  if (payload_type >= RTP_PT_PRIVATE)
596  av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
597  payload_type,
598  p->sample_rate, p->channels);
599  break;
601  if (payload_type >= RTP_PT_PRIVATE)
602  av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
603  payload_type,
604  p->sample_rate, p->channels);
605  break;
606  case AV_CODEC_ID_AMR_NB:
607  av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
608  "a=fmtp:%d octet-align=1\r\n",
609  payload_type, p->sample_rate, p->channels,
610  payload_type);
611  break;
612  case AV_CODEC_ID_AMR_WB:
613  av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
614  "a=fmtp:%d octet-align=1\r\n",
615  payload_type, p->sample_rate, p->channels,
616  payload_type);
617  break;
618  case AV_CODEC_ID_VORBIS:
619  if (p->extradata_size)
620  config = xiph_extradata2config(fmt, p);
621  else
622  av_log(fmt, AV_LOG_ERROR, "Vorbis configuration info missing\n");
623  if (!config)
624  return NULL;
625 
626  av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
627  "a=fmtp:%d configuration=%s\r\n",
628  payload_type, p->sample_rate, p->channels,
629  payload_type, config);
630  break;
631  case AV_CODEC_ID_THEORA: {
632  const char *pix_fmt;
633  switch (p->format) {
634  case AV_PIX_FMT_YUV420P:
635  pix_fmt = "YCbCr-4:2:0";
636  break;
637  case AV_PIX_FMT_YUV422P:
638  pix_fmt = "YCbCr-4:2:2";
639  break;
640  case AV_PIX_FMT_YUV444P:
641  pix_fmt = "YCbCr-4:4:4";
642  break;
643  default:
644  av_log(fmt, AV_LOG_ERROR, "Unsupported pixel format.\n");
645  return NULL;
646  }
647 
648  if (p->extradata_size)
649  config = xiph_extradata2config(fmt, p);
650  else
651  av_log(fmt, AV_LOG_ERROR, "Theora configuration info missing\n");
652  if (!config)
653  return NULL;
654 
655  av_strlcatf(buff, size, "a=rtpmap:%d theora/90000\r\n"
656  "a=fmtp:%d delivery-method=inline; "
657  "width=%d; height=%d; sampling=%s; "
658  "configuration=%s\r\n",
659  payload_type, payload_type,
660  p->width, p->height, pix_fmt, config);
661  break;
662  }
663  case AV_CODEC_ID_VP8:
664  av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
665  payload_type);
666  break;
667  case AV_CODEC_ID_VP9:
668  av_strlcatf(buff, size, "a=rtpmap:%d VP9/90000\r\n",
669  payload_type);
670  break;
671  case AV_CODEC_ID_MJPEG:
672  if (payload_type >= RTP_PT_PRIVATE)
673  av_strlcatf(buff, size, "a=rtpmap:%d JPEG/90000\r\n",
674  payload_type);
675  break;
677  if (payload_type >= RTP_PT_PRIVATE)
678  av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
679  payload_type,
680  8000, p->channels);
681  break;
682  case AV_CODEC_ID_ADPCM_G726: {
683  if (payload_type >= RTP_PT_PRIVATE)
684  av_strlcatf(buff, size, "a=rtpmap:%d AAL2-G726-%d/%d\r\n",
685  payload_type,
687  p->sample_rate);
688  break;
689  }
691  if (payload_type >= RTP_PT_PRIVATE)
692  av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
693  payload_type,
695  p->sample_rate);
696  break;
697  }
698  case AV_CODEC_ID_ILBC:
699  av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
700  "a=fmtp:%d mode=%d\r\n",
701  payload_type, p->sample_rate,
702  payload_type, p->block_align == 38 ? 20 : 30);
703  break;
704  case AV_CODEC_ID_SPEEX:
705  av_strlcatf(buff, size, "a=rtpmap:%d speex/%d\r\n",
706  payload_type, p->sample_rate);
707  if (st->codec) {
708  const char *mode;
709  uint64_t vad_option;
710 
711  if (st->codec->flags & AV_CODEC_FLAG_QSCALE)
712  mode = "on";
713  else if (!av_opt_get_int(st->codec, "vad", AV_OPT_FLAG_ENCODING_PARAM, &vad_option) && vad_option)
714  mode = "vad";
715  else
716  mode = "off";
717 
718  av_strlcatf(buff, size, "a=fmtp:%d vbr=%s\r\n",
719  payload_type, mode);
720  }
721  break;
722  case AV_CODEC_ID_OPUS:
723  /* The opus RTP draft says that all opus streams MUST be declared
724  as stereo, to avoid negotiation failures. The actual number of
725  channels can change on a packet-by-packet basis. The number of
726  channels a receiver prefers to receive or a sender plans to send
727  can be declared via fmtp parameters (both default to mono), but
728  receivers MUST be able to receive and process stereo packets. */
729  av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
730  payload_type);
731  if (p->channels == 2) {
732  av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo=1\r\n",
733  payload_type);
734  }
735  break;
736  default:
737  /* Nothing special to do here... */
738  break;
739  }
740 
741  av_free(config);
742 
743  return buff;
744 }
745 
746 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
747  const char *dest_addr, const char *dest_type,
748  int port, int ttl, AVFormatContext *fmt)
749 {
750  AVCodecParameters *p = st->codecpar;
751  const char *type;
752  int payload_type;
753 
754  payload_type = ff_rtp_get_payload_type(fmt, st->codecpar, idx);
755 
756  switch (p->codec_type) {
757  case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
758  case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
759  case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
760  default : type = "application"; break;
761  }
762 
763  av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
764  sdp_write_address(buff, size, dest_addr, dest_type, ttl);
765  if (p->bit_rate) {
766  av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", p->bit_rate / 1000);
767  }
768 
769  sdp_write_media_attributes(buff, size, st, payload_type, fmt);
770 }
771 
772 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
773 {
774  AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
775  struct sdp_session_level s = { 0 };
776  int i, j, port, ttl, is_multicast, index = 0;
777  char dst[32], dst_type[5];
778 
779  memset(buf, 0, size);
780  s.user = "-";
781  s.src_addr = "127.0.0.1"; /* FIXME: Properly set this */
782  s.src_type = "IP4";
783  s.name = title ? title->value : "No Name";
784 
785  port = 0;
786  ttl = 0;
787  if (n_files == 1) {
788  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->url ? ac[0]->url : "");
789  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
790  sizeof(dst_type));
791  if (!is_multicast)
792  ttl = 0;
793  if (dst[0]) {
794  s.dst_addr = dst;
795  s.dst_type = dst_type;
796  s.ttl = ttl;
797  if (!strcmp(dst_type, "IP6")) {
798  s.src_addr = "::1";
799  s.src_type = "IP6";
800  }
801  }
802  }
803  sdp_write_header(buf, size, &s);
804 
805  dst[0] = 0;
806  for (i = 0; i < n_files; i++) {
807  if (n_files != 1) {
808  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->url ? ac[i]->url : "");
809  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
810  sizeof(dst_type));
811  if (!is_multicast)
812  ttl = 0;
813  }
814  for (j = 0; j < ac[i]->nb_streams; j++) {
815  ff_sdp_write_media(buf, size, ac[i]->streams[j], index++,
816  dst[0] ? dst : NULL, dst_type,
817  (port > 0) ? port + j * 2 : 0,
818  ttl, ac[i]);
819  if (port <= 0) {
820  av_strlcatf(buf, size,
821  "a=control:streamid=%d\r\n", i + j);
822  }
823  if (ac[i]->pb && ac[i]->pb->av_class) {
824  uint8_t *crypto_suite = NULL, *crypto_params = NULL;
825  av_opt_get(ac[i]->pb, "srtp_out_suite", AV_OPT_SEARCH_CHILDREN,
826  &crypto_suite);
827  av_opt_get(ac[i]->pb, "srtp_out_params", AV_OPT_SEARCH_CHILDREN,
828  &crypto_params);
829  if (crypto_suite && crypto_suite[0])
830  av_strlcatf(buf, size,
831  "a=crypto:1 %s inline:%s\r\n",
832  crypto_suite, crypto_params);
833  av_free(crypto_suite);
834  av_free(crypto_params);
835  }
836  }
837  }
838 
839  return 0;
840 }
841 #else
842 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
843 {
844  return AVERROR(ENOSYS);
845 }
846 
847 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
848  const char *dest_addr, const char *dest_type,
849  int port, int ttl, AVFormatContext *fmt)
850 {
851 }
852 #endif
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:4742
internal header for HEVC (de)muxer utilities
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
static enum AVPixelFormat pix_fmt
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:66
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1459
const char * fmt
Definition: avisynth_c.h:861
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3960
GLint GLenum type
Definition: opengl_enc.c:104
int version
Definition: avisynth_c.h:858
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
#define freeaddrinfo
Definition: network.h:215
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1430
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3952
Format I/O context.
Definition: avformat.h:1358
#define RTP_PT_PRIVATE
Definition: rtp.h:77
Public dictionary API.
static int64_t start_time
Definition: ffplay.c:331
uint8_t
#define av_malloc(s)
int width
Video only.
Definition: avcodec.h:4026
AVOptions.
const AVClass * av_class
A class for private options.
Definition: avio.h:174
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:198
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
Generate an SDP for an RTP session.
Definition: sdp.c:842
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
Definition: parseutils.c:749
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3989
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
const char * r
Definition: vf_curves.c:114
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes HEVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext...
Definition: hevc.c:1062
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3956
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:138
int ff_is_multicast_address(struct sockaddr *addr)
Definition: network.c:145
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3978
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
#define NI_NUMERICHOST
Definition: network.h:192
int block_align
Audio only.
Definition: avcodec.h:4077
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:853
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:556
#define s(width, name)
Definition: cbs_vp9.c:257
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
Definition: xiph.c:24
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:533
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
Stream structure.
Definition: avformat.h:881
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:888
#define MAX_EXTRADATA_SIZE
Definition: latmenc.c:31
void * buf
Definition: avisynth_c.h:766
#define AV_STRINGIFY(s)
Definition: macros.h:36
int index
Definition: gxfenc.c:89
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
misc parsing utilities
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:93
#define LIBAVFORMAT_VERSION
Definition: version.h:41
#define RTP_XIPH_IDENT
Definition: rtp.h:89
const int avpriv_mpeg4audio_sample_rates[16]
Definition: mpeg4audio.c:62
int sample_rate
Audio only.
Definition: avcodec.h:4070
#define getaddrinfo
Definition: network.h:214
Main libavformat public API header.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define getnameinfo
Definition: network.h:216
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:761
#define av_free(p)
char * value
Definition: dict.h:87
int len
int ff_rtp_get_payload_type(AVFormatContext *fmt, AVCodecParameters *par, int idx)
Return the payload type for a given stream used in the given format context.
Definition: rtp.c:90
void * priv_data
Format private data.
Definition: avformat.h:1386
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4002
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3974
int channels
Audio only.
Definition: avcodec.h:4066
int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
Check whether a particular flag is set in a flags field.
Definition: opt.c:1024
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx, const char *dest_addr, const char *dest_type, int port, int ttl, AVFormatContext *fmt)
Append the media-specific SDP fragment for the media stream c to the buffer buff. ...
Definition: sdp.c:847
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
enum AVCodecID id
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Definition: utils.c:4847
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
const char * name
Definition: opengl_enc.c:102