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 "config_components.h"
22 
23 #include <string.h>
24 #include "libavutil/avstring.h"
25 #include "libavutil/base64.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/parseutils.h"
29 #include "libavutil/opt.h"
30 #include "libavcodec/xiph.h"
31 #include "libavcodec/mpeg4audio.h"
32 #include "avformat.h"
33 #include "internal.h"
34 #include "avc.h"
35 #include "hevc.h"
36 #include "rtp.h"
37 #include "version.h"
38 #if CONFIG_NETWORK
39 #include "network.h"
40 #endif
41 
42 #if CONFIG_RTP_MUXER
43 #define MAX_EXTRADATA_SIZE ((INT_MAX - 10) / 2)
44 
45 struct sdp_session_level {
46  int sdp_version; /**< protocol version (currently 0) */
47  int id; /**< session ID */
48  int version; /**< session version */
49  int start_time; /**< session start time (NTP time, in seconds),
50  or 0 in case of permanent session */
51  int end_time; /**< session end time (NTP time, in seconds),
52  or 0 if the session is not bounded */
53  int ttl; /**< TTL, in case of multicast stream */
54  const char *user; /**< username of the session's creator */
55  const char *src_addr; /**< IP address of the machine from which the session was created */
56  const char *src_type; /**< address type of src_addr */
57  const char *dst_addr; /**< destination IP address (can be multicast) */
58  const char *dst_type; /**< destination IP address type */
59  const char *name; /**< session name (can be an empty string) */
60 };
61 
62 static void sdp_write_address(char *buff, int size, const char *dest_addr,
63  const char *dest_type, int ttl)
64 {
65  if (dest_addr) {
66  if (!dest_type)
67  dest_type = "IP4";
68  if (ttl > 0 && !strcmp(dest_type, "IP4")) {
69  /* The TTL should only be specified for IPv4 multicast addresses,
70  * not for IPv6. */
71  av_strlcatf(buff, size, "c=IN %s %s/%d\r\n", dest_type, dest_addr, ttl);
72  } else {
73  av_strlcatf(buff, size, "c=IN %s %s\r\n", dest_type, dest_addr);
74  }
75  }
76 }
77 
78 static void sdp_write_header(char *buff, int size, struct sdp_session_level *s)
79 {
80  av_strlcatf(buff, size, "v=%d\r\n"
81  "o=- %d %d IN %s %s\r\n"
82  "s=%s\r\n",
83  s->sdp_version,
84  s->id, s->version, s->src_type, s->src_addr,
85  s->name);
86  sdp_write_address(buff, size, s->dst_addr, s->dst_type, s->ttl);
87  av_strlcatf(buff, size, "t=%d %d\r\n"
88  "a=tool:libavformat " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\r\n",
89  s->start_time, s->end_time);
90 }
91 
92 #if CONFIG_NETWORK
93 static int resolve_destination(char *dest_addr, int size, char *type,
94  int type_size)
95 {
96  struct addrinfo hints = { 0 }, *ai;
97  int is_multicast;
98 
99  av_strlcpy(type, "IP4", type_size);
100  if (!dest_addr[0])
101  return 0;
102 
103  /* Resolve the destination, since it must be written
104  * as a numeric IP address in the SDP. */
105 
106  if (getaddrinfo(dest_addr, NULL, &hints, &ai))
107  return 0;
108  getnameinfo(ai->ai_addr, ai->ai_addrlen, dest_addr, size,
109  NULL, 0, NI_NUMERICHOST);
110 #ifdef AF_INET6
111  if (ai->ai_family == AF_INET6)
112  av_strlcpy(type, "IP6", type_size);
113 #endif
114  is_multicast = ff_is_multicast_address(ai->ai_addr);
115  freeaddrinfo(ai);
116  return is_multicast;
117 }
118 #else
119 static int resolve_destination(char *dest_addr, int size, char *type,
120  int type_size)
121 {
122  return 0;
123 }
124 #endif
125 
126 static int sdp_get_address(char *dest_addr, int size, int *ttl, const char *url)
127 {
128  int port;
129  const char *p;
130  char proto[32];
131 
132  av_url_split(proto, sizeof(proto), NULL, 0, dest_addr, size, &port, NULL, 0, url);
133 
134  *ttl = 0;
135 
136  if (strcmp(proto, "rtp") && strcmp(proto, "srtp")) {
137  /* The url isn't for the actual rtp sessions,
138  * don't parse out anything else than the destination.
139  */
140  return 0;
141  }
142 
143  p = strchr(url, '?');
144  if (p) {
145  char buff[64];
146 
147  if (av_find_info_tag(buff, sizeof(buff), "ttl", p)) {
148  *ttl = strtol(buff, NULL, 10);
149  } else {
150  *ttl = 5;
151  }
152  }
153 
154  return port;
155 }
156 
157 #define MAX_PSET_SIZE 1024
158 static int extradata2psets(AVFormatContext *s, const AVCodecParameters *par,
159  char **out)
160 {
161  char *psets, *p;
162  const uint8_t *r;
163  static const char pset_string[] = "; sprop-parameter-sets=";
164  static const char profile_string[] = "; profile-level-id=";
165  uint8_t *extradata = par->extradata;
166  int extradata_size = par->extradata_size;
167  uint8_t *tmpbuf = NULL;
168  const uint8_t *sps = NULL, *sps_end;
169 
170  *out = NULL;
171 
172  if (par->extradata_size > MAX_EXTRADATA_SIZE) {
173  av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
174  return AVERROR_INVALIDDATA;
175  }
176  if (par->extradata[0] == 1) {
177  int ret = ff_avc_write_annexb_extradata(par->extradata, &extradata,
178  &extradata_size);
179  if (ret < 0)
180  return ret;
181 
182  tmpbuf = extradata;
183  }
184 
185  psets = av_mallocz(MAX_PSET_SIZE);
186  if (!psets) {
187  av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
188  av_free(tmpbuf);
189  return AVERROR(ENOMEM);
190  }
191  memcpy(psets, pset_string, strlen(pset_string));
192  p = psets + strlen(pset_string);
193  r = ff_avc_find_startcode(extradata, extradata + extradata_size);
194  while (r < extradata + extradata_size) {
195  const uint8_t *r1;
196  uint8_t nal_type;
197 
198  while (!*(r++));
199  nal_type = *r & 0x1f;
200  r1 = ff_avc_find_startcode(r, extradata + extradata_size);
201  if (nal_type != 7 && nal_type != 8) { /* Only output SPS and PPS */
202  r = r1;
203  continue;
204  }
205  if (p != (psets + strlen(pset_string))) {
206  *p = ',';
207  p++;
208  }
209  if (!sps) {
210  sps = r;
211  sps_end = r1;
212  }
213  if (!av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r)) {
214  av_log(s, AV_LOG_ERROR, "Cannot Base64-encode %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"!\n",
215  MAX_PSET_SIZE - (p - psets), r1 - r);
216  av_free(psets);
217  av_free(tmpbuf);
218 
219  return AVERROR_INVALIDDATA;
220  }
221  p += strlen(p);
222  r = r1;
223  }
224  if (sps && sps_end - sps >= 4 && p - psets <= MAX_PSET_SIZE - strlen(profile_string) - 7) {
225  memcpy(p, profile_string, strlen(profile_string));
226  p += strlen(p);
227  ff_data_to_hex(p, sps + 1, 3, 0);
228  }
229  av_free(tmpbuf);
230 
231  *out = psets;
232  return 0;
233 }
234 
235 static int extradata2psets_hevc(const AVCodecParameters *par, char **out)
236 {
237  char *psets;
238  uint8_t *extradata = par->extradata;
239  int extradata_size = par->extradata_size;
240  uint8_t *tmpbuf = NULL;
241  int ps_pos[3] = { 0 };
242  static const char * const ps_names[3] = { "vps", "sps", "pps" };
243  int num_arrays, num_nalus;
244  int pos, i, j, ret = 0;
245 
246  *out = NULL;
247 
248  // Convert to hvcc format. Since we need to group multiple NALUs of
249  // the same type, and we might need to convert from one format to the
250  // other anyway, we get away with a little less work by using the hvcc
251  // format.
252  if (par->extradata[0] != 1) {
253  AVIOContext *pb;
254 
255  ret = avio_open_dyn_buf(&pb);
256  if (ret < 0)
257  return ret;
258 
259  ret = ff_isom_write_hvcc(pb, par->extradata, par->extradata_size, 0);
260  if (ret < 0) {
261  avio_close_dyn_buf(pb, &tmpbuf);
262  goto err;
263  }
264  extradata_size = avio_close_dyn_buf(pb, &extradata);
265  tmpbuf = extradata;
266  }
267 
268  if (extradata_size < 23)
269  goto err;
270 
271  num_arrays = extradata[22];
272  pos = 23;
273  for (i = 0; i < num_arrays; i++) {
274  int num_nalus, nalu_type;
275  if (pos + 3 > extradata_size)
276  goto err;
277  nalu_type = extradata[pos] & 0x3f;
278  // Not including libavcodec/hevc.h to avoid confusion between
279  // NAL_* with the same name for both H.264 and HEVC.
280  if (nalu_type == 32) // VPS
281  ps_pos[0] = pos;
282  else if (nalu_type == 33) // SPS
283  ps_pos[1] = pos;
284  else if (nalu_type == 34) // PPS
285  ps_pos[2] = pos;
286  num_nalus = AV_RB16(&extradata[pos + 1]);
287  pos += 3;
288  for (j = 0; j < num_nalus; j++) {
289  int len;
290  if (pos + 2 > extradata_size)
291  goto err;
292  len = AV_RB16(&extradata[pos]);
293  pos += 2;
294  if (pos + len > extradata_size)
295  goto err;
296  pos += len;
297  }
298  }
299  if (!ps_pos[0] || !ps_pos[1] || !ps_pos[2])
300  goto err;
301 
302  psets = av_mallocz(MAX_PSET_SIZE);
303  if (!psets) {
304  ret = AVERROR(ENOMEM);
305  goto err;
306  }
307 
308  psets[0] = '\0';
309 
310  for (i = 0; i < 3; i++) {
311  pos = ps_pos[i];
312 
313  if (i > 0)
314  av_strlcat(psets, "; ", MAX_PSET_SIZE);
315  av_strlcatf(psets, MAX_PSET_SIZE, "sprop-%s=", ps_names[i]);
316 
317  // Skipping boundary checks in the input here; we've already traversed
318  // the whole hvcc structure above without issues
319  num_nalus = AV_RB16(&extradata[pos + 1]);
320  pos += 3;
321  for (j = 0; j < num_nalus; j++) {
322  int len = AV_RB16(&extradata[pos]);
323  int strpos;
324  pos += 2;
325  if (j > 0)
326  av_strlcat(psets, ",", MAX_PSET_SIZE);
327  strpos = strlen(psets);
328  if (!av_base64_encode(psets + strpos, MAX_PSET_SIZE - strpos,
329  &extradata[pos], len)) {
330  av_free(psets);
331  goto err;
332  }
333  pos += len;
334  }
335  }
336  av_free(tmpbuf);
337 
338  *out = psets;
339  return 0;
340 err:
341  if (ret >= 0)
343  av_free(tmpbuf);
344  return ret;
345 }
346 
347 static int extradata2config(AVFormatContext *s, const AVCodecParameters *par,
348  char **out)
349 {
350  char *config;
351 
352  *out = NULL;
353 
354  if (par->extradata_size > MAX_EXTRADATA_SIZE) {
355  av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
356  return AVERROR_INVALIDDATA;
357  }
358  config = av_malloc(10 + par->extradata_size * 2);
359  if (!config) {
360  av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
361  return AVERROR(ENOMEM);
362  }
363  memcpy(config, "; config=", 9);
364  ff_data_to_hex(config + 9, par->extradata, par->extradata_size, 0);
365 
366  *out = config;
367  return 0;
368 }
369 
370 static int xiph_extradata2config(AVFormatContext *s, const AVCodecParameters *par,
371  char **out)
372 {
373  uint8_t *config;
374  char *encoded_config;
375  const uint8_t *header_start[3];
376  int headers_len, header_len[3], config_len;
377  int first_header_size, ret;
378 
379  *out = NULL;
380 
381  switch (par->codec_id) {
382  case AV_CODEC_ID_THEORA:
383  first_header_size = 42;
384  break;
385  case AV_CODEC_ID_VORBIS:
386  first_header_size = 30;
387  break;
388  default:
389  av_log(s, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
390  return AVERROR(ENOSYS);
391  }
392 
394  first_header_size, header_start,
395  header_len);
396  if (ret < 0) {
397  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
398  return ret;
399  }
400 
401  headers_len = header_len[0] + header_len[2];
402  config_len = 4 + // count
403  3 + // ident
404  2 + // packet size
405  1 + // header count
406  2 + // header size
407  headers_len; // and the rest
408 
409  config = av_malloc(config_len);
410  if (!config)
411  goto xiph_fail;
412 
413  encoded_config = av_malloc(AV_BASE64_SIZE(config_len));
414  if (!encoded_config) {
415  av_free(config);
416  goto xiph_fail;
417  }
418 
419  config[0] = config[1] = config[2] = 0;
420  config[3] = 1;
421  config[4] = (RTP_XIPH_IDENT >> 16) & 0xff;
422  config[5] = (RTP_XIPH_IDENT >> 8) & 0xff;
423  config[6] = (RTP_XIPH_IDENT ) & 0xff;
424  config[7] = (headers_len >> 8) & 0xff;
425  config[8] = headers_len & 0xff;
426  config[9] = 2;
427  config[10] = header_len[0];
428  config[11] = 0; // size of comment header; nonexistent
429  memcpy(config + 12, header_start[0], header_len[0]);
430  memcpy(config + 12 + header_len[0], header_start[2], header_len[2]);
431 
432  av_base64_encode(encoded_config, AV_BASE64_SIZE(config_len),
433  config, config_len);
434  av_free(config);
435 
436  *out = encoded_config;
437  return 0;
438 
439 xiph_fail:
441  "Not enough memory for configuration string\n");
442  return AVERROR(ENOMEM);
443 }
444 
445 static int latm_context2profilelevel(const AVCodecParameters *par)
446 {
447  /* MP4A-LATM
448  * The RTP payload format specification is described in RFC 3016
449  * The encoding specifications are provided in ISO/IEC 14496-3 */
450 
451  int profile_level = 0x2B;
452 
453  /* TODO: AAC Profile only supports AAC LC Object Type.
454  * Different Object Types should implement different Profile Levels */
455 
456  if (par->sample_rate <= 24000) {
457  if (par->ch_layout.nb_channels <= 2)
458  profile_level = 0x28; // AAC Profile, Level 1
459  } else if (par->sample_rate <= 48000) {
460  if (par->ch_layout.nb_channels <= 2) {
461  profile_level = 0x29; // AAC Profile, Level 2
462  } else if (par->ch_layout.nb_channels <= 5) {
463  profile_level = 0x2A; // AAC Profile, Level 4
464  }
465  } else if (par->sample_rate <= 96000) {
466  if (par->ch_layout.nb_channels <= 5) {
467  profile_level = 0x2B; // AAC Profile, Level 5
468  }
469  }
470 
471  return profile_level;
472 }
473 
474 static int latm_context2config(AVFormatContext *s, const AVCodecParameters *par,
475  char **out)
476 {
477  /* MP4A-LATM
478  * The RTP payload format specification is described in RFC 3016
479  * The encoding specifications are provided in ISO/IEC 14496-3 */
480 
481  uint8_t config_byte[6];
482  int rate_index;
483  char *config;
484 
485  *out = NULL;
486 
487  for (rate_index = 0; rate_index < 16; rate_index++)
488  if (ff_mpeg4audio_sample_rates[rate_index] == par->sample_rate)
489  break;
490  if (rate_index == 16) {
491  av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
492  return AVERROR(ENOSYS);
493  }
494 
495  config_byte[0] = 0x40;
496  config_byte[1] = 0;
497  config_byte[2] = 0x20 | rate_index;
498  config_byte[3] = par->ch_layout.nb_channels << 4;
499  config_byte[4] = 0x3f;
500  config_byte[5] = 0xc0;
501 
502  config = av_malloc(6*2+1);
503  if (!config) {
504  av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
505  return AVERROR(ENOMEM);
506  }
507  ff_data_to_hex(config, config_byte, 6, 1);
508 
509  *out = config;
510  return 0;
511 }
512 
513 static int sdp_write_media_attributes(char *buff, int size, const AVStream *st,
514  int payload_type, AVFormatContext *fmt)
515 {
516  char *config = NULL;
517  const AVCodecParameters *p = st->codecpar;
518  int ret = 0;
519 
520  switch (p->codec_id) {
521  case AV_CODEC_ID_DIRAC:
522  av_strlcatf(buff, size, "a=rtpmap:%d VC2/90000\r\n", payload_type);
523  break;
524  case AV_CODEC_ID_H264: {
525  int mode = 1;
526  if (fmt && fmt->oformat && fmt->oformat->priv_class &&
527  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
528  mode = 0;
529  if (p->extradata_size) {
530  ret = extradata2psets(fmt, p, &config);
531  if (ret < 0)
532  return ret;
533  }
534  av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
535  "a=fmtp:%d packetization-mode=%d%s\r\n",
536  payload_type,
537  payload_type, mode, config ? config : "");
538  break;
539  }
540  case AV_CODEC_ID_H261:
541  {
542  const char *pic_fmt = NULL;
543  /* only QCIF and CIF are specified as supported in RFC 4587 */
544  if (p->width == 176 && p->height == 144)
545  pic_fmt = "QCIF=1";
546  else if (p->width == 352 && p->height == 288)
547  pic_fmt = "CIF=1";
548  if (payload_type >= RTP_PT_PRIVATE)
549  av_strlcatf(buff, size, "a=rtpmap:%d H261/90000\r\n", payload_type);
550  if (pic_fmt)
551  av_strlcatf(buff, size, "a=fmtp:%d %s\r\n", payload_type, pic_fmt);
552  break;
553  }
554  case AV_CODEC_ID_H263:
555  case AV_CODEC_ID_H263P:
556  /* a=framesize is required by 3GPP TS 26.234 (PSS). It
557  * actually specifies the maximum video size, but we only know
558  * the current size. This is required for playback on Android
559  * stagefright and on Samsung bada. */
560  if (!fmt || !fmt->oformat->priv_class ||
561  !av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") ||
563  av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
564  "a=framesize:%d %d-%d\r\n",
565  payload_type,
566  payload_type, p->width, p->height);
567  break;
568  case AV_CODEC_ID_HEVC:
569  if (p->extradata_size) {
570  ret = extradata2psets_hevc(p, &config);
571  if (ret < 0)
572  return ret;
573  }
574  av_strlcatf(buff, size, "a=rtpmap:%d H265/90000\r\n", payload_type);
575  if (config)
576  av_strlcatf(buff, size, "a=fmtp:%d %s\r\n",
577  payload_type, config);
578  break;
579  case AV_CODEC_ID_MPEG4:
580  if (p->extradata_size) {
581  ret = extradata2config(fmt, p, &config);
582  if (ret < 0)
583  return ret;
584  }
585  av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
586  "a=fmtp:%d profile-level-id=1%s\r\n",
587  payload_type,
588  payload_type, config ? config : "");
589  break;
590  case AV_CODEC_ID_AAC:
591  if (fmt && fmt->oformat && fmt->oformat->priv_class &&
592  av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
593  ret = latm_context2config(fmt, p, &config);
594  if (ret < 0)
595  return ret;
596  av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
597  "a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
598  payload_type, p->sample_rate, p->ch_layout.nb_channels,
599  payload_type, latm_context2profilelevel(p), config);
600  } else {
601  if (p->extradata_size) {
602  ret = extradata2config(fmt, p, &config);
603  if (ret < 0)
604  return ret;
605  } else {
606  /* FIXME: maybe we can forge config information based on the
607  * codec parameters...
608  */
609  av_log(fmt, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
610  return AVERROR(ENOSYS);
611  }
612  av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
613  "a=fmtp:%d profile-level-id=1;"
614  "mode=AAC-hbr;sizelength=13;indexlength=3;"
615  "indexdeltalength=3%s\r\n",
616  payload_type, p->sample_rate, p->ch_layout.nb_channels,
617  payload_type, config);
618  }
619  break;
621  if (payload_type >= RTP_PT_PRIVATE)
622  av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
623  payload_type,
625  break;
627  if (payload_type >= RTP_PT_PRIVATE)
628  av_strlcatf(buff, size, "a=rtpmap:%d L24/%d/%d\r\n",
629  payload_type,
631  break;
633  if (payload_type >= RTP_PT_PRIVATE)
634  av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
635  payload_type,
637  break;
639  if (payload_type >= RTP_PT_PRIVATE)
640  av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
641  payload_type,
643  break;
644  case AV_CODEC_ID_AMR_NB:
645  av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
646  "a=fmtp:%d octet-align=1\r\n",
647  payload_type, p->sample_rate, p->ch_layout.nb_channels,
648  payload_type);
649  break;
650  case AV_CODEC_ID_AMR_WB:
651  av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
652  "a=fmtp:%d octet-align=1\r\n",
653  payload_type, p->sample_rate, p->ch_layout.nb_channels,
654  payload_type);
655  break;
656  case AV_CODEC_ID_VORBIS:
657  if (p->extradata_size)
658  ret = xiph_extradata2config(fmt, p, &config);
659  else {
660  av_log(fmt, AV_LOG_ERROR, "Vorbis configuration info missing\n");
662  }
663  if (ret < 0)
664  return ret;
665 
666  av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
667  "a=fmtp:%d configuration=%s\r\n",
668  payload_type, p->sample_rate, p->ch_layout.nb_channels,
669  payload_type, config);
670  break;
671  case AV_CODEC_ID_THEORA: {
672  const char *pix_fmt;
673  switch (p->format) {
674  case AV_PIX_FMT_YUV420P:
675  pix_fmt = "YCbCr-4:2:0";
676  break;
677  case AV_PIX_FMT_YUV422P:
678  pix_fmt = "YCbCr-4:2:2";
679  break;
680  case AV_PIX_FMT_YUV444P:
681  pix_fmt = "YCbCr-4:4:4";
682  break;
683  default:
684  av_log(fmt, AV_LOG_ERROR, "Unsupported pixel format.\n");
685  return AVERROR(ENOSYS);
686  }
687 
688  if (p->extradata_size)
689  ret = xiph_extradata2config(fmt, p, &config);
690  else {
691  av_log(fmt, AV_LOG_ERROR, "Theora configuration info missing\n");
693  }
694  if (ret < 0)
695  return ret;
696 
697  av_strlcatf(buff, size, "a=rtpmap:%d theora/90000\r\n"
698  "a=fmtp:%d delivery-method=inline; "
699  "width=%d; height=%d; sampling=%s; "
700  "configuration=%s\r\n",
701  payload_type, payload_type,
702  p->width, p->height, pix_fmt, config);
703  break;
704  }
706  case AV_CODEC_ID_RAWVIDEO: {
707  const char *pix_fmt;
708  int bit_depth = 8;
709 
710  switch (p->format) {
711  case AV_PIX_FMT_UYVY422:
712  pix_fmt = "YCbCr-4:2:2";
713  break;
715  pix_fmt = "YCbCr-4:2:2";
716  bit_depth = 10;
717  break;
718  case AV_PIX_FMT_YUV420P:
719  pix_fmt = "YCbCr-4:2:0";
720  break;
721  case AV_PIX_FMT_RGB24:
722  pix_fmt = "RGB";
723  break;
724  case AV_PIX_FMT_BGR24:
725  pix_fmt = "BGR";
726  break;
727  default:
728  av_log(fmt, AV_LOG_ERROR, "Unsupported pixel format.\n");
729  return AVERROR(ENOSYS);
730  }
731 
732  av_strlcatf(buff, size, "a=rtpmap:%d raw/90000\r\n"
733  "a=fmtp:%d sampling=%s; "
734  "width=%d; height=%d; "
735  "depth=%d",
736  payload_type, payload_type,
737  pix_fmt, p->width, p->height, bit_depth);
739  av_strlcatf(buff, size, "; interlace");
740  av_strlcatf(buff, size, "\r\n");
741  break;
742  }
743 
744  case AV_CODEC_ID_VP8:
745  av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
746  payload_type);
747  break;
748  case AV_CODEC_ID_VP9:
749  av_strlcatf(buff, size, "a=rtpmap:%d VP9/90000\r\n",
750  payload_type);
751  break;
752  case AV_CODEC_ID_MJPEG:
753  if (payload_type >= RTP_PT_PRIVATE)
754  av_strlcatf(buff, size, "a=rtpmap:%d JPEG/90000\r\n",
755  payload_type);
756  break;
758  if (payload_type >= RTP_PT_PRIVATE)
759  av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
760  payload_type,
761  8000, p->ch_layout.nb_channels);
762  break;
763  case AV_CODEC_ID_ADPCM_G726: {
764  if (payload_type >= RTP_PT_PRIVATE)
765  av_strlcatf(buff, size, "a=rtpmap:%d AAL2-G726-%d/%d\r\n",
766  payload_type,
768  p->sample_rate);
769  break;
770  }
772  if (payload_type >= RTP_PT_PRIVATE)
773  av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
774  payload_type,
776  p->sample_rate);
777  break;
778  }
779  case AV_CODEC_ID_ILBC:
780  av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
781  "a=fmtp:%d mode=%d\r\n",
782  payload_type, p->sample_rate,
783  payload_type, p->block_align == 38 ? 20 : 30);
784  break;
785  case AV_CODEC_ID_SPEEX:
786  av_strlcatf(buff, size, "a=rtpmap:%d speex/%d\r\n",
787  payload_type, p->sample_rate);
788  break;
789  case AV_CODEC_ID_OPUS:
790  /* The opus RTP draft says that all opus streams MUST be declared
791  as stereo, to avoid negotiation failures. The actual number of
792  channels can change on a packet-by-packet basis. The number of
793  channels a receiver prefers to receive or a sender plans to send
794  can be declared via fmtp parameters (both default to mono), but
795  receivers MUST be able to receive and process stereo packets. */
796  av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
797  payload_type);
798  if (p->ch_layout.nb_channels == 2) {
799  av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo=1\r\n",
800  payload_type);
801  }
802  break;
803  default:
804  /* Nothing special to do here... */
805  break;
806  }
807 
808  av_free(config);
809 
810  return 0;
811 }
812 
813 int ff_sdp_write_media(char *buff, int size, const AVStream *st, int idx,
814  const char *dest_addr, const char *dest_type,
815  int port, int ttl, AVFormatContext *fmt)
816 {
817  const AVCodecParameters *p = st->codecpar;
818  const char *type;
819  int payload_type;
820 
821  payload_type = ff_rtp_get_payload_type(fmt, st->codecpar, idx);
822 
823  switch (p->codec_type) {
824  case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
825  case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
826  case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
827  default : type = "application"; break;
828  }
829 
830  av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
831  sdp_write_address(buff, size, dest_addr, dest_type, ttl);
832  if (p->bit_rate) {
833  av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", p->bit_rate / 1000);
834  }
835 
836  return sdp_write_media_attributes(buff, size, st, payload_type, fmt);
837 }
838 
839 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
840 {
841  AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
842  struct sdp_session_level s = { 0 };
843  int i, j, port, ttl, is_multicast, index = 0;
844  char dst[32], dst_type[5];
845 
846  memset(buf, 0, size);
847  s.user = "-";
848  s.src_addr = "127.0.0.1"; /* FIXME: Properly set this */
849  s.src_type = "IP4";
850  s.name = title ? title->value : "No Name";
851 
852  port = 0;
853  ttl = 0;
854  if (n_files == 1) {
855  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->url ? ac[0]->url : "");
856  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
857  sizeof(dst_type));
858  if (!is_multicast)
859  ttl = 0;
860  if (dst[0]) {
861  s.dst_addr = dst;
862  s.dst_type = dst_type;
863  s.ttl = ttl;
864  if (!strcmp(dst_type, "IP6")) {
865  s.src_addr = "::1";
866  s.src_type = "IP6";
867  }
868  }
869  }
870  sdp_write_header(buf, size, &s);
871 
872  dst[0] = 0;
873  for (i = 0; i < n_files; i++) {
874  if (n_files != 1) {
875  port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->url ? ac[i]->url : "");
876  is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
877  sizeof(dst_type));
878  if (!is_multicast)
879  ttl = 0;
880  }
881  for (j = 0; j < ac[i]->nb_streams; j++) {
882  int ret = ff_sdp_write_media(buf, size, ac[i]->streams[j], index++,
883  dst[0] ? dst : NULL, dst_type,
884  (port > 0) ? port + j * 2 : 0,
885  ttl, ac[i]);
886  if (ret < 0)
887  return ret;
888 
889  if (port <= 0) {
890  av_strlcatf(buf, size,
891  "a=control:streamid=%d\r\n", i + j);
892  }
893  if (ac[i]->pb && ac[i]->pb->av_class) {
894  uint8_t *crypto_suite = NULL, *crypto_params = NULL;
895  av_opt_get(ac[i]->pb, "srtp_out_suite", AV_OPT_SEARCH_CHILDREN,
896  &crypto_suite);
897  av_opt_get(ac[i]->pb, "srtp_out_params", AV_OPT_SEARCH_CHILDREN,
898  &crypto_params);
899  if (crypto_suite && crypto_suite[0])
900  av_strlcatf(buf, size,
901  "a=crypto:1 %s inline:%s\r\n",
902  crypto_suite, crypto_params);
903  av_free(crypto_suite);
904  av_free(crypto_params);
905  }
906  }
907  }
908 
909  return 0;
910 }
911 #else
912 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
913 {
914  return AVERROR(ENOSYS);
915 }
916 
917 int ff_sdp_write_media(char *buff, int size, const AVStream *st, int idx,
918  const char *dest_addr, const char *dest_type,
919  int port, int ttl, AVFormatContext *fmt)
920 {
921  return AVERROR(ENOSYS);
922 }
923 #endif
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:533
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:69
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:127
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:753
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:1354
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
hevc.h
out
FILE * out
Definition: movenc.c:55
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:200
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:168
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:421
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:395
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
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:422
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:55
xiph.h
freeaddrinfo
#define freeaddrinfo
Definition: network.h:218
mpeg4audio.h
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:475
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:329
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)
Write hexadecimal string corresponding to given binary data.
Definition: utils.c:443
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:1407
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:62
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1362
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:378
s
#define s(width, name)
Definition: cbs_vp9.c:198
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:334
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:73
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:335
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
RTP_PT_PRIVATE
#define RTP_PT_PRIVATE
Definition: rtp.h:79
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:128
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:150
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:538
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
base64.h
index
int index
Definition: gxfenc.c:90
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
NI_NUMERICHOST
#define NI_NUMERICHOST
Definition: network.h:195
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
RTP_XIPH_IDENT
#define RTP_XIPH_IDENT
Definition: rtp.h:91
start_time
static int64_t start_time
Definition: ffplay.c:326
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
size
int size
Definition: twinvq_data.h:10344
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:500
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:912
version
version
Definition: libkvazaar.c:321
AV_CODEC_ID_BITPACKED
@ AV_CODEC_ID_BITPACKED
Definition: codec_id.h:281
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:1043
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AV_CODEC_ID_THEORA
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:82
getnameinfo
#define getnameinfo
Definition: network.h:219
AVCodecParameters::height
int height
Definition: codec_par.h:135
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
MAX_EXTRADATA_SIZE
#define MAX_EXTRADATA_SIZE
Definition: latmenc.c:35
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
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:346
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:256
len
int len
Definition: vorbis_enc_data.h:426
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
version.h
LIBAVFORMAT_VERSION
#define LIBAVFORMAT_VERSION
Definition: version.h:40
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1274
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:95
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:414
avformat.h
dict.h
network.h
id
enum AVCodecID id
Definition: dts2pts.c:365
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:71
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:402
ff_avc_write_annexb_extradata
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:255
ff_sdp_write_media
int ff_sdp_write_media(char *buff, int size, const 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:917
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:147
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:26
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:78
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:26
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:110
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:77
mem.h
AVCodecParameters::format
int format
Definition: codec_par.h:92
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AV_CODEC_ID_ILBC
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:499
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
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:85
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1159
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:445
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
addrinfo
Definition: network.h:137
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:341
ff_rtp_get_payload_type
int ff_rtp_get_payload_type(const AVFormatContext *fmt, const AVCodecParameters *par, int idx)
Return the payload type for a given stream used in the given format context.
Definition: rtp.c:93
AVIOContext::av_class
const AVClass * av_class
A class for private options.
Definition: avio.h:173
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