FFmpeg  4.4.6
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  if (p - psets >= MAX_PSET_SIZE)
199  goto fail_in_loop;
200  *p = ',';
201  p++;
202  }
203  if (!sps) {
204  sps = r;
205  sps_end = r1;
206  }
207  if (!av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r)) {
208  av_log(s, AV_LOG_ERROR, "Cannot Base64-encode %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
209 fail_in_loop:
210  av_free(psets);
211  av_free(tmpbuf);
212 
213  return NULL;
214  }
215  p += strlen(p);
216  r = r1;
217  }
218  if (sps && sps_end - sps >= 4 && p - psets <= MAX_PSET_SIZE - strlen(profile_string) - 7) {
219  memcpy(p, profile_string, strlen(profile_string));
220  p += strlen(p);
221  ff_data_to_hex(p, sps + 1, 3, 0);
222  p[6] = '\0';
223  }
224  av_free(tmpbuf);
225 
226  return psets;
227 }
228 
229 static char *extradata2psets_hevc(AVCodecParameters *par)
230 {
231  char *psets;
232  uint8_t *extradata = par->extradata;
233  int extradata_size = par->extradata_size;
234  uint8_t *tmpbuf = NULL;
235  int ps_pos[3] = { 0 };
236  static const char * const ps_names[3] = { "vps", "sps", "pps" };
237  int num_arrays, num_nalus;
238  int pos, i, j;
239 
240  // Convert to hvcc format. Since we need to group multiple NALUs of
241  // the same type, and we might need to convert from one format to the
242  // other anyway, we get away with a little less work by using the hvcc
243  // format.
244  if (par->extradata[0] != 1) {
245  AVIOContext *pb;
246  if (avio_open_dyn_buf(&pb) < 0)
247  return NULL;
248  if (ff_isom_write_hvcc(pb, par->extradata, par->extradata_size, 0) < 0) {
249  avio_close_dyn_buf(pb, &tmpbuf);
250  goto err;
251  }
252  extradata_size = avio_close_dyn_buf(pb, &extradata);
253  tmpbuf = extradata;
254  }
255 
256  if (extradata_size < 23)
257  goto err;
258 
259  num_arrays = extradata[22];
260  pos = 23;
261  for (i = 0; i < num_arrays; i++) {
262  int num_nalus, nalu_type;
263  if (pos + 3 > extradata_size)
264  goto err;
265  nalu_type = extradata[pos] & 0x3f;
266  // Not including libavcodec/hevc.h to avoid confusion between
267  // NAL_* with the same name for both H.264 and HEVC.
268  if (nalu_type == 32) // VPS
269  ps_pos[0] = pos;
270  else if (nalu_type == 33) // SPS
271  ps_pos[1] = pos;
272  else if (nalu_type == 34) // PPS
273  ps_pos[2] = pos;
274  num_nalus = AV_RB16(&extradata[pos + 1]);
275  pos += 3;
276  for (j = 0; j < num_nalus; j++) {
277  int len;
278  if (pos + 2 > extradata_size)
279  goto err;
280  len = AV_RB16(&extradata[pos]);
281  pos += 2;
282  if (pos + len > extradata_size)
283  goto err;
284  pos += len;
285  }
286  }
287  if (!ps_pos[0] || !ps_pos[1] || !ps_pos[2])
288  goto err;
289 
290  psets = av_mallocz(MAX_PSET_SIZE);
291  if (!psets)
292  goto err;
293  psets[0] = '\0';
294 
295  for (i = 0; i < 3; i++) {
296  pos = ps_pos[i];
297 
298  if (i > 0)
299  av_strlcat(psets, "; ", MAX_PSET_SIZE);
300  av_strlcatf(psets, MAX_PSET_SIZE, "sprop-%s=", ps_names[i]);
301 
302  // Skipping boundary checks in the input here; we've already traversed
303  // the whole hvcc structure above without issues
304  num_nalus = AV_RB16(&extradata[pos + 1]);
305  pos += 3;
306  for (j = 0; j < num_nalus; j++) {
307  int len = AV_RB16(&extradata[pos]);
308  int strpos;
309  pos += 2;
310  if (j > 0)
311  av_strlcat(psets, ",", MAX_PSET_SIZE);
312  strpos = strlen(psets);
313  if (!av_base64_encode(psets + strpos, MAX_PSET_SIZE - strpos,
314  &extradata[pos], len)) {
315  av_free(psets);
316  goto err;
317  }
318  pos += len;
319  }
320  }
321  av_free(tmpbuf);
322 
323  return psets;
324 
325 err:
326  av_free(tmpbuf);
327  return NULL;
328 }
329 
330 static char *extradata2config(AVFormatContext *s, AVCodecParameters *par)
331 {
332  char *config;
333 
334  if (par->extradata_size > MAX_EXTRADATA_SIZE) {
335  av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
336 
337  return NULL;
338  }
339  config = av_malloc(10 + par->extradata_size * 2);
340  if (!config) {
341  av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
342  return NULL;
343  }
344  memcpy(config, "; config=", 9);
345  ff_data_to_hex(config + 9, par->extradata, par->extradata_size, 0);
346  config[9 + par->extradata_size * 2] = 0;
347 
348  return config;
349 }
350 
351 static char *xiph_extradata2config(AVFormatContext *s, AVCodecParameters *par)
352 {
353  uint8_t *config;
354  char *encoded_config;
355  const uint8_t *header_start[3];
356  int headers_len, header_len[3], config_len;
357  int first_header_size;
358 
359  switch (par->codec_id) {
360  case AV_CODEC_ID_THEORA:
361  first_header_size = 42;
362  break;
363  case AV_CODEC_ID_VORBIS:
364  first_header_size = 30;
365  break;
366  default:
367  av_log(s, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
368  return NULL;
369  }
370 
372  first_header_size, header_start,
373  header_len) < 0) {
374  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
375  return NULL;
376  }
377 
378  headers_len = header_len[0] + header_len[2];
379  config_len = 4 + // count
380  3 + // ident
381  2 + // packet size
382  1 + // header count
383  2 + // header size
384  headers_len; // and the rest
385 
386  config = av_malloc(config_len);
387  if (!config)
388  goto xiph_fail;
389 
390  encoded_config = av_malloc(AV_BASE64_SIZE(config_len));
391  if (!encoded_config) {
392  av_free(config);
393  goto xiph_fail;
394  }
395 
396  config[0] = config[1] = config[2] = 0;
397  config[3] = 1;
398  config[4] = (RTP_XIPH_IDENT >> 16) & 0xff;
399  config[5] = (RTP_XIPH_IDENT >> 8) & 0xff;
400  config[6] = (RTP_XIPH_IDENT ) & 0xff;
401  config[7] = (headers_len >> 8) & 0xff;
402  config[8] = headers_len & 0xff;
403  config[9] = 2;
404  config[10] = header_len[0];
405  config[11] = 0; // size of comment header; nonexistent
406  memcpy(config + 12, header_start[0], header_len[0]);
407  memcpy(config + 12 + header_len[0], header_start[2], header_len[2]);
408 
409  av_base64_encode(encoded_config, AV_BASE64_SIZE(config_len),
410  config, config_len);
411  av_free(config);
412 
413  return encoded_config;
414 
415 xiph_fail:
417  "Not enough memory for configuration string\n");
418  return NULL;
419 }
420 
421 static int latm_context2profilelevel(AVCodecParameters *par)
422 {
423  /* MP4A-LATM
424  * The RTP payload format specification is described in RFC 3016
425  * The encoding specifications are provided in ISO/IEC 14496-3 */
426 
427  int profile_level = 0x2B;
428 
429  /* TODO: AAC Profile only supports AAC LC Object Type.
430  * Different Object Types should implement different Profile Levels */
431 
432  if (par->sample_rate <= 24000) {
433  if (par->channels <= 2)
434  profile_level = 0x28; // AAC Profile, Level 1
435  } else if (par->sample_rate <= 48000) {
436  if (par->channels <= 2) {
437  profile_level = 0x29; // AAC Profile, Level 2
438  } else if (par->channels <= 5) {
439  profile_level = 0x2A; // AAC Profile, Level 4
440  }
441  } else if (par->sample_rate <= 96000) {
442  if (par->channels <= 5) {
443  profile_level = 0x2B; // AAC Profile, Level 5
444  }
445  }
446 
447  return profile_level;
448 }
449 
450 static char *latm_context2config(AVFormatContext *s, AVCodecParameters *par)
451 {
452  /* MP4A-LATM
453  * The RTP payload format specification is described in RFC 3016
454  * The encoding specifications are provided in ISO/IEC 14496-3 */
455 
456  uint8_t config_byte[6];
457  int rate_index;
458  char *config;
459 
460  for (rate_index = 0; rate_index < 16; rate_index++)
461  if (avpriv_mpeg4audio_sample_rates[rate_index] == par->sample_rate)
462  break;
463  if (rate_index == 16) {
464  av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
465  return NULL;
466  }
467 
468  config_byte[0] = 0x40;
469  config_byte[1] = 0;
470  config_byte[2] = 0x20 | rate_index;
471  config_byte[3] = par->channels << 4;
472  config_byte[4] = 0x3f;
473  config_byte[5] = 0xc0;
474 
475  config = av_malloc(6*2+1);
476  if (!config) {
477  av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
478  return NULL;
479  }
480  ff_data_to_hex(config, config_byte, 6, 1);
481  config[12] = 0;
482 
483  return config;
484 }
485 
486 static char *sdp_write_media_attributes(char *buff, int size, AVStream *st, int payload_type, AVFormatContext *fmt)
487 {
488  char *config = NULL;
489  AVCodecParameters *p = st->codecpar;
490 
491  switch (p->codec_id) {
492  case AV_CODEC_ID_DIRAC:
493  av_strlcatf(buff, size, "a=rtpmap:%d VC2/90000\r\n", payload_type);
494  break;
495  case AV_CODEC_ID_H264: {
496  int mode = 1;
497  if (fmt && fmt->oformat && fmt->oformat->priv_class &&
498  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
499  mode = 0;
500  if (p->extradata_size) {
501  config = extradata2psets(fmt, p);
502  }
503  av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
504  "a=fmtp:%d packetization-mode=%d%s\r\n",
505  payload_type,
506  payload_type, mode, config ? config : "");
507  break;
508  }
509  case AV_CODEC_ID_H261:
510  {
511  const char *pic_fmt = NULL;
512  /* only QCIF and CIF are specified as supported in RFC 4587 */
513  if (p->width == 176 && p->height == 144)
514  pic_fmt = "QCIF=1";
515  else if (p->width == 352 && p->height == 288)
516  pic_fmt = "CIF=1";
517  if (payload_type >= RTP_PT_PRIVATE)
518  av_strlcatf(buff, size, "a=rtpmap:%d H261/90000\r\n", payload_type);
519  if (pic_fmt)
520  av_strlcatf(buff, size, "a=fmtp:%d %s\r\n", payload_type, pic_fmt);
521  break;
522  }
523  case AV_CODEC_ID_H263:
524  case AV_CODEC_ID_H263P:
525  /* a=framesize is required by 3GPP TS 26.234 (PSS). It
526  * actually specifies the maximum video size, but we only know
527  * the current size. This is required for playback on Android
528  * stagefright and on Samsung bada. */
529  if (!fmt || !fmt->oformat->priv_class ||
530  !av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") ||
532  av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
533  "a=framesize:%d %d-%d\r\n",
534  payload_type,
535  payload_type, p->width, p->height);
536  break;
537  case AV_CODEC_ID_HEVC:
538  if (p->extradata_size)
539  config = extradata2psets_hevc(p);
540  av_strlcatf(buff, size, "a=rtpmap:%d H265/90000\r\n", payload_type);
541  if (config)
542  av_strlcatf(buff, size, "a=fmtp:%d %s\r\n",
543  payload_type, config);
544  break;
545  case AV_CODEC_ID_MPEG4:
546  if (p->extradata_size) {
547  config = extradata2config(fmt, p);
548  }
549  av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
550  "a=fmtp:%d profile-level-id=1%s\r\n",
551  payload_type,
552  payload_type, config ? config : "");
553  break;
554  case AV_CODEC_ID_AAC:
555  if (fmt && fmt->oformat && fmt->oformat->priv_class &&
556  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
557  config = latm_context2config(fmt, p);
558  if (!config)
559  return NULL;
560  av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
561  "a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
562  payload_type, p->sample_rate, p->channels,
563  payload_type, latm_context2profilelevel(p), config);
564  } else {
565  if (p->extradata_size) {
566  config = extradata2config(fmt, p);
567  } else {
568  /* FIXME: maybe we can forge config information based on the
569  * codec parameters...
570  */
571  av_log(fmt, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
572  return NULL;
573  }
574  if (!config) {
575  return NULL;
576  }
577  av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
578  "a=fmtp:%d profile-level-id=1;"
579  "mode=AAC-hbr;sizelength=13;indexlength=3;"
580  "indexdeltalength=3%s\r\n",
581  payload_type, p->sample_rate, p->channels,
582  payload_type, config);
583  }
584  break;
586  if (payload_type >= RTP_PT_PRIVATE)
587  av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
588  payload_type,
589  p->sample_rate, p->channels);
590  break;
592  if (payload_type >= RTP_PT_PRIVATE)
593  av_strlcatf(buff, size, "a=rtpmap:%d L24/%d/%d\r\n",
594  payload_type,
595  p->sample_rate, p->channels);
596  break;
598  if (payload_type >= RTP_PT_PRIVATE)
599  av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
600  payload_type,
601  p->sample_rate, p->channels);
602  break;
604  if (payload_type >= RTP_PT_PRIVATE)
605  av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
606  payload_type,
607  p->sample_rate, p->channels);
608  break;
609  case AV_CODEC_ID_AMR_NB:
610  av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
611  "a=fmtp:%d octet-align=1\r\n",
612  payload_type, p->sample_rate, p->channels,
613  payload_type);
614  break;
615  case AV_CODEC_ID_AMR_WB:
616  av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
617  "a=fmtp:%d octet-align=1\r\n",
618  payload_type, p->sample_rate, p->channels,
619  payload_type);
620  break;
621  case AV_CODEC_ID_VORBIS:
622  if (p->extradata_size)
623  config = xiph_extradata2config(fmt, p);
624  else
625  av_log(fmt, AV_LOG_ERROR, "Vorbis configuration info missing\n");
626  if (!config)
627  return NULL;
628 
629  av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
630  "a=fmtp:%d configuration=%s\r\n",
631  payload_type, p->sample_rate, p->channels,
632  payload_type, config);
633  break;
634  case AV_CODEC_ID_THEORA: {
635  const char *pix_fmt;
636  switch (p->format) {
637  case AV_PIX_FMT_YUV420P:
638  pix_fmt = "YCbCr-4:2:0";
639  break;
640  case AV_PIX_FMT_YUV422P:
641  pix_fmt = "YCbCr-4:2:2";
642  break;
643  case AV_PIX_FMT_YUV444P:
644  pix_fmt = "YCbCr-4:4:4";
645  break;
646  default:
647  av_log(fmt, AV_LOG_ERROR, "Unsupported pixel format.\n");
648  return NULL;
649  }
650 
651  if (p->extradata_size)
652  config = xiph_extradata2config(fmt, p);
653  else
654  av_log(fmt, AV_LOG_ERROR, "Theora configuration info missing\n");
655  if (!config)
656  return NULL;
657 
658  av_strlcatf(buff, size, "a=rtpmap:%d theora/90000\r\n"
659  "a=fmtp:%d delivery-method=inline; "
660  "width=%d; height=%d; sampling=%s; "
661  "configuration=%s\r\n",
662  payload_type, payload_type,
663  p->width, p->height, pix_fmt, config);
664  break;
665  }
666  case AV_CODEC_ID_VP8:
667  av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
668  payload_type);
669  break;
670  case AV_CODEC_ID_VP9:
671  av_strlcatf(buff, size, "a=rtpmap:%d VP9/90000\r\n",
672  payload_type);
673  break;
674  case AV_CODEC_ID_MJPEG:
675  if (payload_type >= RTP_PT_PRIVATE)
676  av_strlcatf(buff, size, "a=rtpmap:%d JPEG/90000\r\n",
677  payload_type);
678  break;
680  if (payload_type >= RTP_PT_PRIVATE)
681  av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
682  payload_type,
683  8000, p->channels);
684  break;
685  case AV_CODEC_ID_ADPCM_G726: {
686  if (payload_type >= RTP_PT_PRIVATE)
687  av_strlcatf(buff, size, "a=rtpmap:%d AAL2-G726-%d/%d\r\n",
688  payload_type,
690  p->sample_rate);
691  break;
692  }
694  if (payload_type >= RTP_PT_PRIVATE)
695  av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
696  payload_type,
698  p->sample_rate);
699  break;
700  }
701  case AV_CODEC_ID_ILBC:
702  av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
703  "a=fmtp:%d mode=%d\r\n",
704  payload_type, p->sample_rate,
705  payload_type, p->block_align == 38 ? 20 : 30);
706  break;
707  case AV_CODEC_ID_SPEEX:
708  av_strlcatf(buff, size, "a=rtpmap:%d speex/%d\r\n",
709  payload_type, p->sample_rate);
710 #if FF_API_LAVF_AVCTX
712  if (st->codec) {
713  const char *mode;
714  uint64_t vad_option;
715 
716  if (st->codec->flags & AV_CODEC_FLAG_QSCALE)
717  mode = "on";
718  else if (!av_opt_get_int(st->codec, "vad", AV_OPT_FLAG_ENCODING_PARAM, &vad_option) && vad_option)
719  mode = "vad";
720  else
721  mode = "off";
722 
723  av_strlcatf(buff, size, "a=fmtp:%d vbr=%s\r\n",
724  payload_type, mode);
725  }
727 #endif
728  break;
729  case AV_CODEC_ID_OPUS:
730  /* The opus RTP draft says that all opus streams MUST be declared
731  as stereo, to avoid negotiation failures. The actual number of
732  channels can change on a packet-by-packet basis. The number of
733  channels a receiver prefers to receive or a sender plans to send
734  can be declared via fmtp parameters (both default to mono), but
735  receivers MUST be able to receive and process stereo packets. */
736  av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
737  payload_type);
738  if (p->channels == 2) {
739  av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo=1\r\n",
740  payload_type);
741  }
742  break;
743  default:
744  /* Nothing special to do here... */
745  break;
746  }
747 
748  av_free(config);
749 
750  return buff;
751 }
752 
753 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
754  const char *dest_addr, const char *dest_type,
755  int port, int ttl, AVFormatContext *fmt)
756 {
757  AVCodecParameters *p = st->codecpar;
758  const char *type;
759  int payload_type;
760 
761  payload_type = ff_rtp_get_payload_type(fmt, st->codecpar, idx);
762 
763  switch (p->codec_type) {
764  case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
765  case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
766  case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
767  default : type = "application"; break;
768  }
769 
770  av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
771  sdp_write_address(buff, size, dest_addr, dest_type, ttl);
772  if (p->bit_rate) {
773  av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", p->bit_rate / 1000);
774  }
775 
776  sdp_write_media_attributes(buff, size, st, payload_type, fmt);
777 }
778 
779 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
780 {
781  AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
782  struct sdp_session_level s = { 0 };
783  int i, j, port, ttl, is_multicast, index = 0;
784  char dst[32], dst_type[5];
785 
786  memset(buf, 0, size);
787  s.user = "-";
788  s.src_addr = "127.0.0.1"; /* FIXME: Properly set this */
789  s.src_type = "IP4";
790  s.name = title ? title->value : "No Name";
791 
792  port = 0;
793  ttl = 0;
794  if (n_files == 1) {
795  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->url ? ac[0]->url : "");
796  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
797  sizeof(dst_type));
798  if (!is_multicast)
799  ttl = 0;
800  if (dst[0]) {
801  s.dst_addr = dst;
802  s.dst_type = dst_type;
803  s.ttl = ttl;
804  if (!strcmp(dst_type, "IP6")) {
805  s.src_addr = "::1";
806  s.src_type = "IP6";
807  }
808  }
809  }
810  sdp_write_header(buf, size, &s);
811 
812  dst[0] = 0;
813  for (i = 0; i < n_files; i++) {
814  if (n_files != 1) {
815  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->url ? ac[i]->url : "");
816  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
817  sizeof(dst_type));
818  if (!is_multicast)
819  ttl = 0;
820  }
821  for (j = 0; j < ac[i]->nb_streams; j++) {
822  ff_sdp_write_media(buf, size, ac[i]->streams[j], index++,
823  dst[0] ? dst : NULL, dst_type,
824  (port > 0) ? port + j * 2 : 0,
825  ttl, ac[i]);
826  if (port <= 0) {
827  av_strlcatf(buf, size,
828  "a=control:streamid=%d\r\n", i + j);
829  }
830  if (ac[i]->pb && ac[i]->pb->av_class) {
831  uint8_t *crypto_suite = NULL, *crypto_params = NULL;
832  av_opt_get(ac[i]->pb, "srtp_out_suite", AV_OPT_SEARCH_CHILDREN,
833  &crypto_suite);
834  av_opt_get(ac[i]->pb, "srtp_out_params", AV_OPT_SEARCH_CHILDREN,
835  &crypto_params);
836  if (crypto_suite && crypto_suite[0])
837  av_strlcatf(buf, size,
838  "a=crypto:1 %s inline:%s\r\n",
839  crypto_suite, crypto_params);
840  av_free(crypto_suite);
841  av_free(crypto_params);
842  }
843  }
844  }
845 
846  return 0;
847 }
848 #else
849 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
850 {
851  return AVERROR(ENOSYS);
852 }
853 
854 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
855  const char *dest_addr, const char *dest_type,
856  int port, int ttl, AVFormatContext *fmt)
857 {
858 }
859 #endif
uint8_t
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:67
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:221
Main libavformat public API header.
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1427
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1382
#define AV_RB16
Definition: intreadwrite.h:53
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)
#define s(width, name)
Definition: cbs_vp9.c:257
#define NULL
Definition: coverity.c:32
static enum AVPixelFormat pix_fmt
Public dictionary API.
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
enum AVCodecID id
static int64_t start_time
Definition: ffplay.c:332
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
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:165
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:326
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:429
@ AV_CODEC_ID_H261
Definition: codec_id.h:52
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:381
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:314
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:389
@ AV_CODEC_ID_VP8
Definition: codec_id.h:189
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:320
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:406
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:79
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:364
@ AV_CODEC_ID_AAC
Definition: codec_id.h:426
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:407
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:459
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:483
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
@ AV_CODEC_ID_H263P
Definition: codec_id.h:68
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:484
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:319
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:4799
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
Generate an SDP for an RTP session.
Definition: sdp.c:849
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:145
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
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
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
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 av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:912
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:779
#define AV_STRINGIFY(s)
Definition: macros.h:36
int index
Definition: gxfenc.c:89
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:1068
cl_device_type type
int i
Definition: input.c:407
#define MAX_EXTRADATA_SIZE
Definition: latmenc.c:31
internal header for HEVC (de)muxer utilities
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Definition: utils.c:4896
#define LIBAVFORMAT_VERSION
Definition: version.h:41
common internal API header
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
version
Definition: libkvazaar.c:326
const int avpriv_mpeg4audio_sample_rates[16]
Definition: mpeg4audio.c:62
int ff_is_multicast_address(struct sockaddr *addr)
Definition: network.c:145
#define NI_NUMERICHOST
Definition: network.h:195
#define getaddrinfo
Definition: network.h:217
#define getnameinfo
Definition: network.h:219
#define freeaddrinfo
Definition: network.h:218
AVOptions.
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
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
misc parsing utilities
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
const char * name
Definition: qsvenc.c:46
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
#define RTP_PT_PRIVATE
Definition: rtp.h:77
#define RTP_XIPH_IDENT
Definition: rtp.h:89
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:854
unsigned int pos
Definition: spdifenc.c:412
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int channels
Audio only.
Definition: codec_par.h:166
int width
Video only.
Definition: codec_par.h:126
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
int block_align
Audio only.
Definition: codec_par.h:177
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
char * value
Definition: dict.h:83
Format I/O context.
Definition: avformat.h:1232
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1288
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1251
void * priv_data
Format private data.
Definition: avformat.h:1260
Bytestream IO Context.
Definition: avio.h:161
const AVClass * av_class
A class for private options.
Definition: avio.h:174
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:519
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
attribute_deprecated AVCodecContext * codec
Definition: avformat.h:886
#define av_free(p)
#define av_malloc(s)
#define av_log(a,...)
int size
const char * r
Definition: vf_curves.c:116
int len
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