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 (!st->codecpar->codec_id)
450  if (tag1 == MKTAG('D', 'V', 'R', ' ')) {
452  /* issue658 contains wrong w/h and MS even puts a fake seq header
453  * with wrong w/h in extradata while a correct one is in the stream.
454  * maximum lameness */
455  st->codecpar->width =
456  st->codecpar->height = 0;
457  av_freep(&st->codecpar->extradata);
458  st->codecpar->extradata_size = 0;
459  }
460  if (st->codecpar->codec_id == AV_CODEC_ID_H264)
462  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4)
464  if (st->codecpar->codec_id == AV_CODEC_ID_HEVC)
466  }
467  pos2 = avio_tell(pb);
468  avio_skip(pb, size - (pos2 - pos1 + 24));
469 
470  return 0;
471 }
472 
474 {
475  ASFContext *asf = s->priv_data;
476  AVIOContext *pb = s->pb;
477  ff_asf_guid g;
478  int ext_len, payload_ext_ct, stream_ct, i;
479  uint32_t leak_rate, stream_num;
480  unsigned int stream_languageid_index;
481 
482  avio_rl64(pb); // starttime
483  avio_rl64(pb); // endtime
484  leak_rate = avio_rl32(pb); // leak-datarate
485  avio_rl32(pb); // bucket-datasize
486  avio_rl32(pb); // init-bucket-fullness
487  avio_rl32(pb); // alt-leak-datarate
488  avio_rl32(pb); // alt-bucket-datasize
489  avio_rl32(pb); // alt-init-bucket-fullness
490  avio_rl32(pb); // max-object-size
491  avio_rl32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
492  stream_num = avio_rl16(pb); // stream-num
493 
494  stream_languageid_index = avio_rl16(pb); // stream-language-id-index
495  if (stream_num < 128)
496  asf->streams[stream_num].stream_language_index = stream_languageid_index;
497 
498  avio_rl64(pb); // avg frametime in 100ns units
499  stream_ct = avio_rl16(pb); // stream-name-count
500  payload_ext_ct = avio_rl16(pb); // payload-extension-system-count
501 
502  if (stream_num < 128) {
503  asf->stream_bitrates[stream_num] = leak_rate;
504  asf->streams[stream_num].payload_ext_ct = 0;
505  }
506 
507  for (i = 0; i < stream_ct; i++) {
508  avio_rl16(pb);
509  ext_len = avio_rl16(pb);
510  avio_skip(pb, ext_len);
511  }
512 
513  for (i = 0; i < payload_ext_ct; i++) {
514  int size;
515  ff_get_guid(pb, &g);
516  size = avio_rl16(pb);
517  ext_len = avio_rl32(pb);
518  if (ext_len < 0)
519  return AVERROR_INVALIDDATA;
520  avio_skip(pb, ext_len);
521  if (stream_num < 128 && i < FF_ARRAY_ELEMS(asf->streams[stream_num].payload)) {
522  ASFPayload *p = &asf->streams[stream_num].payload[i];
523  p->type = g[0];
524  p->size = size;
525  av_log(s, AV_LOG_DEBUG, "Payload extension %x %d\n", g[0], p->size );
526  asf->streams[stream_num].payload_ext_ct ++;
527  }
528  }
529 
530  return 0;
531 }
532 
534 {
535  AVIOContext *pb = s->pb;
536  int len1, len2, len3, len4, len5;
537 
538  len1 = avio_rl16(pb);
539  len2 = avio_rl16(pb);
540  len3 = avio_rl16(pb);
541  len4 = avio_rl16(pb);
542  len5 = avio_rl16(pb);
543  get_tag(s, "title", 0, len1, 32);
544  get_tag(s, "author", 0, len2, 32);
545  get_tag(s, "copyright", 0, len3, 32);
546  get_tag(s, "comment", 0, len4, 32);
547  avio_skip(pb, len5);
548 
549  return 0;
550 }
551 
553 {
554  AVIOContext *pb = s->pb;
555  ASFContext *asf = s->priv_data;
556  int desc_count, i, ret;
557 
558  desc_count = avio_rl16(pb);
559  for (i = 0; i < desc_count; i++) {
560  int name_len, value_type, value_len;
561  char name[1024];
562 
563  name_len = avio_rl16(pb);
564  if (name_len % 2) // must be even, broken lavf versions wrote len-1
565  name_len += 1;
566  if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
567  avio_skip(pb, name_len - ret);
568  value_type = avio_rl16(pb);
569  value_len = avio_rl16(pb);
570  if (!value_type && value_len % 2)
571  value_len += 1;
572  /* My sample has that stream set to 0 maybe that mean the container.
573  * ASF stream count starts at 1. I am using 0 to the container value
574  * since it's unused. */
575  if (!strcmp(name, "AspectRatioX"))
576  asf->dar[0].num = get_value(s->pb, value_type, 32);
577  else if (!strcmp(name, "AspectRatioY"))
578  asf->dar[0].den = get_value(s->pb, value_type, 32);
579  else
580  get_tag(s, name, value_type, value_len, 32);
581  }
582 
583  return 0;
584 }
585 
587 {
588  AVIOContext *pb = s->pb;
589  ASFContext *asf = s->priv_data;
590  int j, ret;
591  int stream_count = avio_rl16(pb);
592  for (j = 0; j < stream_count; j++) {
593  char lang[6];
594  unsigned int lang_len = avio_r8(pb);
595  if ((ret = avio_get_str16le(pb, lang_len, lang,
596  sizeof(lang))) < lang_len)
597  avio_skip(pb, lang_len - ret);
598  if (j < 128)
599  av_strlcpy(asf->stream_languages[j], lang,
600  sizeof(*asf->stream_languages));
601  }
602 
603  return 0;
604 }
605 
607 {
608  AVIOContext *pb = s->pb;
609  ASFContext *asf = s->priv_data;
610  int n, stream_num, name_len_utf16, name_len_utf8, value_len;
611  int ret, i;
612  n = avio_rl16(pb);
613 
614  for (i = 0; i < n; i++) {
615  uint8_t *name;
616  int value_type;
617 
618  avio_rl16(pb); // lang_list_index
619  stream_num = avio_rl16(pb);
620  name_len_utf16 = avio_rl16(pb);
621  value_type = avio_rl16(pb); /* value_type */
622  value_len = avio_rl32(pb);
623 
624  if (value_len < 0 || value_len > UINT16_MAX)
625  return AVERROR_INVALIDDATA;
626 
627  name_len_utf8 = 2*name_len_utf16 + 1;
628  name = av_malloc(name_len_utf8);
629  if (!name)
630  return AVERROR(ENOMEM);
631 
632  if ((ret = avio_get_str16le(pb, name_len_utf16, name, name_len_utf8)) < name_len_utf16)
633  avio_skip(pb, name_len_utf16 - ret);
634  av_log(s, AV_LOG_TRACE, "%d stream %d name_len %2d type %d len %4d <%s>\n",
635  i, stream_num, name_len_utf16, value_type, value_len, name);
636 
637  if (!strcmp(name, "AspectRatioX")){
638  int aspect_x = get_value(s->pb, value_type, 16);
639  if(stream_num < 128)
640  asf->dar[stream_num].num = aspect_x;
641  } else if(!strcmp(name, "AspectRatioY")){
642  int aspect_y = get_value(s->pb, value_type, 16);
643  if(stream_num < 128)
644  asf->dar[stream_num].den = aspect_y;
645  } else {
646  get_tag(s, name, value_type, value_len, 16);
647  }
648  av_freep(&name);
649  }
650 
651  return 0;
652 }
653 
655 {
656  AVIOContext *pb = s->pb;
657  ASFContext *asf = s->priv_data;
658  int i, count, name_len, ret;
659  char name[1024];
660 
661  avio_rl64(pb); // reserved 16 bytes
662  avio_rl64(pb); // ...
663  count = avio_rl32(pb); // markers count
664  avio_rl16(pb); // reserved 2 bytes
665  name_len = avio_rl16(pb); // name length
666  avio_skip(pb, name_len);
667 
668  for (i = 0; i < count; i++) {
669  int64_t pres_time;
670  int name_len;
671 
672  if (avio_feof(pb))
673  return AVERROR_INVALIDDATA;
674 
675  avio_rl64(pb); // offset, 8 bytes
676  pres_time = avio_rl64(pb); // presentation time
677  pres_time = av_sat_sub64(pres_time, asf->hdr.preroll * 10000);
678  avio_rl16(pb); // entry length
679  avio_rl32(pb); // send time
680  avio_rl32(pb); // flags
681  name_len = avio_rl32(pb); // name length
682  if ((unsigned)name_len > INT_MAX / 2)
683  return AVERROR_INVALIDDATA;
684  if ((ret = avio_get_str16le(pb, name_len * 2, name,
685  sizeof(name))) < name_len)
686  avio_skip(pb, name_len - ret);
687  avpriv_new_chapter(s, i, (AVRational) { 1, 10000000 }, pres_time,
689  }
690 
691  return 0;
692 }
693 
695 {
696  ASFContext *asf = s->priv_data;
697  ff_asf_guid g;
698  AVIOContext *pb = s->pb;
699  int i;
700  int64_t gsize;
701 
702  ff_get_guid(pb, &g);
703  if (ff_guidcmp(&g, &ff_asf_header))
704  return AVERROR_INVALIDDATA;
705  avio_rl64(pb);
706  avio_rl32(pb);
707  avio_r8(pb);
708  avio_r8(pb);
709  memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
710 
711  for (i = 0; i<128; i++)
712  asf->streams[i].stream_language_index = 128; // invalid stream index means no language info
713 
714  for (;;) {
715  uint64_t gpos = avio_tell(pb);
716  int ret = 0;
717  ff_get_guid(pb, &g);
718  gsize = avio_rl64(pb);
719  print_guid(&g);
720  if (!ff_guidcmp(&g, &ff_asf_data_header)) {
721  asf->data_object_offset = avio_tell(pb);
722  /* If not streaming, gsize is not unlimited (how?),
723  * and there is enough space in the file.. */
724  if (!(asf->hdr.flags & 0x01) && gsize >= 100)
725  asf->data_object_size = gsize - 24;
726  else
727  asf->data_object_size = (uint64_t)-1;
728  break;
729  }
730  if (gsize < 24)
731  return AVERROR_INVALIDDATA;
732  if (!ff_guidcmp(&g, &ff_asf_file_header)) {
734  } else if (!ff_guidcmp(&g, &ff_asf_stream_header)) {
735  ret = asf_read_stream_properties(s, gsize);
736  } else if (!ff_guidcmp(&g, &ff_asf_comment_header)) {
738  } else if (!ff_guidcmp(&g, &ff_asf_language_guid)) {
740  } else if (!ff_guidcmp(&g, &ff_asf_extended_content_header)) {
742  } else if (!ff_guidcmp(&g, &ff_asf_metadata_header)) {
744  } else if (!ff_guidcmp(&g, &ff_asf_metadata_library_header)) {
746  } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_header)) {
748 
749  // there could be an optional stream properties object to follow
750  // if so the next iteration will pick it up
751  continue;
752  } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
753  ff_get_guid(pb, &g);
754  avio_skip(pb, 6);
755  continue;
756  } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
758  } else if (avio_feof(pb)) {
759  return AVERROR_EOF;
760  } else {
761  if (!s->keylen) {
764  unsigned int len;
766  "DRM protected stream detected, decoding will likely fail!\n");
767  len= avio_rl32(pb);
768  av_log(s, AV_LOG_DEBUG, "Secret data:\n");
769 
770  if ((ret = av_get_packet(pb, pkt, len)) < 0)
771  return ret;
774 
775  len= avio_rl32(pb);
776  if (len > UINT16_MAX)
777  return AVERROR_INVALIDDATA;
778  get_tag(s, "ASF_Protection_Type", -1, len, 32);
779 
780  len= avio_rl32(pb);
781  if (len > UINT16_MAX)
782  return AVERROR_INVALIDDATA;
783  get_tag(s, "ASF_Key_ID", -1, len, 32);
784 
785  len= avio_rl32(pb);
786  if (len > UINT16_MAX)
787  return AVERROR_INVALIDDATA;
788  get_tag(s, "ASF_License_URL", -1, len, 32);
789  } else if (!ff_guidcmp(&g, &ff_asf_ext_content_encryption)) {
791  "Ext DRM protected stream detected, decoding will likely fail!\n");
792  av_dict_set(&s->metadata, "encryption", "ASF Extended Content Encryption", 0);
793  } else if (!ff_guidcmp(&g, &ff_asf_digital_signature)) {
794  av_log(s, AV_LOG_INFO, "Digital signature detected!\n");
795  }
796  }
797  }
798  if (ret < 0)
799  return ret;
800 
801  if (avio_tell(pb) != gpos + gsize)
803  "gpos mismatch our pos=%"PRIu64", end=%"PRId64"\n",
804  avio_tell(pb) - gpos, gsize);
805  avio_seek(pb, gpos + gsize, SEEK_SET);
806  }
807  ff_get_guid(pb, &g);
808  avio_rl64(pb);
809  avio_r8(pb);
810  avio_r8(pb);
811  if (avio_feof(pb))
812  return AVERROR_EOF;
813  asf->data_offset = avio_tell(pb);
814  asf->packet_size_left = 0;
815 
816  for (i = 0; i < 128; i++) {
817  int stream_num = asf->asfid2avid[i];
818  if (stream_num >= 0) {
819  AVStream *st = s->streams[stream_num];
820  if (!st->codecpar->bit_rate)
821  st->codecpar->bit_rate = asf->stream_bitrates[i];
822  if (asf->dar[i].num > 0 && asf->dar[i].den > 0) {
825  asf->dar[i].num, asf->dar[i].den, INT_MAX);
826  } else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) &&
827  // Use ASF container value if the stream doesn't set AR.
831  asf->dar[0].num, asf->dar[0].den, INT_MAX);
832 
833  av_log(s, AV_LOG_TRACE, "i=%d, st->codecpar->codec_type:%d, asf->dar %d:%d sar=%d:%d\n",
834  i, st->codecpar->codec_type, asf->dar[i].num, asf->dar[i].den,
836 
837  // copy and convert language codes to the frontend
838  if (asf->streams[i].stream_language_index < 128) {
839  const char *rfc1766 = asf->stream_languages[asf->streams[i].stream_language_index];
840  if (rfc1766 && strlen(rfc1766) > 1) {
841  const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any
842  const char *iso6392 = ff_convert_lang_to(primary_tag,
844  if (iso6392)
845  av_dict_set(&st->metadata, "language", iso6392, 0);
846  }
847  }
848  }
849  }
850 
852 
853  return 0;
854 }
855 
856 #define DO_2BITS(bits, var, defval) \
857  switch (bits & 3) { \
858  case 3: \
859  var = avio_rl32(pb); \
860  rsize += 4; \
861  break; \
862  case 2: \
863  var = avio_rl16(pb); \
864  rsize += 2; \
865  break; \
866  case 1: \
867  var = avio_r8(pb); \
868  rsize++; \
869  break; \
870  default: \
871  var = defval; \
872  break; \
873  }
874 
875 /**
876  * Load a single ASF packet into the demuxer.
877  * @param s demux context
878  * @param pb context to read data from
879  * @return 0 on success, <0 on error
880  */
882 {
883  ASFContext *asf = s->priv_data;
884  uint32_t packet_length, padsize;
885  int rsize = 8;
886  int c, d, e, off;
887 
888  if (asf->uses_std_ecc > 0) {
889  // if we do not know packet size, allow skipping up to 32 kB
890  off = 32768;
891  if (asf->no_resync_search)
892  off = 3;
893 // else if (s->packet_size > 0 && !asf->uses_std_ecc)
894 // off = (avio_tell(pb) - ffformatcontext(s)->data_offset) % s->packet_size + 3;
895 
896  c = d = e = -1;
897  while (off-- > 0) {
898  c = d;
899  d = e;
900  e = avio_r8(pb);
901  if (c == 0x82 && !d && !e)
902  break;
903  }
904 
905  if (c != 0x82) {
906  /* This code allows handling of -EAGAIN at packet boundaries (i.e.
907  * if the packet sync code above triggers -EAGAIN). This does not
908  * imply complete -EAGAIN handling support at random positions in
909  * the stream. */
910  if (pb->error == AVERROR(EAGAIN))
911  return AVERROR(EAGAIN);
912  if (!avio_feof(pb))
914  "ff asf bad header %x at:%"PRId64"\n", c, avio_tell(pb));
915  }
916  if ((c & 0x8f) == 0x82) {
917  if (d || e) {
918  if (!avio_feof(pb))
919  av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
920  return AVERROR_INVALIDDATA;
921  }
922  c = avio_r8(pb);
923  d = avio_r8(pb);
924  rsize += 3;
925  } else if(!avio_feof(pb)) {
926  avio_seek(pb, -1, SEEK_CUR); // FIXME
927  }
928  } else {
929  c = avio_r8(pb);
930  if (c & 0x80) {
931  rsize ++;
932  if (!(c & 0x60)) {
933  d = avio_r8(pb);
934  e = avio_r8(pb);
935  avio_seek(pb, (c & 0xF) - 2, SEEK_CUR);
936  rsize += c & 0xF;
937  }
938 
939  if (c != 0x82)
940  avpriv_request_sample(s, "Invalid ECC byte");
941 
942  if (!asf->uses_std_ecc)
943  asf->uses_std_ecc = (c == 0x82 && !d && !e) ? 1 : -1;
944 
945  c = avio_r8(pb);
946  } else
947  asf->uses_std_ecc = -1;
948  d = avio_r8(pb);
949  }
950 
951  asf->packet_flags = c;
952  asf->packet_property = d;
953 
954  DO_2BITS(asf->packet_flags >> 5, packet_length, s->packet_size);
955  DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored
956  DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length
957 
958  // the following checks prevent overflows and infinite loops
959  if (!packet_length || packet_length >= (1U << 29)) {
961  "invalid packet_length %"PRIu32" at:%"PRId64"\n",
962  packet_length, avio_tell(pb));
963  return AVERROR_INVALIDDATA;
964  }
965  if (padsize >= packet_length) {
967  "invalid padsize %"PRIu32" at:%"PRId64"\n", padsize, avio_tell(pb));
968  return AVERROR_INVALIDDATA;
969  }
970 
971  asf->packet_timestamp = avio_rl32(pb);
972  avio_rl16(pb); /* duration */
973  // rsize has at least 11 bytes which have to be present
974 
975  if (asf->packet_flags & 0x01) {
976  asf->packet_segsizetype = avio_r8(pb);
977  rsize++;
978  asf->packet_segments = asf->packet_segsizetype & 0x3f;
979  } else {
980  asf->packet_segments = 1;
981  asf->packet_segsizetype = 0x80;
982  }
983  if (rsize > packet_length - padsize) {
984  asf->packet_size_left = 0;
986  "invalid packet header length %d for pktlen %"PRIu32"-%"PRIu32" at %"PRId64"\n",
987  rsize, packet_length, padsize, avio_tell(pb));
988  return AVERROR_INVALIDDATA;
989  }
990  asf->packet_size_left = packet_length - padsize - rsize;
991  if (packet_length < asf->hdr.min_pktsize)
992  padsize += asf->hdr.min_pktsize - packet_length;
993  asf->packet_padsize = padsize;
994  av_log(s, AV_LOG_TRACE, "packet: size=%d padsize=%d left=%d\n",
995  s->packet_size, asf->packet_padsize, asf->packet_size_left);
996  return 0;
997 }
998 
999 /**
1000  *
1001  * @return <0 if error
1002  */
1004 {
1005  ASFContext *asf = s->priv_data;
1006  ASFStream *asfst;
1007  int rsize = 1;
1008  int num = avio_r8(pb);
1009  int i;
1010  int64_t ts0, ts1 av_unused;
1011 
1012  asf->packet_segments--;
1013  asf->packet_key_frame = num >> 7;
1014  asf->stream_index = asf->asfid2avid[num & 0x7f];
1015  asfst = &asf->streams[num & 0x7f];
1016  // sequence should be ignored!
1017  DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);
1018  DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);
1020  av_log(asf, AV_LOG_TRACE, "key:%d stream:%d seq:%d offset:%d replic_size:%d num:%X packet_property %X\n",
1021  asf->packet_key_frame, asf->stream_index, asf->packet_seq,
1022  asf->packet_frag_offset, asf->packet_replic_size, num, asf->packet_property);
1023  if (rsize+(int64_t)asf->packet_replic_size > asf->packet_size_left) {
1024  av_log(s, AV_LOG_ERROR, "packet_replic_size %d is invalid\n", asf->packet_replic_size);
1025  return AVERROR_INVALIDDATA;
1026  }
1027  if (asf->packet_replic_size >= 8) {
1028  int64_t end = avio_tell(pb) + asf->packet_replic_size;
1029  AVRational aspect;
1030  asfst->packet_obj_size = avio_rl32(pb);
1031  if (asfst->packet_obj_size >= (1 << 24) || asfst->packet_obj_size < 0) {
1032  av_log(s, AV_LOG_ERROR, "packet_obj_size %d invalid\n", asfst->packet_obj_size);
1033  asfst->packet_obj_size = 0;
1034  return AVERROR_INVALIDDATA;
1035  }
1036  asf->packet_frag_timestamp = avio_rl32(pb); // timestamp
1037 
1038  for (i = 0; i < asfst->payload_ext_ct; i++) {
1039  ASFPayload *p = &asfst->payload[i];
1040  int size = p->size;
1041  int64_t payend;
1042  if (size == 0xFFFF)
1043  size = avio_rl16(pb);
1044  payend = avio_tell(pb) + size;
1045  if (payend > end) {
1046  av_log(s, AV_LOG_ERROR, "too long payload\n");
1047  break;
1048  }
1049  switch (p->type) {
1050  case 0x50:
1051 // duration = avio_rl16(pb);
1052  break;
1053  case 0x54:
1054  aspect.num = avio_r8(pb);
1055  aspect.den = avio_r8(pb);
1056  if (aspect.num > 0 && aspect.den > 0 && asf->stream_index >= 0) {
1057  s->streams[asf->stream_index]->sample_aspect_ratio = aspect;
1058  }
1059  break;
1060  case 0x2A:
1061  avio_skip(pb, 8);
1062  ts0 = avio_rl64(pb);
1063  ts1 = avio_rl64(pb);
1064  if (ts0!= -1) asf->packet_frag_timestamp = ts0/10000;
1066  asf->ts_is_pts = 1;
1067  break;
1068  case 0x5B:
1069  case 0xB7:
1070  case 0xCC:
1071  case 0xC0:
1072  case 0xA0:
1073  //unknown
1074  break;
1075  }
1076  avio_seek(pb, payend, SEEK_SET);
1077  }
1078 
1079  avio_seek(pb, end, SEEK_SET);
1080  rsize += asf->packet_replic_size; // FIXME - check validity
1081  } else if (asf->packet_replic_size == 1) {
1082  // multipacket - frag_offset is beginning timestamp
1084  asf->packet_frag_offset = 0;
1086 
1087  asf->packet_time_delta = avio_r8(pb);
1088  rsize++;
1089  } else if (asf->packet_replic_size != 0) {
1090  av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n",
1091  asf->packet_replic_size);
1092  return AVERROR_INVALIDDATA;
1093  }
1094  if (asf->packet_flags & 0x01) {
1095  DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal
1096  if (rsize > asf->packet_size_left) {
1097  av_log(s, AV_LOG_ERROR, "packet_replic_size is invalid\n");
1098  return AVERROR_INVALIDDATA;
1099  } else if (asf->packet_frag_size > asf->packet_size_left - rsize) {
1100  if (asf->packet_frag_size > asf->packet_size_left - rsize + asf->packet_padsize) {
1101  av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid (%d>%d-%d+%d)\n",
1102  asf->packet_frag_size, asf->packet_size_left, rsize, asf->packet_padsize);
1103  return AVERROR_INVALIDDATA;
1104  } else {
1105  int diff = asf->packet_frag_size - (asf->packet_size_left - rsize);
1106  asf->packet_size_left += diff;
1107  asf->packet_padsize -= diff;
1108  }
1109  }
1110  } else {
1111  asf->packet_frag_size = asf->packet_size_left - rsize;
1112  }
1113  if (asf->packet_replic_size == 1) {
1114  asf->packet_multi_size = asf->packet_frag_size;
1115  if (asf->packet_multi_size > asf->packet_size_left)
1116  return AVERROR_INVALIDDATA;
1117  }
1118  asf->packet_size_left -= rsize;
1119 
1120  return 0;
1121 }
1122 
1123 /**
1124  * Parse data from individual ASF packets (which were previously loaded
1125  * with asf_get_packet()).
1126  * @param s demux context
1127  * @param pb context to read data from
1128  * @param pkt pointer to store packet data into
1129  * @return 0 if data was stored in pkt, <0 on error or 1 if more ASF
1130  * packets need to be loaded (through asf_get_packet())
1131  */
1133 {
1134  ASFContext *asf = s->priv_data;
1135  ASFStream *asf_st = 0;
1136  for (;;) {
1137  int ret;
1138  if (avio_feof(pb))
1139  return AVERROR_EOF;
1140  if (asf->packet_size_left < FRAME_HEADER_SIZE ||
1141  asf->packet_segments < 1 && asf->packet_time_start == 0) {
1142  int ret = asf->packet_size_left + asf->packet_padsize;
1143 
1145  av_log(s, AV_LOG_WARNING, "Skip due to FRAME_HEADER_SIZE\n");
1146 
1147  assert(ret >= 0);
1148  /* fail safe */
1149  avio_skip(pb, ret);
1150 
1151  asf->packet_pos = avio_tell(pb);
1152  if (asf->data_object_size != (uint64_t)-1 &&
1153  (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
1154  return AVERROR_EOF; /* Do not exceed the size of the data object */
1155  return 1;
1156  }
1157  if (asf->packet_time_start == 0) {
1158  if (asf_read_frame_header(s, pb) < 0) {
1159  asf->packet_time_start = asf->packet_segments = 0;
1160  continue;
1161  }
1162  if (asf->stream_index < 0 ||
1163  s->streams[asf->stream_index]->discard >= AVDISCARD_ALL ||
1164  (!asf->packet_key_frame &&
1165  (s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY || asf->streams[s->streams[asf->stream_index]->id].skip_to_key))) {
1166  asf->packet_time_start = 0;
1167  /* unhandled packet (should not happen) */
1168  avio_skip(pb, asf->packet_frag_size);
1169  asf->packet_size_left -= asf->packet_frag_size;
1170  if (asf->stream_index < 0)
1171  av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n",
1172  asf->packet_frag_size);
1173  continue;
1174  }
1175  asf->asf_st = &asf->streams[s->streams[asf->stream_index]->id];
1176  if (!asf->packet_frag_offset)
1177  asf->asf_st->skip_to_key = 0;
1178  }
1179  asf_st = asf->asf_st;
1180  av_assert0(asf_st);
1181 
1182  if (!asf_st->frag_offset && asf->packet_frag_offset) {
1183  av_log(s, AV_LOG_TRACE, "skipping asf data pkt with fragment offset for "
1184  "stream:%d, expected:%d but got %d from pkt)\n",
1185  asf->stream_index, asf_st->frag_offset,
1186  asf->packet_frag_offset);
1187  avio_skip(pb, asf->packet_frag_size);
1188  asf->packet_size_left -= asf->packet_frag_size;
1189  continue;
1190  }
1191 
1192  if (asf->packet_replic_size == 1) {
1193  // frag_offset is here used as the beginning timestamp
1195  asf->packet_time_start += asf->packet_time_delta;
1196  asf_st->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
1197  asf->packet_size_left--;
1198  asf->packet_multi_size--;
1199  if (asf->packet_multi_size < asf_st->packet_obj_size) {
1200  asf->packet_time_start = 0;
1201  avio_skip(pb, asf->packet_multi_size);
1202  asf->packet_size_left -= asf->packet_multi_size;
1203  continue;
1204  }
1205  asf->packet_multi_size -= asf_st->packet_obj_size;
1206  }
1207 
1208  if (asf_st->pkt.size != asf_st->packet_obj_size ||
1209  // FIXME is this condition sufficient?
1210  asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) {
1211  int ret;
1212 
1213  if (asf_st->pkt.data) {
1214  av_log(s, AV_LOG_INFO,
1215  "freeing incomplete packet size %d, new %d\n",
1216  asf_st->pkt.size, asf_st->packet_obj_size);
1217  asf_st->frag_offset = 0;
1218  av_packet_unref(&asf_st->pkt);
1219  }
1220  /* new packet */
1221  if ((ret = av_new_packet(&asf_st->pkt, asf_st->packet_obj_size)) < 0)
1222  return ret;
1223  asf_st->seq = asf->packet_seq;
1224  if (asf->packet_frag_timestamp != AV_NOPTS_VALUE) {
1225  if (asf->ts_is_pts) {
1226  asf_st->pkt.pts = asf->packet_frag_timestamp - asf->hdr.preroll;
1227  } else
1228  asf_st->pkt.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
1229  }
1230  asf_st->pkt.stream_index = asf->stream_index;
1231  asf_st->pkt.pos = asf_st->packet_pos = asf->packet_pos;
1232  asf_st->pkt_clean = 0;
1233 
1234  if (asf_st->pkt.data && asf_st->palette_changed) {
1235  uint8_t *pal;
1237  AVPALETTE_SIZE);
1238  if (!pal) {
1239  av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
1240  } else {
1241  memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
1242  asf_st->palette_changed = 0;
1243  }
1244  }
1245  av_log(asf, AV_LOG_TRACE, "new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
1246  asf->stream_index, asf->packet_key_frame,
1247  asf_st->pkt.flags & AV_PKT_FLAG_KEY,
1248  s->streams[asf->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO,
1249  asf_st->packet_obj_size);
1250  if (s->streams[asf->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
1251  asf->packet_key_frame = 1;
1252  if (asf->packet_key_frame)
1253  asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
1254  }
1255 
1256  /* read data */
1257  av_log(asf, AV_LOG_TRACE, "READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n",
1258  s->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
1259  asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
1260  asf->packet_size_left -= asf->packet_frag_size;
1261  if (asf->packet_size_left < 0)
1262  continue;
1263 
1264  if (asf->packet_frag_offset >= asf_st->pkt.size ||
1265  asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset) {
1267  "packet fragment position invalid %u,%u not in %u\n",
1269  asf_st->pkt.size);
1270  continue;
1271  }
1272 
1273  if (asf->packet_frag_offset != asf_st->frag_offset && !asf_st->pkt_clean) {
1274  memset(asf_st->pkt.data + asf_st->frag_offset, 0, asf_st->pkt.size - asf_st->frag_offset);
1275  asf_st->pkt_clean = 1;
1276  }
1277 
1278  ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
1279  asf->packet_frag_size);
1280  if (ret != asf->packet_frag_size) {
1281  if (ret < 0 || asf->packet_frag_offset + ret == 0)
1282  return ret < 0 ? ret : AVERROR_EOF;
1283 
1284  if (asf_st->ds_span > 1) {
1285  // scrambling, we can either drop it completely or fill the remainder
1286  // TODO: should we fill the whole packet instead of just the current
1287  // fragment?
1288  memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
1289  asf->packet_frag_size - ret);
1290  ret = asf->packet_frag_size;
1291  } else {
1292  // no scrambling, so we can return partial packets
1293  av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
1294  }
1295  }
1296  if (s->key && s->keylen == 20)
1297  ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
1298  ret);
1299  asf_st->frag_offset += ret;
1300  /* test if whole packet is read */
1301  if (asf_st->frag_offset == asf_st->pkt.size) {
1302  // workaround for macroshit radio DVR-MS files
1303  if (s->streams[asf->stream_index]->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
1304  asf_st->pkt.size > 100) {
1305  int i;
1306  for (i = 0; i < asf_st->pkt.size && !asf_st->pkt.data[i]; i++)
1307  ;
1308  if (i == asf_st->pkt.size) {
1309  av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
1310  asf_st->frag_offset = 0;
1311  av_packet_unref(&asf_st->pkt);
1312  continue;
1313  }
1314  }
1315 
1316  /* return packet */
1317  if (asf_st->ds_span > 1) {
1318  if (asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span) {
1320  "pkt.size != ds_packet_size * ds_span (%d %d %d)\n",
1321  asf_st->pkt.size, asf_st->ds_packet_size,
1322  asf_st->ds_span);
1323  } else {
1324  /* packet descrambling */
1325  AVBufferRef *buf = av_buffer_alloc(asf_st->pkt.size +
1327  if (buf) {
1328  uint8_t *newdata = buf->data;
1329  int offset = 0;
1330  memset(newdata + asf_st->pkt.size, 0,
1332  while (offset < asf_st->pkt.size) {
1333  int off = offset / asf_st->ds_chunk_size;
1334  int row = off / asf_st->ds_span;
1335  int col = off % asf_st->ds_span;
1336  int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
1337  assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
1338  assert(idx + 1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
1339  memcpy(newdata + offset,
1340  asf_st->pkt.data + idx * asf_st->ds_chunk_size,
1341  asf_st->ds_chunk_size);
1342  offset += asf_st->ds_chunk_size;
1343  }
1344  av_buffer_unref(&asf_st->pkt.buf);
1345  asf_st->pkt.buf = buf;
1346  asf_st->pkt.data = buf->data;
1347  }
1348  }
1349  }
1350  asf_st->frag_offset = 0;
1351  *pkt = asf_st->pkt;
1352  asf_st->pkt.buf = 0;
1353  asf_st->pkt.size = 0;
1354  asf_st->pkt.data = 0;
1355  asf_st->pkt.side_data_elems = 0;
1356  asf_st->pkt.side_data = NULL;
1357  break; // packet completed
1358  }
1359  }
1360  return 0;
1361 }
1362 
1364 {
1365  ASFContext *asf = s->priv_data;
1366 
1367  for (;;) {
1368  int ret;
1369 
1370  /* parse cached packets, if any */
1371  if ((ret = asf_parse_packet(s, s->pb, pkt)) <= 0)
1372  return ret;
1373  if ((ret = asf_get_packet(s, s->pb)) < 0)
1374  assert(asf->packet_size_left < FRAME_HEADER_SIZE ||
1375  asf->packet_segments < 1);
1376  asf->packet_time_start = 0;
1377  }
1378 }
1379 
1380 // Added to support seeking after packets have been read
1381 // If information is not reset, read_packet fails due to
1382 // leftover information from previous reads
1384 {
1385  ASFContext *asf = s->priv_data;
1386  ASFStream *asf_st;
1387  int i;
1388 
1389  asf->packet_size_left = 0;
1390  asf->packet_flags = 0;
1391  asf->packet_property = 0;
1392  asf->packet_timestamp = 0;
1393  asf->packet_segsizetype = 0;
1394  asf->packet_segments = 0;
1395  asf->packet_seq = 0;
1396  asf->packet_replic_size = 0;
1397  asf->packet_key_frame = 0;
1398  asf->packet_padsize = 0;
1399  asf->packet_frag_offset = 0;
1400  asf->packet_frag_size = 0;
1401  asf->packet_frag_timestamp = 0;
1402  asf->packet_multi_size = 0;
1403  asf->packet_time_delta = 0;
1404  asf->packet_time_start = 0;
1405 
1406  for (i = 0; i < 128; i++) {
1407  asf_st = &asf->streams[i];
1408  av_packet_unref(&asf_st->pkt);
1409  asf_st->packet_obj_size = 0;
1410  asf_st->frag_offset = 0;
1411  asf_st->seq = 0;
1412  }
1413  asf->asf_st = NULL;
1414 }
1415 
1417 {
1418  ASFContext *asf = s->priv_data;
1419  int i;
1420 
1421  for (i = 0; i < 128; i++) {
1422  int j = asf->asfid2avid[i];
1423  ASFStream *asf_st = &asf->streams[i];
1424  if (j < 0 || s->streams[j]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1425  continue;
1426 
1427  asf_st->skip_to_key = 1;
1428  }
1429 }
1430 
1432 {
1434 
1435  return 0;
1436 }
1437 
1438 static int64_t asf_read_pts(AVFormatContext *s, int stream_index,
1439  int64_t *ppos, int64_t pos_limit)
1440 {
1441  FFFormatContext *const si = ffformatcontext(s);
1442  ASFContext *asf = s->priv_data;
1443  AVPacket pkt1, *pkt = &pkt1;
1444  ASFStream *asf_st;
1445  int64_t pts;
1446  int64_t pos = *ppos;
1447  int i;
1448  int64_t start_pos[ASF_MAX_STREAMS];
1449 
1450  for (i = 0; i < s->nb_streams; i++)
1451  start_pos[i] = pos;
1452 
1453  if (s->packet_size > 0)
1454  pos = (pos + s->packet_size - 1 - si->data_offset) /
1455  s->packet_size * s->packet_size +
1456  si->data_offset;
1457  *ppos = pos;
1458  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1459  return AV_NOPTS_VALUE;
1460 
1463  for (;;) {
1464  if (av_read_frame(s, pkt) < 0) {
1465  av_log(s, AV_LOG_INFO, "asf_read_pts failed\n");
1466  return AV_NOPTS_VALUE;
1467  }
1468 
1469  pts = pkt->dts;
1470 
1471  if (pkt->flags & AV_PKT_FLAG_KEY) {
1472  i = pkt->stream_index;
1473 
1474  asf_st = &asf->streams[s->streams[i]->id];
1475 
1476 // assert((asf_st->packet_pos - s->data_offset) % s->packet_size == 0);
1477  pos = asf_st->packet_pos;
1478  av_assert1(pkt->pos == asf_st->packet_pos);
1479 
1480  av_add_index_entry(s->streams[i], pos, pts, pkt->size,
1481  pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
1482  start_pos[i] = asf_st->packet_pos + 1;
1483 
1484  if (pkt->stream_index == stream_index) {
1486  break;
1487  }
1488  }
1490  }
1491 
1492  *ppos = pos;
1493  return pts;
1494 }
1495 
1496 static int asf_build_simple_index(AVFormatContext *s, int stream_index)
1497 {
1498  ff_asf_guid g;
1499  ASFContext *asf = s->priv_data;
1500  int64_t current_pos = avio_tell(s->pb);
1501  int64_t ret;
1502 
1503  if((ret = avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET)) < 0) {
1504  return ret;
1505  }
1506 
1507  if ((ret = ff_get_guid(s->pb, &g)) < 0)
1508  goto end;
1509 
1510  /* the data object can be followed by other top-level objects,
1511  * skip them until the simple index object is reached */
1513  int64_t gsize = avio_rl64(s->pb);
1514  if (gsize < 24 || avio_feof(s->pb)) {
1515  goto end;
1516  }
1517  avio_skip(s->pb, gsize - 24);
1518  if ((ret = ff_get_guid(s->pb, &g)) < 0)
1519  goto end;
1520  }
1521 
1522  {
1523  int64_t itime, last_pos = -1;
1524  int pct, ict;
1525  int i;
1526  int64_t av_unused gsize = avio_rl64(s->pb);
1527  if ((ret = ff_get_guid(s->pb, &g)) < 0)
1528  goto end;
1529  itime = avio_rl64(s->pb);
1530  pct = avio_rl32(s->pb);
1531  ict = avio_rl32(s->pb);
1533  "itime:0x%"PRIx64", pct:%d, ict:%d\n", itime, pct, ict);
1534 
1535  for (i = 0; i < ict; i++) {
1536  int pktnum = avio_rl32(s->pb);
1537  int pktct = avio_rl16(s->pb);
1538  int64_t pos = ffformatcontext(s)->data_offset + s->packet_size * (int64_t)pktnum;
1539  int64_t index_pts = FFMAX(av_rescale(itime, i, 10000) - asf->hdr.preroll, 0);
1540 
1541  if (avio_feof(s->pb)) {
1543  goto end;
1544  }
1545 
1546  if (pos != last_pos) {
1547  av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d pts: %"PRId64"\n",
1548  pktnum, pktct, index_pts);
1549  av_add_index_entry(s->streams[stream_index], pos, index_pts,
1550  s->packet_size, 0, AVINDEX_KEYFRAME);
1551  last_pos = pos;
1552  }
1553  }
1554  asf->index_read = ict > 1;
1555  }
1556 end:
1557 // if (avio_feof(s->pb)) {
1558 // ret = 0;
1559 // }
1560  avio_seek(s->pb, current_pos, SEEK_SET);
1561  return ret;
1562 }
1563 
1564 static int asf_read_seek(AVFormatContext *s, int stream_index,
1565  int64_t pts, int flags)
1566 {
1567  ASFContext *asf = s->priv_data;
1568  AVStream *st = s->streams[stream_index];
1569  FFStream *const sti = ffstream(st);
1570  int ret = 0;
1571 
1572  if (s->packet_size <= 0)
1573  return -1;
1574 
1575  /* Try using the protocol's read_seek if available */
1576  if (s->pb) {
1577  int64_t ret = avio_seek_time(s->pb, stream_index, pts, flags);
1578  if (ret >= 0)
1580  if (ret != AVERROR(ENOSYS))
1581  return ret;
1582  }
1583 
1584  /* explicitly handle the case of seeking to 0 */
1585  if (!pts) {
1587  avio_seek(s->pb, ffformatcontext(s)->data_offset, SEEK_SET);
1588  return 0;
1589  }
1590 
1591  if (!asf->index_read) {
1592  ret = asf_build_simple_index(s, stream_index);
1593  if (ret < 0)
1594  asf->index_read = -1;
1595  }
1596 
1597  if (asf->index_read > 0 && sti->index_entries) {
1599  if (index >= 0) {
1600  /* find the position */
1601  uint64_t pos = sti->index_entries[index].pos;
1602 
1603  /* do the seek */
1604  av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos);
1605  if(avio_seek(s->pb, pos, SEEK_SET) < 0)
1606  return -1;
1608  skip_to_key(s);
1609  return 0;
1610  }
1611  }
1612  /* no index or seeking by index failed */
1613  if (ff_seek_frame_binary(s, stream_index, pts, flags) < 0)
1614  return -1;
1616  skip_to_key(s);
1617  return 0;
1618 }
1619 
1621  .p.name = "asf",
1622  .p.long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1623  .p.flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH,
1624  .p.priv_class = &asf_class,
1625  .priv_data_size = sizeof(ASFContext),
1626  .read_probe = asf_probe,
1632 };
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: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: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 FFInputFormat.read_timestamp().
Definition: seek.c:288
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:32
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:194
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:95
skip_to_key
static void skip_to_key(AVFormatContext *s)
Definition: asfdec_f.c:1416
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:1132
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
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:473
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:522
AVOption
AVOption.
Definition: opt.h:346
asf_build_simple_index
static int asf_build_simple_index(AVFormatContext *s, int stream_index)
Definition: asfdec_f.c:1496
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: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:94
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:512
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:1539
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:485
ff_read_frame_flush
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: seek.c:720
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:322
asf_read_content_desc
static int asf_read_content_desc(AVFormatContext *s)
Definition: asfdec_f.c:533
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
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: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:881
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:102
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
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:853
finish
static void finish(void)
Definition: movenc.c:342
ASFContext::hdr
ASFMainHeader hdr
Definition: asfdec_f.c:90
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:423
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:1231
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: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: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:596
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:494
ff_asf_demuxer
const FFInputFormat ff_asf_demuxer
Definition: asfdec_f.c:1620
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:643
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:713
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: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
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:1431
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
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:1564
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: avpacket.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:127
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: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:856
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:40
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:107
asf_read_packet
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: asfdec_f.c:1363
ASF_BYTE_ARRAY
@ ASF_BYTE_ARRAY
Definition: asf.h:31
asf_read_marker
static int asf_read_marker(AVFormatContext *s)
Definition: asfdec_f.c:654
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: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:72
if
if(ret)
Definition: filter_design.txt:179
ASFMainHeader
Definition: asf.h:39
FFFormatContext
Definition: internal.h:70
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:392
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:505
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: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:96
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
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: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:80
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
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:73
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:442
options
static const AVOption options[]
Definition: asfdec_f.c:120
av_sat_sub64
#define av_sat_sub64
Definition: common.h:143
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:729
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:523
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:106
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:133
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:145
FFStream
Definition: internal.h:199
ASFContext::packet_time_delta
int packet_time_delta
Definition: asfdec_f.c:106
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:329
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:821
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:35
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:164
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:602
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:528
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:1060
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:552
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
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: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
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:1438
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:1003
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:254
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: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:103
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:230
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:86
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:413
avformat.h
asf_read_metadata
static int asf_read_metadata(AVFormatContext *s)
Definition: asfdec_f.c:606
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:533
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: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:611
ASFStream::num
int num
Definition: asfdec_f.c:48
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
asf_reset_header
static void asf_reset_header(AVFormatContext *s)
Definition: asfdec_f.c:1383
AVPacket::stream_index
int stream_index
Definition: packet.h:524
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:317
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:255
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:273
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: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:269
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:499
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
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:542
ff_asf_metadata_library_header
const ff_asf_guid ff_asf_metadata_library_header
Definition: asf_tags.c:106
FFInputFormat
Definition: demux.h:31
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:737
d
d
Definition: ffmpeg_filter.c:425
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: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:279
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:586
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:694
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:534
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:243
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:345