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 && p - psets <= MAX_PSET_SIZE - strlen(profile_string) - 7) {
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:
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  break;
708  case AV_CODEC_ID_OPUS:
709  /* The opus RTP draft says that all opus streams MUST be declared
710  as stereo, to avoid negotiation failures. The actual number of
711  channels can change on a packet-by-packet basis. The number of
712  channels a receiver prefers to receive or a sender plans to send
713  can be declared via fmtp parameters (both default to mono), but
714  receivers MUST be able to receive and process stereo packets. */
715  av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
716  payload_type);
717  if (p->channels == 2) {
718  av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo=1\r\n",
719  payload_type);
720  }
721  break;
722  default:
723  /* Nothing special to do here... */
724  break;
725  }
726 
727  av_free(config);
728 
729  return buff;
730 }
731 
732 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
733  const char *dest_addr, const char *dest_type,
734  int port, int ttl, AVFormatContext *fmt)
735 {
736  AVCodecParameters *p = st->codecpar;
737  const char *type;
738  int payload_type;
739 
740  payload_type = ff_rtp_get_payload_type(fmt, st->codecpar, idx);
741 
742  switch (p->codec_type) {
743  case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
744  case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
745  case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
746  default : type = "application"; break;
747  }
748 
749  av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
750  sdp_write_address(buff, size, dest_addr, dest_type, ttl);
751  if (p->bit_rate) {
752  av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", p->bit_rate / 1000);
753  }
754 
755  sdp_write_media_attributes(buff, size, st, payload_type, fmt);
756 }
757 
758 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
759 {
760  AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
761  struct sdp_session_level s = { 0 };
762  int i, j, port, ttl, is_multicast, index = 0;
763  char dst[32], dst_type[5];
764 
765  memset(buf, 0, size);
766  s.user = "-";
767  s.src_addr = "127.0.0.1"; /* FIXME: Properly set this */
768  s.src_type = "IP4";
769  s.name = title ? title->value : "No Name";
770 
771  port = 0;
772  ttl = 0;
773  if (n_files == 1) {
774  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->url ? ac[0]->url : "");
775  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
776  sizeof(dst_type));
777  if (!is_multicast)
778  ttl = 0;
779  if (dst[0]) {
780  s.dst_addr = dst;
781  s.dst_type = dst_type;
782  s.ttl = ttl;
783  if (!strcmp(dst_type, "IP6")) {
784  s.src_addr = "::1";
785  s.src_type = "IP6";
786  }
787  }
788  }
789  sdp_write_header(buf, size, &s);
790 
791  dst[0] = 0;
792  for (i = 0; i < n_files; i++) {
793  if (n_files != 1) {
794  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->url ? ac[i]->url : "");
795  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
796  sizeof(dst_type));
797  if (!is_multicast)
798  ttl = 0;
799  }
800  for (j = 0; j < ac[i]->nb_streams; j++) {
801  ff_sdp_write_media(buf, size, ac[i]->streams[j], index++,
802  dst[0] ? dst : NULL, dst_type,
803  (port > 0) ? port + j * 2 : 0,
804  ttl, ac[i]);
805  if (port <= 0) {
806  av_strlcatf(buf, size,
807  "a=control:streamid=%d\r\n", i + j);
808  }
809  if (ac[i]->pb && ac[i]->pb->av_class) {
810  uint8_t *crypto_suite = NULL, *crypto_params = NULL;
811  av_opt_get(ac[i]->pb, "srtp_out_suite", AV_OPT_SEARCH_CHILDREN,
812  &crypto_suite);
813  av_opt_get(ac[i]->pb, "srtp_out_params", AV_OPT_SEARCH_CHILDREN,
814  &crypto_params);
815  if (crypto_suite && crypto_suite[0])
816  av_strlcatf(buf, size,
817  "a=crypto:1 %s inline:%s\r\n",
818  crypto_suite, crypto_params);
819  av_free(crypto_suite);
820  av_free(crypto_params);
821  }
822  }
823  }
824 
825  return 0;
826 }
827 #else
828 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
829 {
830  return AVERROR(ENOSYS);
831 }
832 
833 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
834  const char *dest_addr, const char *dest_type,
835  int port, int ttl, AVFormatContext *fmt)
836 {
837 }
838 #endif
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
r
const char * r
Definition: vf_curves.c:116
AVERROR
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
opt.h
av_find_info_tag
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:751
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
hevc.h
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ff_sdp_write_media
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:833
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:166
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
index
fg index
Definition: ffmpeg_filter.c:168
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:405
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:380
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:406
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:53
xiph.h
ff_rtp_get_payload_type
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
freeaddrinfo
#define freeaddrinfo
Definition: network.h:218
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
mpeg4audio.h
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:457
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:314
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_data_to_hex
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Definition: utils.c:4722
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1444
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_dict_get
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
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1399
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:363
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:218
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:319
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:320
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:994
RTP_PT_PRIVATE
#define RTP_PT_PRIVATE
Definition: rtp.h:79
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
NULL
#define NULL
Definition: coverity.c:32
avc.h
parseutils.h
ff_is_multicast_address
int ff_is_multicast_address(struct sockaddr *addr)
Definition: network.c:145
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:524
base64.h
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1163
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:424
NI_NUMERICHOST
#define NI_NUMERICHOST
Definition: network.h:195
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
RTP_XIPH_IDENT
#define RTP_XIPH_IDENT
Definition: rtp.h:91
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:325
start_time
static int64_t start_time
Definition: ffplay.c:330
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:54
size
int size
Definition: twinvq_data.h:10344
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:482
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:559
av_sdp_create
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
Generate an SDP for an RTP session.
Definition: sdp.c:828
version
version
Definition: libkvazaar.c:307
rtp.h
getaddrinfo
#define getaddrinfo
Definition: network.h:217
ff_isom_write_hvcc
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:1067
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
i
int i
Definition: input.c:406
AV_CODEC_ID_THEORA
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:80
getnameinfo
#define getnameinfo
Definition: network.h:219
AVCodecParameters::height
int height
Definition: codec_par.h:127
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
MAX_EXTRADATA_SIZE
#define MAX_EXTRADATA_SIZE
Definition: latmenc.c:33
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
av_url_split
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:4625
AV_STRINGIFY
#define AV_STRINGIFY(s)
Definition: macros.h:66
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:261
len
int len
Definition: vorbis_enc_data.h:426
LIBAVFORMAT_VERSION
#define LIBAVFORMAT_VERSION
Definition: version.h:41
AVStream
Stream structure.
Definition: avformat.h:847
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1126
av_strlcat
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
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
dict.h
network.h
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:69
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:387
ff_avc_write_annexb_extradata
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:221
mode
mode
Definition: ebur128.h:83
av_base64_encode
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:143
avpriv_split_xiph_headers
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
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
av_opt_flag_is_set
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:1048
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
avpriv_mpeg4audio_sample_rates
const int avpriv_mpeg4audio_sample_rates[16]
Definition: mpeg4audio.c:62
AVCodecParameters::format
int format
Definition: codec_par.h:84
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:79
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AV_CODEC_ID_ILBC
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:481
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:190
av_strlcpy
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
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:779
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:427
AVDictionaryEntry::value
char * value
Definition: dict.h:81
avstring.h
addrinfo
Definition: network.h:137
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1135
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:326
AVIOContext::av_class
const AVClass * av_class
A class for private options.
Definition: avio.h:174
AV_RB16
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:98
ff_avc_find_startcode
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:67