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