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