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