FFmpeg
asfdec_f.c
Go to the documentation of this file.
1 /*
2  * ASF compatible demuxer
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <inttypes.h>
23 
24 #include "libavutil/attributes.h"
25 #include "libavutil/avassert.h"
26 #include "libavutil/avstring.h"
27 #include "libavutil/bswap.h"
28 #include "libavutil/common.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "avformat.h"
34 #include "avio_internal.h"
35 #include "avlanguage.h"
36 #include "id3v2.h"
37 #include "internal.h"
38 #include "riff.h"
39 #include "asf.h"
40 #include "asfcrypt.h"
41 
42 typedef struct ASFPayload {
44  uint16_t size;
45 } ASFPayload;
46 
47 typedef struct ASFStream {
48  int num;
49  unsigned char seq;
50  /* use for reading */
54  int timestamp;
55  int64_t duration;
57  int pkt_clean;
58 
59  int ds_span; /* descrambling */
62 
63  int64_t packet_pos;
64 
66 
68  uint32_t palette[256];
69 
71  ASFPayload payload[8];
72 } ASFStream;
73 
74 typedef struct ASFContext {
75  const AVClass *class;
76  int asfid2avid[128]; ///< conversion table from asf ID 2 AVStream ID
77  ASFStream streams[128]; ///< it's max number and it's not that big
78  uint32_t stream_bitrates[128]; ///< max number of streams, bitrate for each (for streaming)
79  AVRational dar[128];
80  char stream_languages[128][6]; ///< max number of streams, language for each (RFC1766, e.g. en-US)
81  /* non streamed additonnal info */
82  /* packet filling */
84  /* only for reading */
85  uint64_t data_offset; ///< beginning of the first data packet
86  uint64_t data_object_offset; ///< data object offset (excl. GUID & size)
87  uint64_t data_object_size; ///< size of the data object
89 
91 
101  unsigned int packet_frag_offset;
102  unsigned int packet_frag_size;
108  int64_t packet_pos;
109 
111 
112  ASFStream *asf_st; ///< currently decoded stream
113 
116 
118 } ASFContext;
119 
120 static const AVOption options[] = {
121  { "no_resync_search", "Don't try to resynchronize by looking for a certain optional start code", offsetof(ASFContext, no_resync_search), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
122  { "export_xmp", "Export full XMP metadata", offsetof(ASFContext, export_xmp), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
123  { NULL },
124 };
125 
126 static const AVClass asf_class = {
127  .class_name = "asf demuxer",
128  .item_name = av_default_item_name,
129  .option = options,
130  .version = LIBAVUTIL_VERSION_INT,
131 };
132 
133 #undef NDEBUG
134 #include <assert.h>
135 
136 #define ASF_MAX_STREAMS 127
137 #define FRAME_HEADER_SIZE 6
138 // Fix Me! FRAME_HEADER_SIZE may be different.
139 // (7 is known to be too large for GipsyGuitar.wmv)
140 
141 #ifdef DEBUG
142 static const ff_asf_guid stream_bitrate_guid = { /* (http://get.to/sdp) */
143  0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2
144 };
145 
146 #define PRINT_IF_GUID(g, cmp) \
147  if (!ff_guidcmp(g, &cmp)) \
148  av_log(NULL, AV_LOG_TRACE, "(GUID: %s) ", # cmp)
149 
150 static void print_guid(ff_asf_guid *g)
151 {
152  int i;
153  PRINT_IF_GUID(g, ff_asf_header);
154  else PRINT_IF_GUID(g, ff_asf_file_header);
155  else PRINT_IF_GUID(g, ff_asf_stream_header);
156  else PRINT_IF_GUID(g, ff_asf_audio_stream);
157  else PRINT_IF_GUID(g, ff_asf_audio_conceal_none);
158  else PRINT_IF_GUID(g, ff_asf_video_stream);
159  else PRINT_IF_GUID(g, ff_asf_video_conceal_none);
160  else PRINT_IF_GUID(g, ff_asf_command_stream);
161  else PRINT_IF_GUID(g, ff_asf_comment_header);
162  else PRINT_IF_GUID(g, ff_asf_codec_comment_header);
163  else PRINT_IF_GUID(g, ff_asf_codec_comment1_header);
164  else PRINT_IF_GUID(g, ff_asf_data_header);
165  else PRINT_IF_GUID(g, ff_asf_simple_index_header);
166  else PRINT_IF_GUID(g, ff_asf_head1_guid);
167  else PRINT_IF_GUID(g, ff_asf_head2_guid);
168  else PRINT_IF_GUID(g, ff_asf_my_guid);
169  else PRINT_IF_GUID(g, ff_asf_ext_stream_header);
170  else PRINT_IF_GUID(g, ff_asf_extended_content_header);
171  else PRINT_IF_GUID(g, ff_asf_ext_stream_embed_stream_header);
172  else PRINT_IF_GUID(g, ff_asf_ext_stream_audio_stream);
173  else PRINT_IF_GUID(g, ff_asf_metadata_header);
174  else PRINT_IF_GUID(g, ff_asf_metadata_library_header);
175  else PRINT_IF_GUID(g, ff_asf_marker_header);
176  else PRINT_IF_GUID(g, stream_bitrate_guid);
177  else PRINT_IF_GUID(g, ff_asf_language_guid);
178  else
179  av_log(NULL, AV_LOG_TRACE, "(GUID: unknown) ");
180  for (i = 0; i < 16; i++)
181  av_log(NULL, AV_LOG_TRACE, " 0x%02x,", (*g)[i]);
182  av_log(NULL, AV_LOG_TRACE, "}\n");
183 }
184 #undef PRINT_IF_GUID
185 #else
186 #define print_guid(g) while(0)
187 #endif
188 
189 static int asf_probe(const AVProbeData *pd)
190 {
191  /* check file header */
192  if (!ff_guidcmp(pd->buf, &ff_asf_header))
193  return AVPROBE_SCORE_MAX;
194  else
195  return 0;
196 }
197 
198 /* size of type 2 (BOOL) is 32bit for "Extended Content Description Object"
199  * but 16 bit for "Metadata Object" and "Metadata Library Object" */
200 static int get_value(AVIOContext *pb, int type, int type2_size)
201 {
202  switch (type) {
203  case 2:
204  return (type2_size == 32) ? avio_rl32(pb) : avio_rl16(pb);
205  case 3:
206  return avio_rl32(pb);
207  case 4:
208  return avio_rl64(pb);
209  case 5:
210  return avio_rl16(pb);
211  default:
212  return INT_MIN;
213  }
214 }
215 
216 /* MSDN claims that this should be "compatible with the ID3 frame, APIC",
217  * but in reality this is only loosely similar */
219 {
220  AVPacket pkt = { 0 };
221  const CodecMime *mime = ff_id3v2_mime_tags;
222  enum AVCodecID id = AV_CODEC_ID_NONE;
223  char mimetype[64];
224  uint8_t *desc = NULL;
225  AVStream *st = NULL;
226  int ret, type, picsize, desc_len;
227 
228  /* type + picsize + mime + desc */
229  if (len < 1 + 4 + 2 + 2) {
230  av_log(s, AV_LOG_ERROR, "Invalid attached picture size: %d.\n", len);
231  return AVERROR_INVALIDDATA;
232  }
233 
234  /* picture type */
235  type = avio_r8(s->pb);
236  len--;
237  if (type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types) || type < 0) {
238  av_log(s, AV_LOG_WARNING, "Unknown attached picture type: %d.\n", type);
239  type = 0;
240  }
241 
242  /* picture data size */
243  picsize = avio_rl32(s->pb);
244  len -= 4;
245 
246  /* picture MIME type */
247  len -= avio_get_str16le(s->pb, len, mimetype, sizeof(mimetype));
248  while (mime->id != AV_CODEC_ID_NONE) {
249  if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
250  id = mime->id;
251  break;
252  }
253  mime++;
254  }
255  if (id == AV_CODEC_ID_NONE) {
256  av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
257  mimetype);
258  return 0;
259  }
260 
261  if (picsize >= len) {
262  av_log(s, AV_LOG_ERROR, "Invalid attached picture data size: %d >= %d.\n",
263  picsize, len);
264  return AVERROR_INVALIDDATA;
265  }
266 
267  /* picture description */
268  desc_len = (len - picsize) * 2 + 1;
269  desc = av_malloc(desc_len);
270  if (!desc)
271  return AVERROR(ENOMEM);
272  len -= avio_get_str16le(s->pb, len - picsize, desc, desc_len);
273 
274  ret = av_get_packet(s->pb, &pkt, picsize);
275  if (ret < 0)
276  goto fail;
277 
278  st = avformat_new_stream(s, NULL);
279  if (!st) {
280  ret = AVERROR(ENOMEM);
281  goto fail;
282  }
285  st->codecpar->codec_id = id;
286  st->attached_pic = pkt;
287  st->attached_pic.stream_index = st->index;
289 
290  if (*desc)
291  av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL);
292  else
293  av_freep(&desc);
294 
295  av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0);
296 
297  return 0;
298 
299 fail:
300  av_freep(&desc);
301  av_packet_unref(&pkt);
302  return ret;
303 }
304 
305 static void get_id3_tag(AVFormatContext *s, int len)
306 {
307  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
308 
309  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, len);
310  if (id3v2_extra_meta) {
311  ff_id3v2_parse_apic(s, &id3v2_extra_meta);
312  ff_id3v2_parse_chapters(s, &id3v2_extra_meta);
313  }
314  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
315 }
316 
317 static void get_tag(AVFormatContext *s, const char *key, int type, int len, int type2_size)
318 {
319  ASFContext *asf = s->priv_data;
320  char *value = NULL;
321  int64_t off = avio_tell(s->pb);
322 #define LEN 22
323 
324  if ((unsigned)len >= (UINT_MAX - LEN) / 2)
325  return;
326 
327  if (!asf->export_xmp && !strncmp(key, "xmp", 3))
328  goto finish;
329 
330  value = av_malloc(2 * len + LEN);
331  if (!value)
332  goto finish;
333 
334  switch (type) {
335  case ASF_UNICODE:
336  avio_get_str16le(s->pb, len, value, 2 * len + 1);
337  break;
338  case -1: // ASCI
339  avio_read(s->pb, value, len);
340  value[len]=0;
341  break;
342  case ASF_BYTE_ARRAY:
343  if (!strcmp(key, "WM/Picture")) { // handle cover art
344  asf_read_picture(s, len);
345  } else if (!strcmp(key, "ID3")) { // handle ID3 tag
346  get_id3_tag(s, len);
347  } else {
348  av_log(s, AV_LOG_VERBOSE, "Unsupported byte array in tag %s.\n", key);
349  }
350  goto finish;
351  case ASF_BOOL:
352  case ASF_DWORD:
353  case ASF_QWORD:
354  case ASF_WORD: {
355  uint64_t num = get_value(s->pb, type, type2_size);
356  snprintf(value, LEN, "%"PRIu64, num);
357  break;
358  }
359  case ASF_GUID:
360  av_log(s, AV_LOG_DEBUG, "Unsupported GUID value in tag %s.\n", key);
361  goto finish;
362  default:
363  av_log(s, AV_LOG_DEBUG,
364  "Unsupported value type %d in tag %s.\n", type, key);
365  goto finish;
366  }
367  if (*value)
368  av_dict_set(&s->metadata, key, value, 0);
369 
370 finish:
371  av_freep(&value);
372  avio_seek(s->pb, off + len, SEEK_SET);
373 }
374 
376 {
377  ASFContext *asf = s->priv_data;
378  AVIOContext *pb = s->pb;
379 
380  ff_get_guid(pb, &asf->hdr.guid);
381  asf->hdr.file_size = avio_rl64(pb);
382  asf->hdr.create_time = avio_rl64(pb);
383  avio_rl64(pb); /* number of packets */
384  asf->hdr.play_time = avio_rl64(pb);
385  asf->hdr.send_time = avio_rl64(pb);
386  asf->hdr.preroll = avio_rl32(pb);
387  asf->hdr.ignore = avio_rl32(pb);
388  asf->hdr.flags = avio_rl32(pb);
389  asf->hdr.min_pktsize = avio_rl32(pb);
390  asf->hdr.max_pktsize = avio_rl32(pb);
391  if (asf->hdr.min_pktsize >= (1U << 29))
392  return AVERROR_INVALIDDATA;
393  asf->hdr.max_bitrate = avio_rl32(pb);
394  s->packet_size = asf->hdr.max_pktsize;
395 
396  return 0;
397 }
398 
400 {
401  ASFContext *asf = s->priv_data;
402  AVIOContext *pb = s->pb;
403  AVStream *st;
404  ASFStream *asf_st;
405  ff_asf_guid g;
406  enum AVMediaType type;
407  int type_specific_size, sizeX;
408  unsigned int tag1;
409  int64_t pos1, pos2, start_time;
410  int test_for_ext_stream_audio, is_dvr_ms_audio = 0;
411 
412  if (s->nb_streams == ASF_MAX_STREAMS) {
413  av_log(s, AV_LOG_ERROR, "too many streams\n");
414  return AVERROR(EINVAL);
415  }
416 
417  pos1 = avio_tell(pb);
418 
419  st = avformat_new_stream(s, NULL);
420  if (!st)
421  return AVERROR(ENOMEM);
422  avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
423  start_time = asf->hdr.preroll;
424 
425  if (!(asf->hdr.flags & 0x01)) { // if we aren't streaming...
426  int64_t fsize = avio_size(pb);
427  if (fsize <= 0 || (int64_t)asf->hdr.file_size <= 0 ||
428  20*FFABS(fsize - (int64_t)asf->hdr.file_size) < FFMIN(fsize, asf->hdr.file_size))
429  st->duration = asf->hdr.play_time /
430  (10000000 / 1000) - start_time;
431  }
432  ff_get_guid(pb, &g);
433 
434  test_for_ext_stream_audio = 0;
435  if (!ff_guidcmp(&g, &ff_asf_audio_stream)) {
436  type = AVMEDIA_TYPE_AUDIO;
437  } else if (!ff_guidcmp(&g, &ff_asf_video_stream)) {
438  type = AVMEDIA_TYPE_VIDEO;
439  } else if (!ff_guidcmp(&g, &ff_asf_jfif_media)) {
440  type = AVMEDIA_TYPE_VIDEO;
442  } else if (!ff_guidcmp(&g, &ff_asf_command_stream)) {
443  type = AVMEDIA_TYPE_DATA;
445  test_for_ext_stream_audio = 1;
446  type = AVMEDIA_TYPE_UNKNOWN;
447  } else {
448  return -1;
449  }
450  ff_get_guid(pb, &g);
451  avio_skip(pb, 8); /* total_size */
452  type_specific_size = avio_rl32(pb);
453  avio_rl32(pb);
454  st->id = avio_rl16(pb) & 0x7f; /* stream id */
455  // mapping of asf ID to AV stream ID;
456  asf->asfid2avid[st->id] = s->nb_streams - 1;
457  asf_st = &asf->streams[st->id];
458 
459  avio_rl32(pb);
460 
461  if (test_for_ext_stream_audio) {
462  ff_get_guid(pb, &g);
464  type = AVMEDIA_TYPE_AUDIO;
465  is_dvr_ms_audio = 1;
466  ff_get_guid(pb, &g);
467  avio_rl32(pb);
468  avio_rl32(pb);
469  avio_rl32(pb);
470  ff_get_guid(pb, &g);
471  avio_rl32(pb);
472  }
473  }
474 
475  st->codecpar->codec_type = type;
476  if (type == AVMEDIA_TYPE_AUDIO) {
477  int ret = ff_get_wav_header(s, pb, st->codecpar, type_specific_size, 0);
478  if (ret < 0)
479  return ret;
480  if (is_dvr_ms_audio) {
481  // codec_id and codec_tag are unreliable in dvr_ms
482  // files. Set them later by probing stream.
483  st->request_probe = 1;
484  st->codecpar->codec_tag = 0;
485  }
486  if (st->codecpar->codec_id == AV_CODEC_ID_AAC)
488  else
490  /* We have to init the frame size at some point .... */
491  pos2 = avio_tell(pb);
492  if (size >= (pos2 + 8 - pos1 + 24)) {
493  asf_st->ds_span = avio_r8(pb);
494  asf_st->ds_packet_size = avio_rl16(pb);
495  asf_st->ds_chunk_size = avio_rl16(pb);
496  avio_rl16(pb); // ds_data_size
497  avio_r8(pb); // ds_silence_data
498  }
499  if (asf_st->ds_span > 1) {
500  if (!asf_st->ds_chunk_size ||
501  (asf_st->ds_packet_size / asf_st->ds_chunk_size <= 1) ||
502  asf_st->ds_packet_size % asf_st->ds_chunk_size)
503  asf_st->ds_span = 0; // disable descrambling
504  }
505  } else if (type == AVMEDIA_TYPE_VIDEO &&
506  size - (avio_tell(pb) - pos1 + 24) >= 51) {
507  avio_rl32(pb);
508  avio_rl32(pb);
509  avio_r8(pb);
510  avio_rl16(pb); /* size */
511  sizeX = avio_rl32(pb); /* size */
512  st->codecpar->width = avio_rl32(pb);
513  st->codecpar->height = avio_rl32(pb);
514  /* not available for asf */
515  avio_rl16(pb); /* panes */
516  st->codecpar->bits_per_coded_sample = avio_rl16(pb); /* depth */
517  tag1 = avio_rl32(pb);
518  avio_skip(pb, 20);
519  if (sizeX > 40) {
520  st->codecpar->extradata_size = ffio_limit(pb, sizeX - 40);
523  if (!st->codecpar->extradata)
524  return AVERROR(ENOMEM);
526  }
527 
528  /* Extract palette from extradata if bpp <= 8 */
529  /* This code assumes that extradata contains only palette */
530  /* This is true for all paletted codecs implemented in libavcodec */
531  if (st->codecpar->extradata_size && (st->codecpar->bits_per_coded_sample <= 8)) {
532 #if HAVE_BIGENDIAN
533  int i;
534  for (i = 0; i < FFMIN(st->codecpar->extradata_size, AVPALETTE_SIZE) / 4; i++)
535  asf_st->palette[i] = av_bswap32(((uint32_t *)st->codecpar->extradata)[i]);
536 #else
537  memcpy(asf_st->palette, st->codecpar->extradata,
539 #endif
540  asf_st->palette_changed = 1;
541  }
542 
543  st->codecpar->codec_tag = tag1;
545  if (tag1 == MKTAG('D', 'V', 'R', ' ')) {
547  /* issue658 contains wrong w/h and MS even puts a fake seq header
548  * with wrong w/h in extradata while a correct one is in the stream.
549  * maximum lameness */
550  st->codecpar->width =
551  st->codecpar->height = 0;
552  av_freep(&st->codecpar->extradata);
553  st->codecpar->extradata_size = 0;
554  }
555  if (st->codecpar->codec_id == AV_CODEC_ID_H264)
557  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4)
559  }
560  pos2 = avio_tell(pb);
561  avio_skip(pb, size - (pos2 - pos1 + 24));
562 
563  return 0;
564 }
565 
567 {
568  ASFContext *asf = s->priv_data;
569  AVIOContext *pb = s->pb;
570  ff_asf_guid g;
571  int ext_len, payload_ext_ct, stream_ct, i;
572  uint32_t leak_rate, stream_num;
573  unsigned int stream_languageid_index;
574 
575  avio_rl64(pb); // starttime
576  avio_rl64(pb); // endtime
577  leak_rate = avio_rl32(pb); // leak-datarate
578  avio_rl32(pb); // bucket-datasize
579  avio_rl32(pb); // init-bucket-fullness
580  avio_rl32(pb); // alt-leak-datarate
581  avio_rl32(pb); // alt-bucket-datasize
582  avio_rl32(pb); // alt-init-bucket-fullness
583  avio_rl32(pb); // max-object-size
584  avio_rl32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
585  stream_num = avio_rl16(pb); // stream-num
586 
587  stream_languageid_index = avio_rl16(pb); // stream-language-id-index
588  if (stream_num < 128)
589  asf->streams[stream_num].stream_language_index = stream_languageid_index;
590 
591  avio_rl64(pb); // avg frametime in 100ns units
592  stream_ct = avio_rl16(pb); // stream-name-count
593  payload_ext_ct = avio_rl16(pb); // payload-extension-system-count
594 
595  if (stream_num < 128) {
596  asf->stream_bitrates[stream_num] = leak_rate;
597  asf->streams[stream_num].payload_ext_ct = 0;
598  }
599 
600  for (i = 0; i < stream_ct; i++) {
601  avio_rl16(pb);
602  ext_len = avio_rl16(pb);
603  avio_skip(pb, ext_len);
604  }
605 
606  for (i = 0; i < payload_ext_ct; i++) {
607  int size;
608  ff_get_guid(pb, &g);
609  size = avio_rl16(pb);
610  ext_len = avio_rl32(pb);
611  avio_skip(pb, ext_len);
612  if (stream_num < 128 && i < FF_ARRAY_ELEMS(asf->streams[stream_num].payload)) {
613  ASFPayload *p = &asf->streams[stream_num].payload[i];
614  p->type = g[0];
615  p->size = size;
616  av_log(s, AV_LOG_DEBUG, "Payload extension %x %d\n", g[0], p->size );
617  asf->streams[stream_num].payload_ext_ct ++;
618  }
619  }
620 
621  return 0;
622 }
623 
625 {
626  AVIOContext *pb = s->pb;
627  int len1, len2, len3, len4, len5;
628 
629  len1 = avio_rl16(pb);
630  len2 = avio_rl16(pb);
631  len3 = avio_rl16(pb);
632  len4 = avio_rl16(pb);
633  len5 = avio_rl16(pb);
634  get_tag(s, "title", 0, len1, 32);
635  get_tag(s, "author", 0, len2, 32);
636  get_tag(s, "copyright", 0, len3, 32);
637  get_tag(s, "comment", 0, len4, 32);
638  avio_skip(pb, len5);
639 
640  return 0;
641 }
642 
644 {
645  AVIOContext *pb = s->pb;
646  ASFContext *asf = s->priv_data;
647  int desc_count, i, ret;
648 
649  desc_count = avio_rl16(pb);
650  for (i = 0; i < desc_count; i++) {
651  int name_len, value_type, value_len;
652  char name[1024];
653 
654  name_len = avio_rl16(pb);
655  if (name_len % 2) // must be even, broken lavf versions wrote len-1
656  name_len += 1;
657  if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
658  avio_skip(pb, name_len - ret);
659  value_type = avio_rl16(pb);
660  value_len = avio_rl16(pb);
661  if (!value_type && value_len % 2)
662  value_len += 1;
663  /* My sample has that stream set to 0 maybe that mean the container.
664  * ASF stream count starts at 1. I am using 0 to the container value
665  * since it's unused. */
666  if (!strcmp(name, "AspectRatioX"))
667  asf->dar[0].num = get_value(s->pb, value_type, 32);
668  else if (!strcmp(name, "AspectRatioY"))
669  asf->dar[0].den = get_value(s->pb, value_type, 32);
670  else
671  get_tag(s, name, value_type, value_len, 32);
672  }
673 
674  return 0;
675 }
676 
678 {
679  AVIOContext *pb = s->pb;
680  ASFContext *asf = s->priv_data;
681  int j, ret;
682  int stream_count = avio_rl16(pb);
683  for (j = 0; j < stream_count; j++) {
684  char lang[6];
685  unsigned int lang_len = avio_r8(pb);
686  if ((ret = avio_get_str16le(pb, lang_len, lang,
687  sizeof(lang))) < lang_len)
688  avio_skip(pb, lang_len - ret);
689  if (j < 128)
690  av_strlcpy(asf->stream_languages[j], lang,
691  sizeof(*asf->stream_languages));
692  }
693 
694  return 0;
695 }
696 
698 {
699  AVIOContext *pb = s->pb;
700  ASFContext *asf = s->priv_data;
701  int n, stream_num, name_len_utf16, name_len_utf8, value_len;
702  int ret, i;
703  n = avio_rl16(pb);
704 
705  for (i = 0; i < n; i++) {
706  uint8_t *name;
707  int value_type;
708 
709  avio_rl16(pb); // lang_list_index
710  stream_num = avio_rl16(pb);
711  name_len_utf16 = avio_rl16(pb);
712  value_type = avio_rl16(pb); /* value_type */
713  value_len = avio_rl32(pb);
714 
715  name_len_utf8 = 2*name_len_utf16 + 1;
716  name = av_malloc(name_len_utf8);
717  if (!name)
718  return AVERROR(ENOMEM);
719 
720  if ((ret = avio_get_str16le(pb, name_len_utf16, name, name_len_utf8)) < name_len_utf16)
721  avio_skip(pb, name_len_utf16 - ret);
722  av_log(s, AV_LOG_TRACE, "%d stream %d name_len %2d type %d len %4d <%s>\n",
723  i, stream_num, name_len_utf16, value_type, value_len, name);
724 
725  if (!strcmp(name, "AspectRatioX")){
726  int aspect_x = get_value(s->pb, value_type, 16);
727  if(stream_num < 128)
728  asf->dar[stream_num].num = aspect_x;
729  } else if(!strcmp(name, "AspectRatioY")){
730  int aspect_y = get_value(s->pb, value_type, 16);
731  if(stream_num < 128)
732  asf->dar[stream_num].den = aspect_y;
733  } else {
734  get_tag(s, name, value_type, value_len, 16);
735  }
736  av_freep(&name);
737  }
738 
739  return 0;
740 }
741 
742 static int asf_read_marker(AVFormatContext *s, int64_t size)
743 {
744  AVIOContext *pb = s->pb;
745  ASFContext *asf = s->priv_data;
746  int i, count, name_len, ret;
747  char name[1024];
748 
749  avio_rl64(pb); // reserved 16 bytes
750  avio_rl64(pb); // ...
751  count = avio_rl32(pb); // markers count
752  avio_rl16(pb); // reserved 2 bytes
753  name_len = avio_rl16(pb); // name length
754  avio_skip(pb, name_len);
755 
756  for (i = 0; i < count; i++) {
757  int64_t pres_time;
758  int name_len;
759 
760  if (avio_feof(pb))
761  return AVERROR_INVALIDDATA;
762 
763  avio_rl64(pb); // offset, 8 bytes
764  pres_time = avio_rl64(pb); // presentation time
765  pres_time -= asf->hdr.preroll * 10000;
766  avio_rl16(pb); // entry length
767  avio_rl32(pb); // send time
768  avio_rl32(pb); // flags
769  name_len = avio_rl32(pb); // name length
770  if ((ret = avio_get_str16le(pb, name_len * 2, name,
771  sizeof(name))) < name_len)
772  avio_skip(pb, name_len - ret);
773  avpriv_new_chapter(s, i, (AVRational) { 1, 10000000 }, pres_time,
775  }
776 
777  return 0;
778 }
779 
781 {
782  ASFContext *asf = s->priv_data;
783  ff_asf_guid g;
784  AVIOContext *pb = s->pb;
785  int i;
786  int64_t gsize;
787 
788  ff_get_guid(pb, &g);
789  if (ff_guidcmp(&g, &ff_asf_header))
790  return AVERROR_INVALIDDATA;
791  avio_rl64(pb);
792  avio_rl32(pb);
793  avio_r8(pb);
794  avio_r8(pb);
795  memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
796 
797  for (i = 0; i<128; i++)
798  asf->streams[i].stream_language_index = 128; // invalid stream index means no language info
799 
800  for (;;) {
801  uint64_t gpos = avio_tell(pb);
802  int ret = 0;
803  ff_get_guid(pb, &g);
804  gsize = avio_rl64(pb);
805  print_guid(&g);
806  if (!ff_guidcmp(&g, &ff_asf_data_header)) {
807  asf->data_object_offset = avio_tell(pb);
808  /* If not streaming, gsize is not unlimited (how?),
809  * and there is enough space in the file.. */
810  if (!(asf->hdr.flags & 0x01) && gsize >= 100)
811  asf->data_object_size = gsize - 24;
812  else
813  asf->data_object_size = (uint64_t)-1;
814  break;
815  }
816  if (gsize < 24)
817  return AVERROR_INVALIDDATA;
818  if (!ff_guidcmp(&g, &ff_asf_file_header)) {
819  ret = asf_read_file_properties(s, gsize);
820  } else if (!ff_guidcmp(&g, &ff_asf_stream_header)) {
821  ret = asf_read_stream_properties(s, gsize);
822  } else if (!ff_guidcmp(&g, &ff_asf_comment_header)) {
823  asf_read_content_desc(s, gsize);
824  } else if (!ff_guidcmp(&g, &ff_asf_language_guid)) {
825  asf_read_language_list(s, gsize);
826  } else if (!ff_guidcmp(&g, &ff_asf_extended_content_header)) {
827  asf_read_ext_content_desc(s, gsize);
828  } else if (!ff_guidcmp(&g, &ff_asf_metadata_header)) {
829  asf_read_metadata(s, gsize);
830  } else if (!ff_guidcmp(&g, &ff_asf_metadata_library_header)) {
831  asf_read_metadata(s, gsize);
832  } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_header)) {
834 
835  // there could be an optional stream properties object to follow
836  // if so the next iteration will pick it up
837  continue;
838  } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
839  ff_get_guid(pb, &g);
840  avio_skip(pb, 6);
841  continue;
842  } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
843  asf_read_marker(s, gsize);
844  } else if (avio_feof(pb)) {
845  return AVERROR_EOF;
846  } else {
847  if (!s->keylen) {
849  unsigned int len;
850  AVPacket pkt;
852  "DRM protected stream detected, decoding will likely fail!\n");
853  len= avio_rl32(pb);
854  av_log(s, AV_LOG_DEBUG, "Secret data:\n");
855 
856  if ((ret = av_get_packet(pb, &pkt, len)) < 0)
857  return ret;
858  av_hex_dump_log(s, AV_LOG_DEBUG, pkt.data, pkt.size);
859  av_packet_unref(&pkt);
860  len= avio_rl32(pb);
861  get_tag(s, "ASF_Protection_Type", -1, len, 32);
862  len= avio_rl32(pb);
863  get_tag(s, "ASF_Key_ID", -1, len, 32);
864  len= avio_rl32(pb);
865  get_tag(s, "ASF_License_URL", -1, len, 32);
866  } else if (!ff_guidcmp(&g, &ff_asf_ext_content_encryption)) {
868  "Ext DRM protected stream detected, decoding will likely fail!\n");
869  av_dict_set(&s->metadata, "encryption", "ASF Extended Content Encryption", 0);
870  } else if (!ff_guidcmp(&g, &ff_asf_digital_signature)) {
871  av_log(s, AV_LOG_INFO, "Digital signature detected!\n");
872  }
873  }
874  }
875  if (ret < 0)
876  return ret;
877 
878  if (avio_tell(pb) != gpos + gsize)
879  av_log(s, AV_LOG_DEBUG,
880  "gpos mismatch our pos=%"PRIu64", end=%"PRId64"\n",
881  avio_tell(pb) - gpos, gsize);
882  avio_seek(pb, gpos + gsize, SEEK_SET);
883  }
884  ff_get_guid(pb, &g);
885  avio_rl64(pb);
886  avio_r8(pb);
887  avio_r8(pb);
888  if (avio_feof(pb))
889  return AVERROR_EOF;
890  asf->data_offset = avio_tell(pb);
891  asf->packet_size_left = 0;
892 
893  for (i = 0; i < 128; i++) {
894  int stream_num = asf->asfid2avid[i];
895  if (stream_num >= 0) {
896  AVStream *st = s->streams[stream_num];
897  if (!st->codecpar->bit_rate)
898  st->codecpar->bit_rate = asf->stream_bitrates[i];
899  if (asf->dar[i].num > 0 && asf->dar[i].den > 0) {
902  asf->dar[i].num, asf->dar[i].den, INT_MAX);
903  } else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) &&
904  // Use ASF container value if the stream doesn't set AR.
908  asf->dar[0].num, asf->dar[0].den, INT_MAX);
909 
910  av_log(s, AV_LOG_TRACE, "i=%d, st->codecpar->codec_type:%d, asf->dar %d:%d sar=%d:%d\n",
911  i, st->codecpar->codec_type, asf->dar[i].num, asf->dar[i].den,
913 
914  // copy and convert language codes to the frontend
915  if (asf->streams[i].stream_language_index < 128) {
916  const char *rfc1766 = asf->stream_languages[asf->streams[i].stream_language_index];
917  if (rfc1766 && strlen(rfc1766) > 1) {
918  const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any
919  const char *iso6392 = ff_convert_lang_to(primary_tag,
921  if (iso6392)
922  av_dict_set(&st->metadata, "language", iso6392, 0);
923  }
924  }
925  }
926  }
927 
929 
930  return 0;
931 }
932 
933 #define DO_2BITS(bits, var, defval) \
934  switch (bits & 3) { \
935  case 3: \
936  var = avio_rl32(pb); \
937  rsize += 4; \
938  break; \
939  case 2: \
940  var = avio_rl16(pb); \
941  rsize += 2; \
942  break; \
943  case 1: \
944  var = avio_r8(pb); \
945  rsize++; \
946  break; \
947  default: \
948  var = defval; \
949  break; \
950  }
951 
952 /**
953  * Load a single ASF packet into the demuxer.
954  * @param s demux context
955  * @param pb context to read data from
956  * @return 0 on success, <0 on error
957  */
959 {
960  ASFContext *asf = s->priv_data;
961  uint32_t packet_length, padsize;
962  int rsize = 8;
963  int c, d, e, off;
964 
965  if (asf->uses_std_ecc > 0) {
966  // if we do not know packet size, allow skipping up to 32 kB
967  off = 32768;
968  if (asf->no_resync_search)
969  off = 3;
970 // else if (s->packet_size > 0 && !asf->uses_std_ecc)
971 // off = (avio_tell(pb) - s->internal->data_offset) % s->packet_size + 3;
972 
973  c = d = e = -1;
974  while (off-- > 0) {
975  c = d;
976  d = e;
977  e = avio_r8(pb);
978  if (c == 0x82 && !d && !e)
979  break;
980  }
981 
982  if (c != 0x82) {
983  /* This code allows handling of -EAGAIN at packet boundaries (i.e.
984  * if the packet sync code above triggers -EAGAIN). This does not
985  * imply complete -EAGAIN handling support at random positions in
986  * the stream. */
987  if (pb->error == AVERROR(EAGAIN))
988  return AVERROR(EAGAIN);
989  if (!avio_feof(pb))
990  av_log(s, AV_LOG_ERROR,
991  "ff asf bad header %x at:%"PRId64"\n", c, avio_tell(pb));
992  }
993  if ((c & 0x8f) == 0x82) {
994  if (d || e) {
995  if (!avio_feof(pb))
996  av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
997  return AVERROR_INVALIDDATA;
998  }
999  c = avio_r8(pb);
1000  d = avio_r8(pb);
1001  rsize += 3;
1002  } else if(!avio_feof(pb)) {
1003  avio_seek(pb, -1, SEEK_CUR); // FIXME
1004  }
1005  } else {
1006  c = avio_r8(pb);
1007  if (c & 0x80) {
1008  rsize ++;
1009  if (!(c & 0x60)) {
1010  d = avio_r8(pb);
1011  e = avio_r8(pb);
1012  avio_seek(pb, (c & 0xF) - 2, SEEK_CUR);
1013  rsize += c & 0xF;
1014  }
1015 
1016  if (c != 0x82)
1017  avpriv_request_sample(s, "Invalid ECC byte");
1018 
1019  if (!asf->uses_std_ecc)
1020  asf->uses_std_ecc = (c == 0x82 && !d && !e) ? 1 : -1;
1021 
1022  c = avio_r8(pb);
1023  } else
1024  asf->uses_std_ecc = -1;
1025  d = avio_r8(pb);
1026  }
1027 
1028  asf->packet_flags = c;
1029  asf->packet_property = d;
1030 
1031  DO_2BITS(asf->packet_flags >> 5, packet_length, s->packet_size);
1032  DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored
1033  DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length
1034 
1035  // the following checks prevent overflows and infinite loops
1036  if (!packet_length || packet_length >= (1U << 29)) {
1037  av_log(s, AV_LOG_ERROR,
1038  "invalid packet_length %"PRIu32" at:%"PRId64"\n",
1039  packet_length, avio_tell(pb));
1040  return AVERROR_INVALIDDATA;
1041  }
1042  if (padsize >= packet_length) {
1043  av_log(s, AV_LOG_ERROR,
1044  "invalid padsize %"PRIu32" at:%"PRId64"\n", padsize, avio_tell(pb));
1045  return AVERROR_INVALIDDATA;
1046  }
1047 
1048  asf->packet_timestamp = avio_rl32(pb);
1049  avio_rl16(pb); /* duration */
1050  // rsize has at least 11 bytes which have to be present
1051 
1052  if (asf->packet_flags & 0x01) {
1053  asf->packet_segsizetype = avio_r8(pb);
1054  rsize++;
1055  asf->packet_segments = asf->packet_segsizetype & 0x3f;
1056  } else {
1057  asf->packet_segments = 1;
1058  asf->packet_segsizetype = 0x80;
1059  }
1060  if (rsize > packet_length - padsize) {
1061  asf->packet_size_left = 0;
1062  av_log(s, AV_LOG_ERROR,
1063  "invalid packet header length %d for pktlen %"PRIu32"-%"PRIu32" at %"PRId64"\n",
1064  rsize, packet_length, padsize, avio_tell(pb));
1065  return AVERROR_INVALIDDATA;
1066  }
1067  asf->packet_size_left = packet_length - padsize - rsize;
1068  if (packet_length < asf->hdr.min_pktsize)
1069  padsize += asf->hdr.min_pktsize - packet_length;
1070  asf->packet_padsize = padsize;
1071  av_log(s, AV_LOG_TRACE, "packet: size=%d padsize=%d left=%d\n",
1073  return 0;
1074 }
1075 
1076 /**
1077  *
1078  * @return <0 if error
1079  */
1081 {
1082  ASFContext *asf = s->priv_data;
1083  ASFStream *asfst;
1084  int rsize = 1;
1085  int num = avio_r8(pb);
1086  int i;
1087  int64_t ts0, ts1 av_unused;
1088 
1089  asf->packet_segments--;
1090  asf->packet_key_frame = num >> 7;
1091  asf->stream_index = asf->asfid2avid[num & 0x7f];
1092  asfst = &asf->streams[num & 0x7f];
1093  // sequence should be ignored!
1094  DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);
1095  DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);
1097  av_log(asf, AV_LOG_TRACE, "key:%d stream:%d seq:%d offset:%d replic_size:%d num:%X packet_property %X\n",
1098  asf->packet_key_frame, asf->stream_index, asf->packet_seq,
1099  asf->packet_frag_offset, asf->packet_replic_size, num, asf->packet_property);
1100  if (rsize+(int64_t)asf->packet_replic_size > asf->packet_size_left) {
1101  av_log(s, AV_LOG_ERROR, "packet_replic_size %d is invalid\n", asf->packet_replic_size);
1102  return AVERROR_INVALIDDATA;
1103  }
1104  if (asf->packet_replic_size >= 8) {
1105  int64_t end = avio_tell(pb) + asf->packet_replic_size;
1106  AVRational aspect;
1107  asfst->packet_obj_size = avio_rl32(pb);
1108  if (asfst->packet_obj_size >= (1 << 24) || asfst->packet_obj_size < 0) {
1109  av_log(s, AV_LOG_ERROR, "packet_obj_size %d invalid\n", asfst->packet_obj_size);
1110  asfst->packet_obj_size = 0;
1111  return AVERROR_INVALIDDATA;
1112  }
1113  asf->packet_frag_timestamp = avio_rl32(pb); // timestamp
1114 
1115  for (i = 0; i < asfst->payload_ext_ct; i++) {
1116  ASFPayload *p = &asfst->payload[i];
1117  int size = p->size;
1118  int64_t payend;
1119  if (size == 0xFFFF)
1120  size = avio_rl16(pb);
1121  payend = avio_tell(pb) + size;
1122  if (payend > end) {
1123  av_log(s, AV_LOG_ERROR, "too long payload\n");
1124  break;
1125  }
1126  switch (p->type) {
1127  case 0x50:
1128 // duration = avio_rl16(pb);
1129  break;
1130  case 0x54:
1131  aspect.num = avio_r8(pb);
1132  aspect.den = avio_r8(pb);
1133  if (aspect.num > 0 && aspect.den > 0 && asf->stream_index >= 0) {
1134  s->streams[asf->stream_index]->sample_aspect_ratio = aspect;
1135  }
1136  break;
1137  case 0x2A:
1138  avio_skip(pb, 8);
1139  ts0 = avio_rl64(pb);
1140  ts1 = avio_rl64(pb);
1141  if (ts0!= -1) asf->packet_frag_timestamp = ts0/10000;
1143  asf->ts_is_pts = 1;
1144  break;
1145  case 0x5B:
1146  case 0xB7:
1147  case 0xCC:
1148  case 0xC0:
1149  case 0xA0:
1150  //unknown
1151  break;
1152  }
1153  avio_seek(pb, payend, SEEK_SET);
1154  }
1155 
1156  avio_seek(pb, end, SEEK_SET);
1157  rsize += asf->packet_replic_size; // FIXME - check validity
1158  } else if (asf->packet_replic_size == 1) {
1159  // multipacket - frag_offset is beginning timestamp
1161  asf->packet_frag_offset = 0;
1163 
1164  asf->packet_time_delta = avio_r8(pb);
1165  rsize++;
1166  } else if (asf->packet_replic_size != 0) {
1167  av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n",
1168  asf->packet_replic_size);
1169  return AVERROR_INVALIDDATA;
1170  }
1171  if (asf->packet_flags & 0x01) {
1172  DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal
1173  if (rsize > asf->packet_size_left) {
1174  av_log(s, AV_LOG_ERROR, "packet_replic_size is invalid\n");
1175  return AVERROR_INVALIDDATA;
1176  } else if (asf->packet_frag_size > asf->packet_size_left - rsize) {
1177  if (asf->packet_frag_size > asf->packet_size_left - rsize + asf->packet_padsize) {
1178  av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid (%d>%d-%d+%d)\n",
1179  asf->packet_frag_size, asf->packet_size_left, rsize, asf->packet_padsize);
1180  return AVERROR_INVALIDDATA;
1181  } else {
1182  int diff = asf->packet_frag_size - (asf->packet_size_left - rsize);
1183  asf->packet_size_left += diff;
1184  asf->packet_padsize -= diff;
1185  }
1186  }
1187  } else {
1188  asf->packet_frag_size = asf->packet_size_left - rsize;
1189  }
1190  if (asf->packet_replic_size == 1) {
1191  asf->packet_multi_size = asf->packet_frag_size;
1192  if (asf->packet_multi_size > asf->packet_size_left)
1193  return AVERROR_INVALIDDATA;
1194  }
1195  asf->packet_size_left -= rsize;
1196 
1197  return 0;
1198 }
1199 
1200 /**
1201  * Parse data from individual ASF packets (which were previously loaded
1202  * with asf_get_packet()).
1203  * @param s demux context
1204  * @param pb context to read data from
1205  * @param pkt pointer to store packet data into
1206  * @return 0 if data was stored in pkt, <0 on error or 1 if more ASF
1207  * packets need to be loaded (through asf_get_packet())
1208  */
1210 {
1211  ASFContext *asf = s->priv_data;
1212  ASFStream *asf_st = 0;
1213  for (;;) {
1214  int ret;
1215  if (avio_feof(pb))
1216  return AVERROR_EOF;
1217  if (asf->packet_size_left < FRAME_HEADER_SIZE ||
1218  asf->packet_segments < 1 && asf->packet_time_start == 0) {
1219  int ret = asf->packet_size_left + asf->packet_padsize;
1220 
1222  av_log(s, AV_LOG_WARNING, "Skip due to FRAME_HEADER_SIZE\n");
1223 
1224  assert(ret >= 0);
1225  /* fail safe */
1226  avio_skip(pb, ret);
1227 
1228  asf->packet_pos = avio_tell(pb);
1229  if (asf->data_object_size != (uint64_t)-1 &&
1230  (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
1231  return AVERROR_EOF; /* Do not exceed the size of the data object */
1232  return 1;
1233  }
1234  if (asf->packet_time_start == 0) {
1235  if (asf_read_frame_header(s, pb) < 0) {
1236  asf->packet_time_start = asf->packet_segments = 0;
1237  continue;
1238  }
1239  if (asf->stream_index < 0 ||
1240  s->streams[asf->stream_index]->discard >= AVDISCARD_ALL ||
1241  (!asf->packet_key_frame &&
1242  (s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY || asf->streams[s->streams[asf->stream_index]->id].skip_to_key))) {
1243  asf->packet_time_start = 0;
1244  /* unhandled packet (should not happen) */
1245  avio_skip(pb, asf->packet_frag_size);
1246  asf->packet_size_left -= asf->packet_frag_size;
1247  if (asf->stream_index < 0)
1248  av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n",
1249  asf->packet_frag_size);
1250  continue;
1251  }
1252  asf->asf_st = &asf->streams[s->streams[asf->stream_index]->id];
1253  if (!asf->packet_frag_offset)
1254  asf->asf_st->skip_to_key = 0;
1255  }
1256  asf_st = asf->asf_st;
1257  av_assert0(asf_st);
1258 
1259  if (!asf_st->frag_offset && asf->packet_frag_offset) {
1260  av_log(s, AV_LOG_TRACE, "skipping asf data pkt with fragment offset for "
1261  "stream:%d, expected:%d but got %d from pkt)\n",
1262  asf->stream_index, asf_st->frag_offset,
1263  asf->packet_frag_offset);
1264  avio_skip(pb, asf->packet_frag_size);
1265  asf->packet_size_left -= asf->packet_frag_size;
1266  continue;
1267  }
1268 
1269  if (asf->packet_replic_size == 1) {
1270  // frag_offset is here used as the beginning timestamp
1272  asf->packet_time_start += asf->packet_time_delta;
1273  asf_st->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
1274  asf->packet_size_left--;
1275  asf->packet_multi_size--;
1276  if (asf->packet_multi_size < asf_st->packet_obj_size) {
1277  asf->packet_time_start = 0;
1278  avio_skip(pb, asf->packet_multi_size);
1279  asf->packet_size_left -= asf->packet_multi_size;
1280  continue;
1281  }
1282  asf->packet_multi_size -= asf_st->packet_obj_size;
1283  }
1284 
1285  if (asf_st->pkt.size != asf_st->packet_obj_size ||
1286  // FIXME is this condition sufficient?
1287  asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) {
1288  int ret;
1289 
1290  if (asf_st->pkt.data) {
1291  av_log(s, AV_LOG_INFO,
1292  "freeing incomplete packet size %d, new %d\n",
1293  asf_st->pkt.size, asf_st->packet_obj_size);
1294  asf_st->frag_offset = 0;
1295  av_packet_unref(&asf_st->pkt);
1296  }
1297  /* new packet */
1298  if ((ret = av_new_packet(&asf_st->pkt, asf_st->packet_obj_size)) < 0)
1299  return ret;
1300  asf_st->seq = asf->packet_seq;
1301  if (asf->ts_is_pts) {
1302  asf_st->pkt.pts = asf->packet_frag_timestamp - asf->hdr.preroll;
1303  } else
1304  asf_st->pkt.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
1305  asf_st->pkt.stream_index = asf->stream_index;
1306  asf_st->pkt.pos = asf_st->packet_pos = asf->packet_pos;
1307  asf_st->pkt_clean = 0;
1308 
1309  if (asf_st->pkt.data && asf_st->palette_changed) {
1310  uint8_t *pal;
1312  AVPALETTE_SIZE);
1313  if (!pal) {
1314  av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
1315  } else {
1316  memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
1317  asf_st->palette_changed = 0;
1318  }
1319  }
1320  av_log(asf, AV_LOG_TRACE, "new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
1321  asf->stream_index, asf->packet_key_frame,
1322  asf_st->pkt.flags & AV_PKT_FLAG_KEY,
1324  asf_st->packet_obj_size);
1326  asf->packet_key_frame = 1;
1327  if (asf->packet_key_frame)
1328  asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
1329  }
1330 
1331  /* read data */
1332  av_log(asf, AV_LOG_TRACE, "READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n",
1333  s->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
1334  asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
1335  asf->packet_size_left -= asf->packet_frag_size;
1336  if (asf->packet_size_left < 0)
1337  continue;
1338 
1339  if (asf->packet_frag_offset >= asf_st->pkt.size ||
1340  asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset) {
1341  av_log(s, AV_LOG_ERROR,
1342  "packet fragment position invalid %u,%u not in %u\n",
1344  asf_st->pkt.size);
1345  continue;
1346  }
1347 
1348  if (asf->packet_frag_offset != asf_st->frag_offset && !asf_st->pkt_clean) {
1349  memset(asf_st->pkt.data + asf_st->frag_offset, 0, asf_st->pkt.size - asf_st->frag_offset);
1350  asf_st->pkt_clean = 1;
1351  }
1352 
1353  ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
1354  asf->packet_frag_size);
1355  if (ret != asf->packet_frag_size) {
1356  if (ret < 0 || asf->packet_frag_offset + ret == 0)
1357  return ret < 0 ? ret : AVERROR_EOF;
1358 
1359  if (asf_st->ds_span > 1) {
1360  // scrambling, we can either drop it completely or fill the remainder
1361  // TODO: should we fill the whole packet instead of just the current
1362  // fragment?
1363  memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
1364  asf->packet_frag_size - ret);
1365  ret = asf->packet_frag_size;
1366  } else {
1367  // no scrambling, so we can return partial packets
1368  av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
1369  }
1370  }
1371  if (s->key && s->keylen == 20)
1372  ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
1373  ret);
1374  asf_st->frag_offset += ret;
1375  /* test if whole packet is read */
1376  if (asf_st->frag_offset == asf_st->pkt.size) {
1377  // workaround for macroshit radio DVR-MS files
1379  asf_st->pkt.size > 100) {
1380  int i;
1381  for (i = 0; i < asf_st->pkt.size && !asf_st->pkt.data[i]; i++)
1382  ;
1383  if (i == asf_st->pkt.size) {
1384  av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
1385  asf_st->frag_offset = 0;
1386  av_packet_unref(&asf_st->pkt);
1387  continue;
1388  }
1389  }
1390 
1391  /* return packet */
1392  if (asf_st->ds_span > 1) {
1393  if (asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span) {
1394  av_log(s, AV_LOG_ERROR,
1395  "pkt.size != ds_packet_size * ds_span (%d %d %d)\n",
1396  asf_st->pkt.size, asf_st->ds_packet_size,
1397  asf_st->ds_span);
1398  } else {
1399  /* packet descrambling */
1400  AVBufferRef *buf = av_buffer_alloc(asf_st->pkt.size +
1402  if (buf) {
1403  uint8_t *newdata = buf->data;
1404  int offset = 0;
1405  memset(newdata + asf_st->pkt.size, 0,
1407  while (offset < asf_st->pkt.size) {
1408  int off = offset / asf_st->ds_chunk_size;
1409  int row = off / asf_st->ds_span;
1410  int col = off % asf_st->ds_span;
1411  int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
1412  assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
1413  assert(idx + 1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
1414  memcpy(newdata + offset,
1415  asf_st->pkt.data + idx * asf_st->ds_chunk_size,
1416  asf_st->ds_chunk_size);
1417  offset += asf_st->ds_chunk_size;
1418  }
1419  av_buffer_unref(&asf_st->pkt.buf);
1420  asf_st->pkt.buf = buf;
1421  asf_st->pkt.data = buf->data;
1422  }
1423  }
1424  }
1425  asf_st->frag_offset = 0;
1426  *pkt = asf_st->pkt;
1427  asf_st->pkt.buf = 0;
1428  asf_st->pkt.size = 0;
1429  asf_st->pkt.data = 0;
1430  asf_st->pkt.side_data_elems = 0;
1431  asf_st->pkt.side_data = NULL;
1432  break; // packet completed
1433  }
1434  }
1435  return 0;
1436 }
1437 
1439 {
1440  ASFContext *asf = s->priv_data;
1441 
1442  for (;;) {
1443  int ret;
1444 
1445  /* parse cached packets, if any */
1446  if ((ret = asf_parse_packet(s, s->pb, pkt)) <= 0)
1447  return ret;
1448  if ((ret = asf_get_packet(s, s->pb)) < 0)
1449  assert(asf->packet_size_left < FRAME_HEADER_SIZE ||
1450  asf->packet_segments < 1);
1451  asf->packet_time_start = 0;
1452  }
1453 }
1454 
1455 // Added to support seeking after packets have been read
1456 // If information is not reset, read_packet fails due to
1457 // leftover information from previous reads
1459 {
1460  ASFContext *asf = s->priv_data;
1461  ASFStream *asf_st;
1462  int i;
1463 
1464  asf->packet_size_left = 0;
1465  asf->packet_flags = 0;
1466  asf->packet_property = 0;
1467  asf->packet_timestamp = 0;
1468  asf->packet_segsizetype = 0;
1469  asf->packet_segments = 0;
1470  asf->packet_seq = 0;
1471  asf->packet_replic_size = 0;
1472  asf->packet_key_frame = 0;
1473  asf->packet_padsize = 0;
1474  asf->packet_frag_offset = 0;
1475  asf->packet_frag_size = 0;
1476  asf->packet_frag_timestamp = 0;
1477  asf->packet_multi_size = 0;
1478  asf->packet_time_delta = 0;
1479  asf->packet_time_start = 0;
1480 
1481  for (i = 0; i < 128; i++) {
1482  asf_st = &asf->streams[i];
1483  av_packet_unref(&asf_st->pkt);
1484  asf_st->packet_obj_size = 0;
1485  asf_st->frag_offset = 0;
1486  asf_st->seq = 0;
1487  }
1488  asf->asf_st = NULL;
1489 }
1490 
1492 {
1493  ASFContext *asf = s->priv_data;
1494  int i;
1495 
1496  for (i = 0; i < 128; i++) {
1497  int j = asf->asfid2avid[i];
1498  ASFStream *asf_st = &asf->streams[i];
1499  if (j < 0 || s->streams[j]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1500  continue;
1501 
1502  asf_st->skip_to_key = 1;
1503  }
1504 }
1505 
1507 {
1508  asf_reset_header(s);
1509 
1510  return 0;
1511 }
1512 
1513 static int64_t asf_read_pts(AVFormatContext *s, int stream_index,
1514  int64_t *ppos, int64_t pos_limit)
1515 {
1516  ASFContext *asf = s->priv_data;
1517  AVPacket pkt1, *pkt = &pkt1;
1518  ASFStream *asf_st;
1519  int64_t pts;
1520  int64_t pos = *ppos;
1521  int i;
1522  int64_t start_pos[ASF_MAX_STREAMS];
1523 
1524  for (i = 0; i < s->nb_streams; i++)
1525  start_pos[i] = pos;
1526 
1527  if (s->packet_size > 0)
1528  pos = (pos + s->packet_size - 1 - s->internal->data_offset) /
1529  s->packet_size * s->packet_size +
1530  s->internal->data_offset;
1531  *ppos = pos;
1532  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1533  return AV_NOPTS_VALUE;
1534 
1536  asf_reset_header(s);
1537  for (;;) {
1538  if (av_read_frame(s, pkt) < 0) {
1539  av_log(s, AV_LOG_INFO, "asf_read_pts failed\n");
1540  return AV_NOPTS_VALUE;
1541  }
1542 
1543  pts = pkt->dts;
1544 
1545  if (pkt->flags & AV_PKT_FLAG_KEY) {
1546  i = pkt->stream_index;
1547 
1548  asf_st = &asf->streams[s->streams[i]->id];
1549 
1550 // assert((asf_st->packet_pos - s->data_offset) % s->packet_size == 0);
1551  pos = asf_st->packet_pos;
1552  av_assert1(pkt->pos == asf_st->packet_pos);
1553 
1554  av_add_index_entry(s->streams[i], pos, pts, pkt->size,
1555  pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
1556  start_pos[i] = asf_st->packet_pos + 1;
1557 
1558  if (pkt->stream_index == stream_index) {
1559  av_packet_unref(pkt);
1560  break;
1561  }
1562  }
1563  av_packet_unref(pkt);
1564  }
1565 
1566  *ppos = pos;
1567  return pts;
1568 }
1569 
1570 static int asf_build_simple_index(AVFormatContext *s, int stream_index)
1571 {
1572  ff_asf_guid g;
1573  ASFContext *asf = s->priv_data;
1574  int64_t current_pos = avio_tell(s->pb);
1575  int64_t ret;
1576 
1577  if((ret = avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET)) < 0) {
1578  return ret;
1579  }
1580 
1581  if ((ret = ff_get_guid(s->pb, &g)) < 0)
1582  goto end;
1583 
1584  /* the data object can be followed by other top-level objects,
1585  * skip them until the simple index object is reached */
1586  while (ff_guidcmp(&g, &ff_asf_simple_index_header)) {
1587  int64_t gsize = avio_rl64(s->pb);
1588  if (gsize < 24 || avio_feof(s->pb)) {
1589  goto end;
1590  }
1591  avio_skip(s->pb, gsize - 24);
1592  if ((ret = ff_get_guid(s->pb, &g)) < 0)
1593  goto end;
1594  }
1595 
1596  {
1597  int64_t itime, last_pos = -1;
1598  int pct, ict;
1599  int i;
1600  int64_t av_unused gsize = avio_rl64(s->pb);
1601  if ((ret = ff_get_guid(s->pb, &g)) < 0)
1602  goto end;
1603  itime = avio_rl64(s->pb);
1604  pct = avio_rl32(s->pb);
1605  ict = avio_rl32(s->pb);
1606  av_log(s, AV_LOG_DEBUG,
1607  "itime:0x%"PRIx64", pct:%d, ict:%d\n", itime, pct, ict);
1608 
1609  for (i = 0; i < ict; i++) {
1610  int pktnum = avio_rl32(s->pb);
1611  int pktct = avio_rl16(s->pb);
1612  int64_t pos = s->internal->data_offset + s->packet_size * (int64_t)pktnum;
1613  int64_t index_pts = FFMAX(av_rescale(itime, i, 10000) - asf->hdr.preroll, 0);
1614 
1615  if (avio_feof(s->pb)) {
1616  ret = AVERROR_INVALIDDATA;
1617  goto end;
1618  }
1619 
1620  if (pos != last_pos) {
1621  av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d pts: %"PRId64"\n",
1622  pktnum, pktct, index_pts);
1623  av_add_index_entry(s->streams[stream_index], pos, index_pts,
1624  s->packet_size, 0, AVINDEX_KEYFRAME);
1625  last_pos = pos;
1626  }
1627  }
1628  asf->index_read = ict > 1;
1629  }
1630 end:
1631 // if (avio_feof(s->pb)) {
1632 // ret = 0;
1633 // }
1634  avio_seek(s->pb, current_pos, SEEK_SET);
1635  return ret;
1636 }
1637 
1638 static int asf_read_seek(AVFormatContext *s, int stream_index,
1639  int64_t pts, int flags)
1640 {
1641  ASFContext *asf = s->priv_data;
1642  AVStream *st = s->streams[stream_index];
1643  int ret = 0;
1644 
1645  if (s->packet_size <= 0)
1646  return -1;
1647 
1648  /* Try using the protocol's read_seek if available */
1649  if (s->pb) {
1650  int64_t ret = avio_seek_time(s->pb, stream_index, pts, flags);
1651  if (ret >= 0)
1652  asf_reset_header(s);
1653  if (ret != AVERROR(ENOSYS))
1654  return ret;
1655  }
1656 
1657  /* explicitly handle the case of seeking to 0 */
1658  if (!pts) {
1659  asf_reset_header(s);
1660  avio_seek(s->pb, s->internal->data_offset, SEEK_SET);
1661  return 0;
1662  }
1663 
1664  if (!asf->index_read) {
1665  ret = asf_build_simple_index(s, stream_index);
1666  if (ret < 0)
1667  asf->index_read = -1;
1668  }
1669 
1670  if (asf->index_read > 0 && st->index_entries) {
1671  int index = av_index_search_timestamp(st, pts, flags);
1672  if (index >= 0) {
1673  /* find the position */
1674  uint64_t pos = st->index_entries[index].pos;
1675 
1676  /* do the seek */
1677  av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos);
1678  if(avio_seek(s->pb, pos, SEEK_SET) < 0)
1679  return -1;
1680  asf_reset_header(s);
1681  skip_to_key(s);
1682  return 0;
1683  }
1684  }
1685  /* no index or seeking by index failed */
1686  if (ff_seek_frame_binary(s, stream_index, pts, flags) < 0)
1687  return -1;
1688  asf_reset_header(s);
1689  skip_to_key(s);
1690  return 0;
1691 }
1692 
1694  .name = "asf",
1695  .long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1696  .priv_data_size = sizeof(ASFContext),
1697  .read_probe = asf_probe,
1702  .read_timestamp = asf_read_pts,
1704  .priv_class = &asf_class,
1705 };
uint32_t palette[256]
Definition: asfdec_f.c:68
const ff_asf_guid ff_asf_header
Definition: asf.c:23
unsigned int packet_size
Definition: avformat.h:1482
#define NULL
Definition: coverity.c:32
discard all frames except keyframes
Definition: avcodec.h:810
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:473
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:643
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
#define DO_2BITS(bits, var, defval)
Definition: asfdec_f.c:933
int packet_timestamp
Definition: asfdec_f.c:94
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
const ff_asf_guid ff_asf_ext_stream_audio_stream
Definition: asf.c:104
const ff_asf_guid ff_asf_ext_content_encryption
Definition: asf.c:138
int packet_obj_size
Definition: asfdec_f.c:53
static void skip_to_key(AVFormatContext *s)
Definition: asfdec_f.c:1491
int packet_segments
Definition: asfdec_f.c:96
AVOption.
Definition: opt.h:246
static int asf_read_language_list(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:677
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:2039
const ff_asf_guid ff_asf_codec_comment_header
Definition: asf.c:73
const ff_asf_guid ff_asf_metadata_header
Definition: asf.c:108
int packet_key_frame
Definition: asfdec_f.c:99
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3124
int ts_is_pts
Definition: asfdec_f.c:104
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:101
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4882
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
int64_t pos
Definition: avformat.h:810
int num
Definition: asfdec_f.c:48
#define avpriv_request_sample(...)
int64_t data_offset
offset of the first packet
Definition: internal.h:82
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
uint64_t data_offset
beginning of the first data packet
Definition: asfdec_f.c:85
ASFMainHeader hdr
Definition: asfdec_f.c:90
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1478
static int asf_read_file_properties(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:375
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1110
int skip_to_key
Definition: asfdec_f.c:56
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1811
int64_t packet_frag_timestamp
Definition: asfdec_f.c:103
int palette_changed
Definition: asfdec_f.c:67
GLint GLenum type
Definition: opengl_enc.c:104
const ff_asf_guid ff_asf_command_stream
Definition: asf.c:65
static int asf_probe(const AVProbeData *pd)
Definition: asfdec_f.c:189
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
const char * key
const ff_asf_guid ff_asf_ext_stream_header
Definition: asf.c:35
static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:399
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
discard all
Definition: avcodec.h:811
static AVPacket pkt
int uses_std_ecc
Definition: asfdec_f.c:117
uint32_t min_pktsize
size of a data packet invalid if broadcasting
Definition: asf.h:55
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
Definition: id3v2.c:1143
int packet_time_start
Definition: asfdec_f.c:107
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
Macro definitions for various function/variable attributes.
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4583
Format I/O context.
Definition: avformat.h:1358
char str[32]
Definition: internal.h:50
const ff_asf_guid ff_asf_data_header
Definition: asf.c:80
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
int64_t duration
Definition: asfdec_f.c:55
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: utils.c:1918
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
int ffio_limit(AVIOContext *s, int size)
Definition: utils.c:247
static int64_t start_time
Definition: ffplay.c:331
uint8_t
uint32_t flags
0x01 - broadcast 0x02 - seekable rest is reserved should be 0
Definition: asf.h:52
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4019
const ff_asf_guid ff_asf_audio_stream
Definition: asf.c:39
AVOptions.
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: asfdec_f.c:1438
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1183
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
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 offset
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int packet_time_delta
Definition: asfdec_f.c:106
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
int id
Format-specific stream ID.
Definition: avformat.h:888
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
ASFStream streams[128]
it&#39;s max number and it&#39;s not that big
Definition: asfdec_f.c:77
int packet_padsize
Definition: asfdec_f.c:100
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4455
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int packet_size_left
Definition: asfdec_f.c:83
static void finish(void)
Definition: movenc.c:345
uint8_t * data
Definition: avcodec.h:1477
uint64_t send_time
time to send file, in 100-nanosecond units invalid if broadcasting (could be ignored) ...
Definition: asf.h:47
#define AVERROR_EOF
End of file.
Definition: error.h:55
enum AVCodecID id
Definition: internal.h:51
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
AVPacket pkt
Definition: asfdec_f.c:51
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
static int asf_read_marker(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:742
int asfid2avid[128]
conversion table from asf ID 2 AVStream ID
Definition: asfdec_f.c:76
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:648
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
uint64_t file_size
in bytes invalid if broadcasting
Definition: asf.h:41
ff_asf_guid guid
generated by client computer
Definition: asf.h:40
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3982
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
static int asf_read_metadata(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:697
#define U(x)
Definition: vp56_arith.h:37
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
const ff_asf_guid ff_asf_audio_conceal_none
Definition: asf.c:43
int packet_replic_size
Definition: asfdec_f.c:98
#define FRAME_HEADER_SIZE
Definition: asfdec_f.c:137
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
const ff_asf_guid ff_asf_head1_guid
Definition: asf.c:84
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2148
static const AVOption options[]
Definition: asfdec_f.c:120
static int asf_build_simple_index(AVFormatContext *s, int stream_index)
Definition: asfdec_f.c:1570
const ff_asf_guid ff_asf_simple_index_header
Definition: asf.c:96
const ff_asf_guid ff_asf_head2_guid
Definition: asf.c:88
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:770
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:736
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static int asf_read_picture(AVFormatContext *s, int len)
Definition: asfdec_f.c:218
void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len)
Definition: asfcrypt.c:147
int packet_seq
Definition: asfdec_f.c:97
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1460
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1127
const ff_asf_guid ff_asf_video_conceal_none
Definition: asf.c:61
int ds_chunk_size
Definition: asfdec_f.c:61
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
Definition: riffdec.c:32
int pkt_clean
Definition: asfdec_f.c:57
static int asf_read_content_desc(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:624
int side_data_elems
Definition: avcodec.h:1489
static const AVClass asf_class
Definition: asfdec_f.c:126
int frag_offset
Definition: asfdec_f.c:52
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
uint64_t data_object_size
size of the data object
Definition: asfdec_f.c:87
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
#define fail()
Definition: checkasm.h:120
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3971
Definition: asf.h:32
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:639
uint32_t max_pktsize
shall be the same as for min_pktsize invalid if broadcasting
Definition: asf.h:57
static int asf_read_close(AVFormatContext *s)
Definition: asfdec_f.c:1506
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
const CodecMime ff_id3v2_mime_tags[]
Definition: id3v2.c:131
common internal API header
uint16_t size
Definition: asfdec_f.c:44
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: asfdec_f.c:1513
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int export_xmp
Definition: asfdec_f.c:115
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define FFMIN(a, b)
Definition: common.h:96
const ff_asf_guid ff_asf_digital_signature
Definition: asf.c:142
static void get_id3_tag(AVFormatContext *s, int len)
Definition: asfdec_f.c:305
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
char stream_languages[128][6]
max number of streams, language for each (RFC1766, e.g. en-US)
Definition: asfdec_f.c:80
#define print_guid(g)
Definition: asfdec_f.c:186
const ff_asf_guid ff_asf_extended_content_header
Definition: asf.c:92
ASFStream * asf_st
currently decoded stream
Definition: asfdec_f.c:112
unsigned int packet_frag_size
Definition: asfdec_f.c:102
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
int timestamp
Definition: asfdec_f.c:54
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
const ff_asf_guid ff_asf_ext_stream_embed_stream_header
Definition: asf.c:100
int packet_multi_size
Definition: asfdec_f.c:105
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:945
const ff_asf_guid ff_asf_my_guid
Definition: asf.c:126
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb)
Definition: asfdec_f.c:1080
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
Definition: asfdec_f.c:1638
#define FF_ARRAY_ELEMS(a)
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:849
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
if(ret)
uint8_t ff_asf_guid[16]
Definition: riff.h:90
Stream structure.
Definition: avformat.h:881
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
uint32_t ignore
preroll is 64 bits - but let&#39;s just ignore it
Definition: asf.h:51
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
uint32_t stream_bitrates[128]
max number of streams, bitrate for each (for streaming)
Definition: asfdec_f.c:78
#define av_bswap32
Definition: bswap.h:33
int ds_span
Definition: asfdec_f.c:59
uint64_t create_time
time of creation, in 100-nanosecond units since 1.1.1601 invalid if broadcasting
Definition: asf.h:43
const ff_asf_guid ff_asf_file_header
Definition: asf.c:27
uint64_t play_time
play time, in 100-nanosecond units invalid if broadcasting
Definition: asf.h:45
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
const ff_asf_guid ff_asf_video_stream
Definition: asf.c:53
AVInputFormat ff_asf_demuxer
Definition: asfdec_f.c:1693
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint16_t stream_language_index
Definition: asfdec_f.c:65
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:474
void * buf
Definition: avisynth_c.h:766
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int index_read
Definition: asfdec_f.c:88
Describe the class of an AVClass context structure.
Definition: log.h:67
int index
Definition: gxfenc.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int ds_packet_size
Definition: asfdec_f.c:60
#define LEN
const ff_asf_guid ff_asf_stream_header
Definition: asf.c:31
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
unsigned int packet_frag_offset
Definition: asfdec_f.c:101
byte swapping routines
AVMediaType
Definition: avutil.h:199
const AVMetadataConv ff_asf_metadata_conv[]
Definition: asf.c:159
#define snprintf
Definition: snprintf.h:34
uint64_t data_object_offset
data object offset (excl. GUID & size)
Definition: asfdec_f.c:86
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
static void get_tag(AVFormatContext *s, const char *key, int type, int len, int type2_size)
Definition: asfdec_f.c:317
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1768
full parsing and repack of the first frame only, only implemented for H.264 currently ...
Definition: avformat.h:803
int packet_property
Definition: asfdec_f.c:93
const ff_asf_guid ff_asf_comment_header
Definition: asf.c:69
ASFPayload payload[8]
Definition: asfdec_f.c:71
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
uint8_t type
Definition: asfdec_f.c:43
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
uint32_t preroll
timestamp of the first packet, in milliseconds if nonzero - subtract from time
Definition: asf.h:49
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
const uint8_t * key
Definition: avformat.h:1534
int64_t packet_pos
Definition: asfdec_f.c:63
A reference to a data buffer.
Definition: buffer.h:81
const ff_asf_guid ff_asf_language_guid
Definition: asf.c:130
full parsing and repack
Definition: avformat.h:800
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:754
Main libavformat public API header.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: avcodec.h:1488
const ff_asf_guid ff_asf_jfif_media
Definition: asf.c:57
Definition: asf.h:36
common internal and external API header
Definition: asf.h:35
int no_resync_search
Definition: asfdec_f.c:114
unsigned char seq
Definition: asfdec_f.c:49
static int asf_read_header(AVFormatContext *s)
Definition: asfdec_f.c:780
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
const ff_asf_guid ff_asf_codec_comment1_header
Definition: asf.c:76
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
Read an ID3v2 tag, including supported extra metadata.
Definition: id3v2.c:1121
int den
Denominator.
Definition: rational.h:60
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
int64_t packet_pos
Definition: asfdec_f.c:108
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
int payload_ext_ct
Definition: asfdec_f.c:70
int64_t avio_seek_time(AVIOContext *h, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp relative to some component stream.
Definition: aviobuf.c:1242
const ff_asf_guid ff_asf_content_encryption
Definition: asf.c:134
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int len
AVRational dar[128]
Definition: asfdec_f.c:79
void * priv_data
Format private data.
Definition: avformat.h:1386
int packet_flags
Definition: asfdec_f.c:92
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3995
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3967
int packet_segsizetype
Definition: asfdec_f.c:95
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
int stream_index
Definition: asfdec_f.c:110
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
const char *const ff_id3v2_picture_types[21]
Definition: id3v2.c:107
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:358
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3957
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
const ff_asf_guid ff_asf_marker_header
Definition: asf.c:116
Definition: asf.h:34
void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
Send a nice hexadecimal dump of a buffer to the log.
Definition: dump.c:79
static int asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Parse data from individual ASF packets (which were previously loaded with asf_get_packet()).
Definition: asfdec_f.c:1209
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
int stream_index
Definition: avcodec.h:1479
Definition: asf.h:33
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:936
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
Definition: riff.h:116
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1139
enum AVCodecID id
This structure stores compressed data.
Definition: avcodec.h:1454
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:778
#define ASF_MAX_STREAMS
Definition: asfdec_f.c:136
uint32_t max_bitrate
bandwidth of stream in bps should be the sum of bitrates of the individual media streams ...
Definition: asf.h:59
static int asf_get_packet(AVFormatContext *s, AVIOContext *pb)
Load a single ASF packet into the demuxer.
Definition: asfdec_f.c:958
const ff_asf_guid ff_asf_metadata_library_header
Definition: asf.c:112
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
for(j=16;j >0;--j)
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:963
static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
Definition: asfdec_f.c:566
static int get_value(AVIOContext *pb, int type, int type2_size)
Definition: asfdec_f.c:200
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and AVInputFormat.read_timestamp().
Definition: utils.c:2163
#define av_unused
Definition: attributes.h:125
static void asf_reset_header(AVFormatContext *s)
Definition: asfdec_f.c:1458
const char * name
Definition: opengl_enc.c:102