FFmpeg
asfdec_o.c
Go to the documentation of this file.
1 /*
2  * Microsoft Advanced Streaming Format demuxer
3  * Copyright (c) 2014 Alexandra Hájková
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 "libavutil/attributes.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/bswap.h"
25 #include "libavutil/common.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/mathematics.h"
29 #include "libavutil/opt.h"
31 
32 #include "avformat.h"
33 #include "avio_internal.h"
34 #include "avlanguage.h"
35 #include "id3v2.h"
36 #include "internal.h"
37 #include "riff.h"
38 #include "asf.h"
39 #include "asfcrypt.h"
40 
41 #define ASF_BOOL 0x2
42 #define ASF_WORD 0x5
43 #define ASF_GUID 0x6
44 #define ASF_DWORD 0x3
45 #define ASF_QWORD 0x4
46 #define ASF_UNICODE 0x0
47 #define ASF_FLAG_BROADCAST 0x1
48 #define ASF_BYTE_ARRAY 0x1
49 #define ASF_TYPE_AUDIO 0x2
50 #define ASF_TYPE_VIDEO 0x1
51 #define ASF_STREAM_NUM 0x7F
52 #define ASF_MAX_STREAMS 128
53 #define BMP_HEADER_SIZE 40
54 #define ASF_NUM_OF_PAYLOADS 0x3F
55 #define ASF_ERROR_CORRECTION_LENGTH_TYPE 0x60
56 #define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
57 
58 typedef struct GUIDParseTable {
59  const char *name;
64 
65 typedef struct ASFPacket {
67  int64_t dts;
68  uint32_t frame_num; // ASF payloads with the same number are parts of the same frame
69  int flags;
70  int data_size;
71  int duration;
72  int size_left;
74 } ASFPacket;
75 
76 typedef struct ASFStream {
77  uint8_t stream_index; // from packet header
78  int index; // stream index in AVFormatContext, set in asf_read_stream_properties
79  int type;
80  int indexed; // added index entries from the Simple Index Object or not
81  int8_t span; // for deinterleaving
82  uint16_t virtual_pkt_len;
84  int16_t lang_idx;
86 } ASFStream;
87 
88 typedef struct ASFStreamData{
89  char langs[32];
90  AVDictionary *asf_met; // for storing per-stream metadata
93 
94 typedef struct ASFContext {
96  int is_simple_index; // is simple index present or not 1/0
97  int is_header;
98 
99  uint64_t preroll;
100  uint64_t nb_packets; // ASF packets
101  uint32_t packet_size;
102  int64_t send_time;
103  int duration;
104 
105  uint32_t b_flags; // flags with broadcast flag
106  uint32_t prop_flags; // file properties object flags
107 
108  uint64_t data_size; // data object size
109  uint64_t unknown_size; // size of the unknown object
110 
111  int64_t offset; // offset of the current object
112 
113  int64_t data_offset;
114  int64_t first_packet_offset; // packet offset
115  int64_t unknown_offset; // for top level header objects or subobjects without specified behavior
116 
117  // ASF file must not contain more than 128 streams according to the specification
118  ASFStream *asf_st[ASF_MAX_STREAMS];
121 
122  int stream_index; // from packet header, for the subpayload case
123 
124  // packet parameters
125  uint64_t sub_header_offset; // offset of subpayload header
126  int64_t sub_dts;
127  uint8_t dts_delta; // for subpayloads
128  uint32_t packet_size_internal; // packet size stored inside ASFPacket, can be 0
129  int64_t packet_offset; // offset of the current packet inside Data Object
130  uint32_t pad_len; // padding after payload
131  uint32_t rep_data_len;
132 
133  // packet state
134  uint64_t sub_left; // subpayloads left or not
135  unsigned int nb_sub; // number of subpayloads read so far from the current ASF packet
136  uint16_t mult_sub_len; // total length of subpayloads array inside multiple payload
137  uint64_t nb_mult_left; // multiple payloads left
139  enum {
143  READ_MULTI_SUB
144  } state;
145 } ASFContext;
146 
147 static int detect_unknown_subobject(AVFormatContext *s, int64_t offset, int64_t size);
149 
150 static int asf_probe(const AVProbeData *pd)
151 {
152  /* check file header */
153  if (!ff_guidcmp(pd->buf, &ff_asf_header))
154  return AVPROBE_SCORE_MAX/2;
155  else
156  return 0;
157 }
158 
160 {
161  FFSWAP(unsigned char, guid[0], guid[3]);
162  FFSWAP(unsigned char, guid[1], guid[2]);
163  FFSWAP(unsigned char, guid[4], guid[5]);
164  FFSWAP(unsigned char, guid[6], guid[7]);
165 }
166 
167 static void align_position(AVIOContext *pb, int64_t offset, uint64_t size)
168 {
169  if (size < INT64_MAX - offset && avio_tell(pb) != offset + size)
170  avio_seek(pb, offset + size, SEEK_SET);
171 }
172 
174 {
175  ASFContext *asf = s->priv_data;
176  AVIOContext *pb = s->pb;
177  uint64_t size = avio_rl64(pb);
178  int ret;
179 
180  if (size > INT64_MAX)
181  return AVERROR_INVALIDDATA;
182 
183  if (asf->is_header)
184  asf->unknown_size = size;
185  asf->is_header = 0;
186  if (!g->is_subobject) {
187  if (!(ret = strcmp(g->name, "Header Extension")))
188  avio_skip(pb, 22); // skip reserved fields and Data Size
189  if ((ret = detect_unknown_subobject(s, asf->unknown_offset,
190  asf->unknown_size)) < 0)
191  return ret;
192  } else {
193  if (size < 24) {
194  av_log(s, AV_LOG_ERROR, "Too small size %"PRIu64" (< 24).\n", size);
195  return AVERROR_INVALIDDATA;
196  }
197  avio_skip(pb, size - 24);
198  }
199 
200  return 0;
201 }
202 
203 static int get_asf_string(AVIOContext *pb, int maxlen, char *buf, int buflen)
204 {
205  char *q = buf;
206  int ret = 0;
207  if (buflen <= 0)
208  return AVERROR(EINVAL);
209  while (ret + 1 < maxlen) {
210  uint8_t tmp;
211  uint32_t ch;
212  GET_UTF16(ch, (ret += 2) <= maxlen ? avio_rl16(pb) : 0, break;);
213  PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)
214  }
215  *q = 0;
216 
217  return ret;
218 }
219 
221 {
222  ASFContext *asf = s->priv_data;
223  AVIOContext *pb = s->pb;
224  uint64_t size = avio_rl64(pb);
225  int i, nb_markers, ret;
226  size_t len;
227  char name[1024];
228 
229  avio_skip(pb, 8);
230  avio_skip(pb, 8); // skip reserved GUID
231  nb_markers = avio_rl32(pb);
232  avio_skip(pb, 2); // skip reserved field
233  len = avio_rl16(pb);
234  for (i = 0; i < len; i++)
235  avio_skip(pb, 1);
236 
237  for (i = 0; i < nb_markers; i++) {
238  int64_t pts;
239 
240  avio_skip(pb, 8);
241  pts = avio_rl64(pb);
242  pts -= asf->preroll * 10000;
243  avio_skip(pb, 2); // entry length
244  avio_skip(pb, 4); // send time
245  avio_skip(pb, 4); // flags
246  len = avio_rl32(pb);
247 
248  if ((ret = avio_get_str16le(pb, len, name,
249  sizeof(name))) < len)
250  avio_skip(pb, len - ret);
251  avpriv_new_chapter(s, i, (AVRational) { 1, 10000000 }, pts,
253  }
254  align_position(pb, asf->offset, size);
255 
256  return 0;
257 }
258 
259 static int asf_read_metadata(AVFormatContext *s, const char *title, uint16_t len,
260  unsigned char *ch, uint16_t buflen)
261 {
262  AVIOContext *pb = s->pb;
263 
264  avio_get_str16le(pb, len, ch, buflen);
265  if (ch[0]) {
266  if (av_dict_set(&s->metadata, title, ch, 0) < 0)
267  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
268  }
269 
270  return 0;
271 }
272 
274  uint16_t val_len, int type, AVDictionary **met)
275 {
276  int ret;
277  uint8_t *value;
278  uint16_t buflen = 2 * val_len + 1;
279  AVIOContext *pb = s->pb;
280 
281  value = av_malloc(buflen);
282  if (!value)
283  return AVERROR(ENOMEM);
284  if (type == ASF_UNICODE) {
285  // get_asf_string reads UTF-16 and converts it to UTF-8 which needs longer buffer
286  if ((ret = get_asf_string(pb, val_len, value, buflen)) < 0)
287  goto failed;
288  if (av_dict_set(met, name, value, 0) < 0)
289  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
290  } else {
291  char buf[256];
292  if (val_len > sizeof(buf)) {
293  ret = AVERROR_INVALIDDATA;
294  goto failed;
295  }
296  if ((ret = avio_read(pb, value, val_len)) < 0)
297  goto failed;
298  if (ret < 2 * val_len)
299  value[ret] = '\0';
300  else
301  value[2 * val_len - 1] = '\0';
302  snprintf(buf, sizeof(buf), "%s", value);
303  if (av_dict_set(met, name, buf, 0) < 0)
304  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
305  }
306  av_freep(&value);
307 
308  return 0;
309 
310 failed:
311  av_freep(&value);
312  return ret;
313 }
314 static int asf_read_generic_value(AVIOContext *pb, int type, uint64_t *value)
315 {
316 
317  switch (type) {
318  case ASF_BOOL:
319  *value = avio_rl16(pb);
320  break;
321  case ASF_DWORD:
322  *value = avio_rl32(pb);
323  break;
324  case ASF_QWORD:
325  *value = avio_rl64(pb);
326  break;
327  case ASF_WORD:
328  *value = avio_rl16(pb);
329  break;
330  default:
331  return AVERROR_INVALIDDATA;
332  }
333 
334  return 0;
335 }
336 
338  int type, AVDictionary **met)
339 {
340  AVIOContext *pb = s->pb;
341  uint64_t value;
342  char buf[32];
343  int ret;
344 
345  ret = asf_read_generic_value(pb, type, &value);
346  if (ret < 0)
347  return ret;
348 
349  snprintf(buf, sizeof(buf), "%"PRIu64, value);
350  if (av_dict_set(met, name, buf, 0) < 0)
351  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
352 
353  return 0;
354 }
355 
356 /* MSDN claims that this should be "compatible with the ID3 frame, APIC",
357  * but in reality this is only loosely similar */
359 {
360  AVPacket pkt = { 0 };
361  const CodecMime *mime = ff_id3v2_mime_tags;
362  enum AVCodecID id = AV_CODEC_ID_NONE;
363  char mimetype[64];
364  uint8_t *desc = NULL;
365  AVStream *st = NULL;
366  int ret, type, picsize, desc_len;
367 
368  /* type + picsize + mime + desc */
369  if (len < 1 + 4 + 2 + 2) {
370  av_log(s, AV_LOG_ERROR, "Invalid attached picture size: %d.\n", len);
371  return AVERROR_INVALIDDATA;
372  }
373 
374  /* picture type */
375  type = avio_r8(s->pb);
376  len--;
377  if (type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types) || type < 0) {
378  av_log(s, AV_LOG_WARNING, "Unknown attached picture type: %d.\n", type);
379  type = 0;
380  }
381 
382  /* picture data size */
383  picsize = avio_rl32(s->pb);
384  len -= 4;
385 
386  /* picture MIME type */
387  len -= avio_get_str16le(s->pb, len, mimetype, sizeof(mimetype));
388  while (mime->id != AV_CODEC_ID_NONE) {
389  if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
390  id = mime->id;
391  break;
392  }
393  mime++;
394  }
395  if (id == AV_CODEC_ID_NONE) {
396  av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
397  mimetype);
398  return 0;
399  }
400 
401  if (picsize >= len) {
402  av_log(s, AV_LOG_ERROR, "Invalid attached picture data size: %d >= %d.\n",
403  picsize, len);
404  return AVERROR_INVALIDDATA;
405  }
406 
407  /* picture description */
408  desc_len = (len - picsize) * 2 + 1;
409  desc = av_malloc(desc_len);
410  if (!desc)
411  return AVERROR(ENOMEM);
412  len -= avio_get_str16le(s->pb, len - picsize, desc, desc_len);
413 
414  ret = av_get_packet(s->pb, &pkt, picsize);
415  if (ret < 0)
416  goto fail;
417 
418  st = avformat_new_stream(s, NULL);
419  if (!st) {
420  ret = AVERROR(ENOMEM);
421  goto fail;
422  }
423 
426  st->codecpar->codec_id = id;
427  st->attached_pic = pkt;
428  st->attached_pic.stream_index = st->index;
430 
431  if (*desc) {
432  if (av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL) < 0)
433  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
434  } else
435  av_freep(&desc);
436 
437  if (av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0) < 0)
438  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
439 
440  return 0;
441 
442 fail:
443  av_freep(&desc);
444  av_packet_unref(&pkt);
445  return ret;
446 }
447 
448 static void get_id3_tag(AVFormatContext *s, int len)
449 {
450  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
451 
452  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, len);
453  if (id3v2_extra_meta) {
454  ff_id3v2_parse_apic(s, id3v2_extra_meta);
455  ff_id3v2_parse_chapters(s, id3v2_extra_meta);
456  }
457  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
458 }
459 
460 static int process_metadata(AVFormatContext *s, const uint8_t *name, uint16_t name_len,
461  uint16_t val_len, uint16_t type, AVDictionary **met)
462 {
463  int ret;
465 
466  if (val_len) {
467  switch (type) {
468  case ASF_UNICODE:
469  asf_read_value(s, name, val_len, type, met);
470  break;
471  case ASF_BYTE_ARRAY:
472  if (!strcmp(name, "WM/Picture")) // handle cover art
473  asf_read_picture(s, val_len);
474  else if (!strcmp(name, "ID3")) // handle ID3 tag
475  get_id3_tag(s, val_len);
476  else
477  asf_read_value(s, name, val_len, type, met);
478  break;
479  case ASF_GUID:
480  ff_get_guid(s->pb, &guid);
481  break;
482  default:
483  if ((ret = asf_set_metadata(s, name, type, met)) < 0)
484  return ret;
485  break;
486  }
487  }
488 
489  return 0;
490 }
491 
493 {
494  ASFContext *asf = s->priv_data;
495  AVIOContext *pb = s->pb;
496  uint64_t size = avio_rl64(pb);
497  uint16_t nb_desc = avio_rl16(pb);
498  int i, ret;
499 
500  for (i = 0; i < nb_desc; i++) {
501  uint16_t name_len, type, val_len;
502  uint8_t *name = NULL;
503 
504  name_len = avio_rl16(pb);
505  if (!name_len)
506  return AVERROR_INVALIDDATA;
507  name = av_malloc(name_len);
508  if (!name)
509  return AVERROR(ENOMEM);
510  avio_get_str16le(pb, name_len, name,
511  name_len);
512  type = avio_rl16(pb);
513  // BOOL values are 16 bits long in the Metadata Object
514  // but 32 bits long in the Extended Content Description Object
515  if (type == ASF_BOOL)
516  type = ASF_DWORD;
517  val_len = avio_rl16(pb);
518 
519  ret = process_metadata(s, name, name_len, val_len, type, &s->metadata);
520  av_freep(&name);
521  if (ret < 0)
522  return ret;
523  }
524 
525  align_position(pb, asf->offset, size);
526  return 0;
527 }
528 
529 static AVStream *find_stream(AVFormatContext *s, uint16_t st_num)
530 {
531  AVStream *st = NULL;
532  ASFContext *asf = s->priv_data;
533  int i;
534 
535  for (i = 0; i < asf->nb_streams; i++) {
536  if (asf->asf_st[i]->stream_index == st_num) {
537  st = s->streams[asf->asf_st[i]->index];
538  break;
539  }
540  }
541 
542  return st;
543 }
544 
546 {
547  ASFContext *asf = s->priv_data;
548  AVIOContext *pb = s->pb;
549  uint64_t value = 0;
550  int ret;
551 
552  ret = asf_read_generic_value(pb, type, &value);
553  if (ret < 0)
554  return ret;
555 
556  if (st_num < ASF_MAX_STREAMS) {
557  if (!strcmp(name, "AspectRatioX"))
558  asf->asf_sd[st_num].aspect_ratio.num = value;
559  else
560  asf->asf_sd[st_num].aspect_ratio.den = value;
561  }
562  return 0;
563 }
564 
566 {
567  ASFContext *asf = s->priv_data;
568  AVIOContext *pb = s->pb;
569  uint64_t size = avio_rl64(pb);
570  uint16_t nb_recs = avio_rl16(pb); // number of records in the Description Records list
571  int i, ret;
572 
573  for (i = 0; i < nb_recs; i++) {
574  uint16_t name_len, buflen, type, val_len, st_num;
575  uint8_t *name = NULL;
576 
577  avio_skip(pb, 2); // skip reserved field
578  st_num = avio_rl16(pb);
579  name_len = avio_rl16(pb);
580  buflen = 2 * name_len + 1;
581  if (!name_len)
582  break;
583  type = avio_rl16(pb);
584  val_len = avio_rl32(pb);
585  name = av_malloc(buflen);
586  if (!name)
587  return AVERROR(ENOMEM);
588  avio_get_str16le(pb, name_len, name,
589  buflen);
590  if (!strcmp(name, "AspectRatioX") || !strcmp(name, "AspectRatioY")) {
591  ret = asf_store_aspect_ratio(s, st_num, name, type);
592  if (ret < 0) {
593  av_freep(&name);
594  break;
595  }
596  } else {
597  if (st_num < ASF_MAX_STREAMS) {
598  if ((ret = process_metadata(s, name, name_len, val_len, type,
599  st_num ? &asf->asf_sd[st_num].asf_met
600  : &s->metadata)) < 0) {
601  av_freep(&name);
602  break;
603  }
604  }
605  }
606  av_freep(&name);
607  }
608 
609  align_position(pb, asf->offset, size);
610  return 0;
611 }
612 
614 {
615  ASFContext *asf = s->priv_data;
616  AVIOContext *pb = s->pb;
617  int i;
618  static const char *const titles[] =
619  { "Title", "Author", "Copyright", "Description", "Rate" };
620  uint16_t len[5], buflen[5] = { 0 };
621  uint8_t *ch;
622  uint64_t size = avio_rl64(pb);
623 
624  for (i = 0; i < 5; i++) {
625  len[i] = avio_rl16(pb);
626  // utf8 string should be <= 2 * utf16 string, extra byte for the terminator
627  buflen[i] = 2 * len[i] + 1;
628  }
629 
630  for (i = 0; i < 5; i++) {
631  ch = av_malloc(buflen[i]);
632  if (!ch)
633  return(AVERROR(ENOMEM));
634  asf_read_metadata(s, titles[i], len[i], ch, buflen[i]);
635  av_freep(&ch);
636  }
637  align_position(pb, asf->offset, size);
638 
639  return 0;
640 }
641 
643 {
644  ASFContext *asf = s->priv_data;
645  AVIOContext *pb = s->pb;
646  time_t creation_time;
647 
648  avio_rl64(pb); // read object size
649  avio_skip(pb, 16); // skip File ID
650  avio_skip(pb, 8); // skip File size
651  creation_time = avio_rl64(pb);
652  if (!(asf->b_flags & ASF_FLAG_BROADCAST)) {
653  struct tm tmbuf;
654  struct tm *tm;
655  char buf[64];
656 
657  // creation date is in 100 ns units from 1 Jan 1601, conversion to s
658  creation_time /= 10000000;
659  // there are 11644473600 seconds between 1 Jan 1601 and 1 Jan 1970
660  creation_time -= 11644473600;
661  tm = gmtime_r(&creation_time, &tmbuf);
662  if (tm) {
663  if (!strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm))
664  buf[0] = '\0';
665  } else
666  buf[0] = '\0';
667  if (buf[0]) {
668  if (av_dict_set(&s->metadata, "creation_time", buf, 0) < 0)
669  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
670  }
671  }
672  asf->nb_packets = avio_rl64(pb);
673  asf->duration = avio_rl64(pb) / 10000; // stream duration
674  avio_skip(pb, 8); // skip send duration
675  asf->preroll = avio_rl64(pb);
676  asf->duration -= asf->preroll;
677  asf->b_flags = avio_rl32(pb);
678  avio_skip(pb, 4); // skip minimal packet size
679  asf->packet_size = avio_rl32(pb);
680  avio_skip(pb, 4); // skip max_bitrate
681 
682  return 0;
683 }
684 
686 {
687  uint16_t size_asf; // ASF-specific Format Data size
688  uint32_t size_bmp; // BMP_HEADER-specific Format Data size
689  unsigned int tag;
690 
691  st->codecpar->width = avio_rl32(pb);
692  st->codecpar->height = avio_rl32(pb);
693  avio_skip(pb, 1); // skip reserved flags
694  size_asf = avio_rl16(pb);
695  tag = ff_get_bmp_header(pb, st, &size_bmp);
696  st->codecpar->codec_tag = tag;
698  size_bmp = FFMAX(size_asf, size_bmp);
699 
700  if (size_bmp > BMP_HEADER_SIZE &&
701  size_bmp < INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
702  int ret;
703  st->codecpar->extradata_size = size_bmp - BMP_HEADER_SIZE;
706  st->codecpar->extradata_size = 0;
707  return AVERROR(ENOMEM);
708  }
709  memset(st->codecpar->extradata + st->codecpar->extradata_size , 0,
711  if ((ret = avio_read(pb, st->codecpar->extradata,
712  st->codecpar->extradata_size)) < 0)
713  return ret;
714  }
715  return 0;
716 }
717 
719 {
720  ASFContext *asf = s->priv_data;
721  AVIOContext *pb = s->pb;
722  uint64_t size;
723  uint32_t err_data_len, ts_data_len; // type specific data length
724  uint16_t flags;
725  ff_asf_guid stream_type;
726  enum AVMediaType type;
727  int i, ret;
728  uint8_t stream_index;
729  AVStream *st;
730  ASFStream *asf_st;
731 
732  // ASF file must not contain more than 128 streams according to the specification
733  if (asf->nb_streams >= ASF_MAX_STREAMS)
734  return AVERROR_INVALIDDATA;
735 
736  size = avio_rl64(pb);
737  ff_get_guid(pb, &stream_type);
738  if (!ff_guidcmp(&stream_type, &ff_asf_audio_stream))
739  type = AVMEDIA_TYPE_AUDIO;
740  else if (!ff_guidcmp(&stream_type, &ff_asf_video_stream))
741  type = AVMEDIA_TYPE_VIDEO;
742  else if (!ff_guidcmp(&stream_type, &ff_asf_jfif_media))
743  type = AVMEDIA_TYPE_VIDEO;
744  else if (!ff_guidcmp(&stream_type, &ff_asf_command_stream))
745  type = AVMEDIA_TYPE_DATA;
746  else if (!ff_guidcmp(&stream_type,
748  type = AVMEDIA_TYPE_UNKNOWN;
749  else
750  return AVERROR_INVALIDDATA;
751 
752  ff_get_guid(pb, &stream_type); // error correction type
753  avio_skip(pb, 8); // skip the time offset
754  ts_data_len = avio_rl32(pb);
755  err_data_len = avio_rl32(pb);
756  flags = avio_rl16(pb); // bit 15 - Encrypted Content
757 
758  stream_index = flags & ASF_STREAM_NUM;
759  for (i = 0; i < asf->nb_streams; i++)
760  if (stream_index == asf->asf_st[i]->stream_index) {
762  "Duplicate stream found, this stream will be ignored.\n");
763  align_position(pb, asf->offset, size);
764  return 0;
765  }
766 
767  st = avformat_new_stream(s, NULL);
768  if (!st)
769  return AVERROR(ENOMEM);
770  avpriv_set_pts_info(st, 32, 1, 1000); // pts should be dword, in milliseconds
771  st->codecpar->codec_type = type;
772  asf->asf_st[asf->nb_streams] = av_mallocz(sizeof(*asf_st));
773  if (!asf->asf_st[asf->nb_streams])
774  return AVERROR(ENOMEM);
775  asf_st = asf->asf_st[asf->nb_streams];
776  asf->nb_streams++;
777  asf_st->stream_index = stream_index;
778  asf_st->index = st->index;
779  asf_st->indexed = 0;
780  st->id = flags & ASF_STREAM_NUM;
781  av_init_packet(&asf_st->pkt.avpkt);
782  asf_st->pkt.data_size = 0;
783  avio_skip(pb, 4); // skip reserved field
784 
785  switch (type) {
786  case AVMEDIA_TYPE_AUDIO:
787  asf_st->type = AVMEDIA_TYPE_AUDIO;
788  if ((ret = ff_get_wav_header(s, pb, st->codecpar, ts_data_len, 0)) < 0)
789  return ret;
790  break;
791  case AVMEDIA_TYPE_VIDEO:
792  asf_st->type = AVMEDIA_TYPE_VIDEO;
793  if ((ret = parse_video_info(pb, st)) < 0)
794  return ret;
795  break;
796  default:
797  avio_skip(pb, ts_data_len);
798  break;
799  }
800 
801  if (err_data_len) {
802  if (type == AVMEDIA_TYPE_AUDIO) {
803  uint8_t span = avio_r8(pb);
804  if (span > 1) {
805  asf_st->span = span;
806  asf_st->virtual_pkt_len = avio_rl16(pb);
807  asf_st->virtual_chunk_len = avio_rl16(pb);
808  if (!asf_st->virtual_chunk_len || !asf_st->virtual_pkt_len)
809  return AVERROR_INVALIDDATA;
810  avio_skip(pb, err_data_len - 5);
811  } else
812  avio_skip(pb, err_data_len - 1);
813  } else
814  avio_skip(pb, err_data_len);
815  }
816 
817  align_position(pb, asf->offset, size);
818 
819  return 0;
820 }
821 
822 static void set_language(AVFormatContext *s, const char *rfc1766, AVDictionary **met)
823 {
824  // language abbr should contain at least 2 chars
825  if (rfc1766 && strlen(rfc1766) > 1) {
826  const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any
827  const char *iso6392 = ff_convert_lang_to(primary_tag,
829  if (iso6392)
830  if (av_dict_set(met, "language", iso6392, 0) < 0)
831  av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
832  }
833 }
834 
836 {
837  ASFContext *asf = s->priv_data;
838  AVIOContext *pb = s->pb;
839  AVStream *st = NULL;
841  uint16_t nb_st_name, nb_pay_exts, st_num, lang_idx;
842  int i, ret;
843  uint32_t bitrate;
844  uint64_t start_time, end_time, time_per_frame;
845  uint64_t size = avio_rl64(pb);
846 
847  start_time = avio_rl64(pb);
848  end_time = avio_rl64(pb);
849  bitrate = avio_rl32(pb);
850  avio_skip(pb, 28); // skip some unused values
851  st_num = avio_rl16(pb);
852  st_num &= ASF_STREAM_NUM;
853  lang_idx = avio_rl16(pb); // Stream Language ID Index
854  for (i = 0; i < asf->nb_streams; i++) {
855  if (st_num == asf->asf_st[i]->stream_index) {
856  st = s->streams[asf->asf_st[i]->index];
857  asf->asf_st[i]->lang_idx = lang_idx;
858  break;
859  }
860  }
861  time_per_frame = avio_rl64(pb); // average time per frame
862  if (st) {
863  st->start_time = start_time;
864  st->duration = end_time - start_time;
865  st->codecpar->bit_rate = bitrate;
866  st->avg_frame_rate.num = 10000000;
867  st->avg_frame_rate.den = time_per_frame;
868  }
869  nb_st_name = avio_rl16(pb);
870  nb_pay_exts = avio_rl16(pb);
871  for (i = 0; i < nb_st_name; i++) {
872  uint16_t len;
873 
874  avio_rl16(pb); // Language ID Index
875  len = avio_rl16(pb);
876  avio_skip(pb, len);
877  }
878 
879  for (i = 0; i < nb_pay_exts; i++) {
880  uint32_t len;
881  avio_skip(pb, 16); // Extension System ID
882  avio_skip(pb, 2); // Extension Data Size
883  len = avio_rl32(pb);
884  avio_skip(pb, len);
885  }
886 
887  if ((ret = ff_get_guid(pb, &guid)) < 0) {
888  align_position(pb, asf->offset, size);
889 
890  return 0;
891  }
892 
893  g = find_guid(guid);
894  if (g && !(strcmp(g->name, "Stream Properties"))) {
895  if ((ret = g->read_object(s, g)) < 0)
896  return ret;
897  }
898 
899  align_position(pb, asf->offset, size);
900  return 0;
901 }
902 
904 {
905  ASFContext *asf = s->priv_data;
906  AVIOContext *pb = s->pb;
907  int i, ret;
908  uint64_t size = avio_rl64(pb);
909  uint16_t nb_langs = avio_rl16(pb);
910 
911  if (nb_langs < ASF_MAX_STREAMS) {
912  for (i = 0; i < nb_langs; i++) {
913  size_t len;
914  len = avio_r8(pb);
915  if (!len)
916  len = 6;
917  if ((ret = get_asf_string(pb, len, asf->asf_sd[i].langs,
918  sizeof(asf->asf_sd[i].langs))) < 0) {
919  return ret;
920  }
921  }
922  }
923 
924  align_position(pb, asf->offset, size);
925  return 0;
926 }
927 
928 // returns data object offset when reading this object for the first time
930 {
931  ASFContext *asf = s->priv_data;
932  AVIOContext *pb = s->pb;
933  uint64_t size = asf->data_size = avio_rl64(pb);
934  int i;
935 
936  if (!asf->data_reached) {
937  asf->data_reached = 1;
938  asf->data_offset = asf->offset;
939  }
940 
941  for (i = 0; i < asf->nb_streams; i++) {
942  if (!(asf->b_flags & ASF_FLAG_BROADCAST))
943  s->streams[i]->duration = asf->duration;
944  }
945  asf->nb_mult_left = 0;
946  asf->sub_left = 0;
947  asf->state = PARSE_PACKET_HEADER;
948  asf->return_subpayload = 0;
949  asf->packet_size_internal = 0;
950  avio_skip(pb, 16); // skip File ID
951  size = avio_rl64(pb); // Total Data Packets
952  if (size != asf->nb_packets)
954  "Number of Packets from File Properties Object is not equal to Total"
955  "Datapackets value! num of packets %"PRIu64" total num %"PRIu64".\n",
956  size, asf->nb_packets);
957  avio_skip(pb, 2); // skip reserved field
958  asf->first_packet_offset = avio_tell(pb);
959  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(asf->b_flags & ASF_FLAG_BROADCAST))
960  align_position(pb, asf->offset, asf->data_size);
961 
962  return 0;
963 }
964 
966 {
967  ASFContext *asf = s->priv_data;
968  AVIOContext *pb = s->pb;
969  AVStream *st = NULL;
970  uint64_t interval; // index entry time interval in 100 ns units, usually it's 1s
971  uint32_t pkt_num, nb_entries;
972  int32_t prev_pkt_num = -1;
973  int i;
974  int64_t offset;
975  uint64_t size = avio_rl64(pb);
976 
977  // simple index objects should be ordered by stream number, this loop tries to find
978  // the first not indexed video stream
979  for (i = 0; i < asf->nb_streams; i++) {
980  if ((asf->asf_st[i]->type == AVMEDIA_TYPE_VIDEO) && !asf->asf_st[i]->indexed) {
981  asf->asf_st[i]->indexed = 1;
982  st = s->streams[asf->asf_st[i]->index];
983  break;
984  }
985  }
986  if (!st) {
987  avio_skip(pb, size - 24); // if there's no video stream, skip index object
988  return 0;
989  }
990  avio_skip(pb, 16); // skip File ID
991  interval = avio_rl64(pb);
992  avio_skip(pb, 4);
993  nb_entries = avio_rl32(pb);
994  for (i = 0; i < nb_entries; i++) {
995  pkt_num = avio_rl32(pb);
996  offset = avio_skip(pb, 2);
997  if (offset < 0) {
998  av_log(s, AV_LOG_ERROR, "Skipping failed in asf_read_simple_index.\n");
999  return offset;
1000  }
1001  if (prev_pkt_num != pkt_num) {
1003  pkt_num, av_rescale(interval, i, 10000),
1004  asf->packet_size, 0, AVINDEX_KEYFRAME);
1005  prev_pkt_num = pkt_num;
1006  }
1007  }
1008  asf->is_simple_index = 1;
1009  align_position(pb, asf->offset, size);
1010 
1011  return 0;
1012 }
1013 
1014 static const GUIDParseTable gdef[] = {
1015  { "Data", { 0x75, 0xB2, 0x26, 0x36, 0x66, 0x8E, 0x11, 0xCF, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }, asf_read_data, 1 },
1016  { "Simple Index", { 0x33, 0x00, 0x08, 0x90, 0xE5, 0xB1, 0x11, 0xCF, 0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB }, asf_read_simple_index, 1 },
1017  { "Content Description", { 0x75, 0xB2, 0x26, 0x33, 0x66 ,0x8E, 0x11, 0xCF, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }, asf_read_content_desc, 1 },
1018  { "Extended Content Description", { 0xD2, 0xD0, 0xA4, 0x40, 0xE3, 0x07, 0x11, 0xD2, 0x97, 0xF0, 0x00, 0xA0, 0xC9, 0x5e, 0xA8, 0x50 }, asf_read_ext_content, 1 },
1019  { "Stream Bitrate Properties", { 0x7B, 0xF8, 0x75, 0xCE, 0x46, 0x8D, 0x11, 0xD1, 0x8D, 0x82, 0x00, 0x60, 0x97, 0xC9, 0xA2, 0xB2 }, asf_read_unknown, 1 },
1020  { "File Properties", { 0x8C, 0xAB, 0xDC, 0xA1, 0xA9, 0x47, 0x11, 0xCF, 0x8E, 0xE4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_properties, 1 },
1021  { "Header Extension", { 0x5F, 0xBF, 0x03, 0xB5, 0xA9, 0x2E, 0x11, 0xCF, 0x8E, 0xE3, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_unknown, 0 },
1022  { "Stream Properties", { 0xB7, 0xDC, 0x07, 0x91, 0xA9, 0xB7, 0x11, 0xCF, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_stream_properties, 1 },
1023  { "Codec List", { 0x86, 0xD1, 0x52, 0x40, 0x31, 0x1D, 0x11, 0xD0, 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 }, asf_read_unknown, 1 },
1024  { "Marker", { 0xF4, 0x87, 0xCD, 0x01, 0xA9, 0x51, 0x11, 0xCF, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_marker, 1 },
1025  { "Script Command", { 0x1E, 0xFB, 0x1A, 0x30, 0x0B, 0x62, 0x11, 0xD0, 0xA3, 0x9B, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 }, asf_read_unknown, 1 },
1026  { "Language List", { 0x7C, 0x43, 0x46, 0xa9, 0xef, 0xe0, 0x4B, 0xFC, 0xB2, 0x29, 0x39, 0x3e, 0xde, 0x41, 0x5c, 0x85 }, asf_read_language_list, 1},
1027  { "Padding", { 0x18, 0x06, 0xD4, 0x74, 0xCA, 0xDF, 0x45, 0x09, 0xA4, 0xBA, 0x9A, 0xAB, 0xCB, 0x96, 0xAA, 0xE8 }, asf_read_unknown, 1 },
1028  { "DRMv1 Header", { 0x22, 0x11, 0xB3, 0xFB, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
1029  { "DRMv2 Header", { 0x29, 0x8A, 0xE6, 0x14, 0x26, 0x22, 0x4C, 0x17, 0xB9, 0x35, 0xDA, 0xE0, 0x7E, 0xE9, 0x28, 0x9c }, asf_read_unknown, 1 },
1030  { "Index", { 0xD6, 0xE2, 0x29, 0xD3, 0x35, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
1031  { "Media Object Index", { 0xFE, 0xB1, 0x03, 0xF8, 0x12, 0xAD, 0x4C, 0x64, 0x84, 0x0F, 0x2A, 0x1D, 0x2F, 0x7A, 0xD4, 0x8C }, asf_read_unknown, 1 },
1032  { "Timecode Index", { 0x3C, 0xB7, 0x3F, 0xD0, 0x0C, 0x4A, 0x48, 0x03, 0x95, 0x3D, 0xED, 0xF7, 0xB6, 0x22, 0x8F, 0x0C }, asf_read_unknown, 0 },
1033  { "Bitrate_Mutual_Exclusion", { 0xD6, 0xE2, 0x29, 0xDC, 0x35, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
1034  { "Error Correction", { 0x75, 0xB2, 0x26, 0x35, 0x66, 0x8E, 0x11, 0xCF, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }, asf_read_unknown, 1 },
1035  { "Content Branding", { 0x22, 0x11, 0xB3, 0xFA, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
1036  { "Content Encryption", { 0x22, 0x11, 0xB3, 0xFB, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
1037  { "Extended Content Encryption", { 0x29, 0x8A, 0xE6, 0x14, 0x26, 0x22, 0x4C, 0x17, 0xB9, 0x35, 0xDA, 0xE0, 0x7E, 0xE9, 0x28, 0x9C }, asf_read_unknown, 1 },
1038  { "Digital Signature", { 0x22, 0x11, 0xB3, 0xFC, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
1039  { "Extended Stream Properties", { 0x14, 0xE6, 0xA5, 0xCB, 0xC6, 0x72, 0x43, 0x32, 0x83, 0x99, 0xA9, 0x69, 0x52, 0x06, 0x5B, 0x5A }, asf_read_ext_stream_properties, 1 },
1040  { "Advanced Mutual Exclusion", { 0xA0, 0x86, 0x49, 0xCF, 0x47, 0x75, 0x46, 0x70, 0x8A, 0x16, 0x6E, 0x35, 0x35, 0x75, 0x66, 0xCD }, asf_read_unknown, 1 },
1041  { "Group Mutual Exclusion", { 0xD1, 0x46, 0x5A, 0x40, 0x5A, 0x79, 0x43, 0x38, 0xB7, 0x1B, 0xE3, 0x6B, 0x8F, 0xD6, 0xC2, 0x49 }, asf_read_unknown, 1},
1042  { "Stream Prioritization", { 0xD4, 0xFE, 0xD1, 0x5B, 0x88, 0xD3, 0x45, 0x4F, 0x81, 0xF0, 0xED, 0x5C, 0x45, 0x99, 0x9E, 0x24 }, asf_read_unknown, 1 },
1043  { "Bandwidth Sharing Object", { 0xA6, 0x96, 0x09, 0xE6, 0x51, 0x7B, 0x11, 0xD2, 0xB6, 0xAF, 0x00, 0xC0, 0x4F, 0xD9, 0x08, 0xE9 }, asf_read_unknown, 1 },
1044  { "Metadata", { 0xC5, 0xF8, 0xCB, 0xEA, 0x5B, 0xAF, 0x48, 0x77, 0x84, 0x67, 0xAA, 0x8C, 0x44, 0xFA, 0x4C, 0xCA }, asf_read_metadata_obj, 1 },
1045  { "Metadata Library", { 0x44, 0x23, 0x1C, 0x94, 0x94, 0x98, 0x49, 0xD1, 0xA1, 0x41, 0x1D, 0x13, 0x4E, 0x45, 0x70, 0x54 }, asf_read_metadata_obj, 1 },
1046  { "Audio Spread", { 0xBF, 0xC3, 0xCD, 0x50, 0x61, 0x8F, 0x11, 0xCF, 0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20 }, asf_read_unknown, 1 },
1047  { "Index Parameters", { 0xD6, 0xE2, 0x29, 0xDF, 0x35, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
1048  { "Content Encryption System Windows Media DRM Network Devices",
1049  { 0x7A, 0x07, 0x9B, 0xB6, 0xDA, 0XA4, 0x4e, 0x12, 0xA5, 0xCA, 0x91, 0xD3, 0x8D, 0xC1, 0x1A, 0x8D }, asf_read_unknown, 1 },
1050  { "Mutex Language", { 0xD6, 0xE2, 0x2A, 0x00, 0x25, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
1051  { "Mutex Bitrate", { 0xD6, 0xE2, 0x2A, 0x01, 0x25, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
1052  { "Mutex Unknown", { 0xD6, 0xE2, 0x2A, 0x02, 0x25, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
1053  { "Bandwidth Sharing Exclusive", { 0xAF, 0x60, 0x60, 0xAA, 0x51, 0x97, 0x11, 0xD2, 0xB6, 0xAF, 0x00, 0xC0, 0x4F, 0xD9, 0x08, 0xE9 }, asf_read_unknown, 1 },
1054  { "Bandwidth Sharing Partial", { 0xAF, 0x60, 0x60, 0xAB, 0x51, 0x97, 0x11, 0xD2, 0xB6, 0xAF, 0x00, 0xC0, 0x4F, 0xD9, 0x08, 0xE9 }, asf_read_unknown, 1 },
1055  { "Payload Extension System Timecode", { 0x39, 0x95, 0x95, 0xEC, 0x86, 0x67, 0x4E, 0x2D, 0x8F, 0xDB, 0x98, 0x81, 0x4C, 0xE7, 0x6C, 0x1E }, asf_read_unknown, 1 },
1056  { "Payload Extension System File Name", { 0xE1, 0x65, 0xEC, 0x0E, 0x19, 0xED, 0x45, 0xD7, 0xB4, 0xA7, 0x25, 0xCB, 0xD1, 0xE2, 0x8E, 0x9B }, asf_read_unknown, 1 },
1057  { "Payload Extension System Content Type", { 0xD5, 0x90, 0xDC, 0x20, 0x07, 0xBC, 0x43, 0x6C, 0x9C, 0xF7, 0xF3, 0xBB, 0xFB, 0xF1, 0xA4, 0xDC }, asf_read_unknown, 1 },
1058  { "Payload Extension System Pixel Aspect Ratio", { 0x1, 0x1E, 0xE5, 0x54, 0xF9, 0xEA, 0x4B, 0xC8, 0x82, 0x1A, 0x37, 0x6B, 0x74, 0xE4, 0xC4, 0xB8 }, asf_read_unknown, 1 },
1059  { "Payload Extension System Sample Duration", { 0xC6, 0xBD, 0x94, 0x50, 0x86, 0x7F, 0x49, 0x07, 0x83, 0xA3, 0xC7, 0x79, 0x21, 0xB7, 0x33, 0xAD }, asf_read_unknown, 1 },
1060  { "Payload Extension System Encryption Sample ID", { 0x66, 0x98, 0xB8, 0x4E, 0x0A, 0xFA, 0x43, 0x30, 0xAE, 0xB2, 0x1C, 0x0A, 0x98, 0xD7, 0xA4, 0x4D }, asf_read_unknown, 1 },
1061  { "Payload Extension System Degradable JPEG", { 0x00, 0xE1, 0xAF, 0x06, 0x7B, 0xEC, 0x11, 0xD1, 0xA5, 0x82, 0x00, 0xC0, 0x4F, 0xC2, 0x9C, 0xFB }, asf_read_unknown, 1 },
1062 };
1063 
1064 #define READ_LEN(flag, name, len) \
1065  do { \
1066  if ((flag) == name ## IS_BYTE) \
1067  len = avio_r8(pb); \
1068  else if ((flag) == name ## IS_WORD) \
1069  len = avio_rl16(pb); \
1070  else if ((flag) == name ## IS_DWORD) \
1071  len = avio_rl32(pb); \
1072  else \
1073  len = 0; \
1074  } while(0)
1075 
1076 static int asf_read_subpayload(AVFormatContext *s, AVPacket *pkt, int is_header)
1077 {
1078  ASFContext *asf = s->priv_data;
1079  AVIOContext *pb = s->pb;
1080  uint8_t sub_len;
1081  int ret, i;
1082 
1083  if (is_header) {
1084  asf->dts_delta = avio_r8(pb);
1085  if (asf->nb_mult_left) {
1086  asf->mult_sub_len = avio_rl16(pb); // total
1087  }
1088  asf->sub_header_offset = avio_tell(pb);
1089  asf->nb_sub = 0;
1090  asf->sub_left = 1;
1091  }
1092  sub_len = avio_r8(pb);
1093  if ((ret = av_get_packet(pb, pkt, sub_len)) < 0) // each subpayload is entire frame
1094  return ret;
1095  for (i = 0; i < asf->nb_streams; i++) {
1096  if (asf->stream_index == asf->asf_st[i]->stream_index) {
1097  pkt->stream_index = asf->asf_st[i]->index;
1098  break;
1099  }
1100  }
1101  asf->return_subpayload = 1;
1102  if (!sub_len)
1103  asf->return_subpayload = 0;
1104 
1105  if (sub_len)
1106  asf->nb_sub++;
1107  pkt->dts = asf->sub_dts + (asf->nb_sub - 1) * asf->dts_delta - asf->preroll;
1108  if (asf->nb_mult_left && (avio_tell(pb) >=
1109  (asf->sub_header_offset + asf->mult_sub_len))) {
1110  asf->sub_left = 0;
1111  asf->nb_mult_left--;
1112  }
1113  if (avio_tell(pb) >= asf->packet_offset + asf->packet_size - asf->pad_len) {
1114  asf->sub_left = 0;
1115  if (!asf->nb_mult_left) {
1116  avio_skip(pb, asf->pad_len);
1117  if (avio_tell(pb) != asf->packet_offset + asf->packet_size) {
1118  if (!asf->packet_size)
1119  return AVERROR_INVALIDDATA;
1121  "Position %"PRId64" wrong, should be %"PRId64"\n",
1122  avio_tell(pb), asf->packet_offset + asf->packet_size);
1123  avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
1124  }
1125  }
1126  }
1127 
1128  return 0;
1129 }
1130 
1131 static void reset_packet(ASFPacket *asf_pkt)
1132 {
1133  asf_pkt->size_left = 0;
1134  asf_pkt->data_size = 0;
1135  asf_pkt->duration = 0;
1136  asf_pkt->flags = 0;
1137  asf_pkt->dts = 0;
1138  av_packet_unref(&asf_pkt->avpkt);
1139 }
1140 
1142 {
1143  ASFContext *asf = s->priv_data;
1144  AVIOContext *pb = s->pb;
1145  int ret, data_size;
1146 
1147  if (!asf_pkt->data_size) {
1148  data_size = avio_rl32(pb); // read media object size
1149  if (data_size <= 0)
1150  return AVERROR_INVALIDDATA;
1151  if ((ret = av_new_packet(&asf_pkt->avpkt, data_size)) < 0)
1152  return ret;
1153  asf_pkt->data_size = asf_pkt->size_left = data_size;
1154  } else
1155  avio_skip(pb, 4); // reading of media object size is already done
1156  asf_pkt->dts = avio_rl32(pb); // read presentation time
1157  if (asf->rep_data_len >= 8)
1158  avio_skip(pb, asf->rep_data_len - 8); // skip replicated data
1159 
1160  return 0;
1161 }
1162 
1164  ASFPacket *asf_pkt)
1165 {
1166  ASFContext *asf = s->priv_data;
1167  AVIOContext *pb = s->pb;
1168  uint16_t pay_len;
1169  unsigned char *p;
1170  int ret;
1171  int skip = 0;
1172 
1173  // if replicated length is 1, subpayloads are present
1174  if (asf->rep_data_len == 1) {
1175  asf->sub_left = 1;
1176  asf->state = READ_MULTI_SUB;
1177  pkt->flags = asf_pkt->flags;
1178  if ((ret = asf_read_subpayload(s, pkt, 1)) < 0)
1179  return ret;
1180  } else {
1181  if (asf->rep_data_len)
1182  if ((ret = asf_read_replicated_data(s, asf_pkt)) < 0)
1183  return ret;
1184  pay_len = avio_rl16(pb); // payload length should be WORD
1185  if (pay_len > asf->packet_size) {
1186  av_log(s, AV_LOG_ERROR,
1187  "Error: invalid data packet size, pay_len %"PRIu16", "
1188  "asf->packet_size %"PRIu32", offset %"PRId64".\n",
1189  pay_len, asf->packet_size, avio_tell(pb));
1190  return AVERROR_INVALIDDATA;
1191  }
1192  p = asf_pkt->avpkt.data + asf_pkt->data_size - asf_pkt->size_left;
1193  if (pay_len > asf_pkt->size_left) {
1194  av_log(s, AV_LOG_ERROR,
1195  "Error: invalid buffer size, pay_len %d, data size left %d.\n",
1196  pay_len, asf_pkt->size_left);
1197  skip = pay_len - asf_pkt->size_left;
1198  pay_len = asf_pkt->size_left;
1199  }
1200  if (asf_pkt->size_left <= 0)
1201  return AVERROR_INVALIDDATA;
1202  if ((ret = avio_read(pb, p, pay_len)) < 0)
1203  return ret;
1204  if (s->key && s->keylen == 20)
1205  ff_asfcrypt_dec(s->key, p, ret);
1206  avio_skip(pb, skip);
1207  asf_pkt->size_left -= pay_len;
1208  asf->nb_mult_left--;
1209  }
1210 
1211  return 0;
1212 }
1213 
1215 {
1216  ASFContext *asf = s->priv_data;
1217  AVIOContext *pb = s->pb;
1218  int64_t offset;
1219  uint64_t size;
1220  unsigned char *p;
1221  int ret, data_size;
1222 
1223  if (!asf_pkt->data_size) {
1224  data_size = avio_rl32(pb); // read media object size
1225  if (data_size <= 0)
1226  return AVERROR_EOF;
1227  if ((ret = av_new_packet(&asf_pkt->avpkt, data_size)) < 0)
1228  return ret;
1229  asf_pkt->data_size = asf_pkt->size_left = data_size;
1230  } else
1231  avio_skip(pb, 4); // skip media object size
1232  asf_pkt->dts = avio_rl32(pb); // read presentation time
1233  if (asf->rep_data_len >= 8)
1234  avio_skip(pb, asf->rep_data_len - 8); // skip replicated data
1235  offset = avio_tell(pb);
1236 
1237  // size of the payload - size of the packet without header and padding
1238  if (asf->packet_size_internal)
1239  size = asf->packet_size_internal - offset + asf->packet_offset - asf->pad_len;
1240  else
1241  size = asf->packet_size - offset + asf->packet_offset - asf->pad_len;
1242  if (size > asf->packet_size) {
1243  av_log(s, AV_LOG_ERROR,
1244  "Error: invalid data packet size, offset %"PRId64".\n",
1245  avio_tell(pb));
1246  return AVERROR_INVALIDDATA;
1247  }
1248  p = asf_pkt->avpkt.data + asf_pkt->data_size - asf_pkt->size_left;
1249  if (size > asf_pkt->size_left || asf_pkt->size_left <= 0)
1250  return AVERROR_INVALIDDATA;
1251  if (asf_pkt->size_left > size)
1252  asf_pkt->size_left -= size;
1253  else
1254  asf_pkt->size_left = 0;
1255  if ((ret = avio_read(pb, p, size)) < 0)
1256  return ret;
1257  if (s->key && s->keylen == 20)
1258  ff_asfcrypt_dec(s->key, p, ret);
1259  if (asf->packet_size_internal)
1260  avio_skip(pb, asf->packet_size - asf->packet_size_internal);
1261  avio_skip(pb, asf->pad_len); // skip padding
1262 
1263  return 0;
1264 }
1265 
1267 {
1268  ASFContext *asf = s->priv_data;
1269  AVIOContext *pb = s->pb;
1270  int ret, i;
1271  ASFPacket *asf_pkt = NULL;
1272 
1273  if (!asf->sub_left) {
1274  uint32_t off_len, media_len;
1275  uint8_t stream_num;
1276 
1277  stream_num = avio_r8(pb);
1278  asf->stream_index = stream_num & ASF_STREAM_NUM;
1279  for (i = 0; i < asf->nb_streams; i++) {
1280  if (asf->stream_index == asf->asf_st[i]->stream_index) {
1281  asf_pkt = &asf->asf_st[i]->pkt;
1282  asf_pkt->stream_index = asf->asf_st[i]->index;
1283  break;
1284  }
1285  }
1286  if (!asf_pkt) {
1287  if (asf->packet_offset + asf->packet_size <= asf->data_offset + asf->data_size) {
1288  if (!asf->packet_size) {
1289  av_log(s, AV_LOG_ERROR, "Invalid packet size 0.\n");
1290  return AVERROR_INVALIDDATA;
1291  }
1292  avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
1293  av_log(s, AV_LOG_WARNING, "Skipping the stream with the invalid stream index %d.\n",
1294  asf->stream_index);
1295  return AVERROR(EAGAIN);
1296  } else
1297  return AVERROR_INVALIDDATA;
1298  }
1299 
1300  if (stream_num >> 7)
1301  asf_pkt->flags |= AV_PKT_FLAG_KEY;
1303  ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_, media_len);
1305  ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_, off_len);
1307  ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_, asf->rep_data_len);
1308  if (asf_pkt->size_left && (asf_pkt->frame_num != media_len)) {
1309  av_log(s, AV_LOG_WARNING, "Unfinished frame will be ignored\n");
1310  reset_packet(asf_pkt);
1311  }
1312  asf_pkt->frame_num = media_len;
1313  asf->sub_dts = off_len;
1314  if (asf->nb_mult_left) {
1315  if ((ret = asf_read_multiple_payload(s, pkt, asf_pkt)) < 0)
1316  return ret;
1317  } else if (asf->rep_data_len == 1) {
1318  asf->sub_left = 1;
1319  asf->state = READ_SINGLE;
1320  pkt->flags = asf_pkt->flags;
1321  if ((ret = asf_read_subpayload(s, pkt, 1)) < 0)
1322  return ret;
1323  } else {
1324  if ((ret = asf_read_single_payload(s, asf_pkt)) < 0)
1325  return ret;
1326  }
1327  } else {
1328  for (i = 0; i <= asf->nb_streams; i++) {
1329  if (asf->stream_index == asf->asf_st[i]->stream_index) {
1330  asf_pkt = &asf->asf_st[i]->pkt;
1331  break;
1332  }
1333  }
1334  if (!asf_pkt)
1335  return AVERROR_INVALIDDATA;
1336  pkt->flags = asf_pkt->flags;
1337  pkt->dts = asf_pkt->dts;
1338  pkt->stream_index = asf->asf_st[i]->index;
1339  if ((ret = asf_read_subpayload(s, pkt, 0)) < 0) // read subpayload without its header
1340  return ret;
1341  }
1342 
1343  return 0;
1344 }
1345 
1347 {
1348  ASFContext *asf = s->priv_data;
1349  AVIOContext *pb = s->pb;
1350  uint64_t size;
1351  uint32_t av_unused seq;
1352  unsigned char error_flags, len_flags, pay_flags;
1353 
1354  asf->packet_offset = avio_tell(pb);
1355  error_flags = avio_r8(pb); // read Error Correction Flags
1356  if (error_flags & ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT) {
1357  if (!(error_flags & ASF_ERROR_CORRECTION_LENGTH_TYPE)) {
1358  size = error_flags & ASF_PACKET_ERROR_CORRECTION_DATA_SIZE;
1359  avio_skip(pb, size);
1360  }
1361  len_flags = avio_r8(pb);
1362  } else
1363  len_flags = error_flags;
1364  asf->prop_flags = avio_r8(pb);
1366  ASF_PPI_FLAG_PACKET_LENGTH_FIELD_, asf->packet_size_internal);
1368  ASF_PPI_FLAG_SEQUENCE_FIELD_, seq);
1370  ASF_PPI_FLAG_PADDING_LENGTH_FIELD_, asf->pad_len );
1371  asf->send_time = avio_rl32(pb); // send time
1372  avio_skip(pb, 2); // skip duration
1373  if (len_flags & ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT) { // Multiple Payloads present
1374  pay_flags = avio_r8(pb);
1375  asf->nb_mult_left = (pay_flags & ASF_NUM_OF_PAYLOADS);
1376  }
1377 
1378  return 0;
1379 }
1380 
1381 static int asf_deinterleave(AVFormatContext *s, ASFPacket *asf_pkt, int st_num)
1382 {
1383  ASFContext *asf = s->priv_data;
1384  ASFStream *asf_st = asf->asf_st[st_num];
1385  unsigned char *p = asf_pkt->avpkt.data;
1386  uint16_t pkt_len = asf->asf_st[st_num]->virtual_pkt_len;
1387  uint16_t chunk_len = asf->asf_st[st_num]->virtual_chunk_len;
1388  int nchunks = pkt_len / chunk_len;
1389  AVPacket pkt;
1390  int pos = 0, j, l, ret;
1391 
1392 
1393  if ((ret = av_new_packet(&pkt, asf_pkt->data_size)) < 0)
1394  return ret;
1395 
1396  while (asf_pkt->data_size >= asf_st->span * pkt_len + pos) {
1397  if (pos >= asf_pkt->data_size) {
1398  break;
1399  }
1400  for (l = 0; l < pkt_len; l++) {
1401  if (pos >= asf_pkt->data_size) {
1402  break;
1403  }
1404  for (j = 0; j < asf_st->span; j++) {
1405  if ((pos + chunk_len) >= asf_pkt->data_size)
1406  break;
1407  memcpy(pkt.data + pos,
1408  p + (j * nchunks + l) * chunk_len,
1409  chunk_len);
1410  pos += chunk_len;
1411  }
1412  }
1413  p += asf_st->span * pkt_len;
1414  if (p > asf_pkt->avpkt.data + asf_pkt->data_size)
1415  break;
1416  }
1417  av_packet_unref(&asf_pkt->avpkt);
1418  asf_pkt->avpkt = pkt;
1419 
1420  return 0;
1421 }
1422 
1424 {
1425  ASFContext *asf = s->priv_data;
1426  AVIOContext *pb = s->pb;
1427  int ret, i;
1428 
1429  if ((avio_tell(pb) >= asf->data_offset + asf->data_size) &&
1430  !(asf->b_flags & ASF_FLAG_BROADCAST))
1431  return AVERROR_EOF;
1432  while (!pb->eof_reached) {
1433  if (asf->state == PARSE_PACKET_HEADER) {
1435  if (pb->eof_reached)
1436  break;
1437  if (!asf->nb_mult_left)
1438  asf->state = READ_SINGLE;
1439  else
1440  asf->state = READ_MULTI;
1441  }
1442  ret = asf_read_payload(s, pkt);
1443  if (ret == AVERROR(EAGAIN)) {
1444  asf->state = PARSE_PACKET_HEADER;
1445  continue;
1446  }
1447  else if (ret < 0)
1448  return ret;
1449 
1450  switch (asf->state) {
1451  case READ_SINGLE:
1452  if (!asf->sub_left)
1453  asf->state = PARSE_PACKET_HEADER;
1454  break;
1455  case READ_MULTI_SUB:
1456  if (!asf->sub_left && !asf->nb_mult_left) {
1457  asf->state = PARSE_PACKET_HEADER;
1458  if (!asf->return_subpayload &&
1459  (avio_tell(pb) <= asf->packet_offset +
1460  asf->packet_size - asf->pad_len))
1461  avio_skip(pb, asf->pad_len); // skip padding
1462  if (asf->packet_offset + asf->packet_size > avio_tell(pb))
1463  avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
1464  } else if (!asf->sub_left)
1465  asf->state = READ_MULTI;
1466  break;
1467  case READ_MULTI:
1468  if (!asf->nb_mult_left) {
1469  asf->state = PARSE_PACKET_HEADER;
1470  if (!asf->return_subpayload &&
1471  (avio_tell(pb) <= asf->packet_offset +
1472  asf->packet_size - asf->pad_len))
1473  avio_skip(pb, asf->pad_len); // skip padding
1474  if (asf->packet_offset + asf->packet_size > avio_tell(pb))
1475  avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
1476  }
1477  break;
1478  }
1479  if (asf->return_subpayload) {
1480  asf->return_subpayload = 0;
1481  return 0;
1482  }
1483  for (i = 0; i < asf->nb_streams; i++) {
1484  ASFPacket *asf_pkt = &asf->asf_st[i]->pkt;
1485  if (asf_pkt && !asf_pkt->size_left && asf_pkt->data_size) {
1486  if (asf->asf_st[i]->span > 1 &&
1487  asf->asf_st[i]->type == AVMEDIA_TYPE_AUDIO)
1488  if ((ret = asf_deinterleave(s, asf_pkt, i)) < 0)
1489  return ret;
1490  av_packet_move_ref(pkt, &asf_pkt->avpkt);
1491  pkt->stream_index = asf->asf_st[i]->index;
1492  pkt->flags = asf_pkt->flags;
1493  pkt->dts = asf_pkt->dts - asf->preroll;
1494  asf_pkt->data_size = 0;
1495  asf_pkt->frame_num = 0;
1496  return 0;
1497  }
1498  }
1499  }
1500 
1501  if (pb->eof_reached)
1502  return AVERROR_EOF;
1503 
1504  return 0;
1505 }
1506 
1508 {
1509  ASFContext *asf = s->priv_data;
1510  int i;
1511 
1512  for (i = 0; i < ASF_MAX_STREAMS; i++) {
1513  av_dict_free(&asf->asf_sd[i].asf_met);
1514  if (i < asf->nb_streams) {
1515  av_packet_unref(&asf->asf_st[i]->pkt.avpkt);
1516  av_freep(&asf->asf_st[i]);
1517  }
1518  }
1519 
1520  asf->nb_streams = 0;
1521  return 0;
1522 }
1523 
1525 {
1526  ASFContext *asf = s->priv_data;
1527  int i;
1528 
1529  asf->state = PARSE_PACKET_HEADER;
1530  asf->offset = 0;
1531  asf->return_subpayload = 0;
1532  asf->sub_left = 0;
1533  asf->sub_header_offset = 0;
1534  asf->packet_offset = asf->first_packet_offset;
1535  asf->pad_len = 0;
1536  asf->rep_data_len = 0;
1537  asf->dts_delta = 0;
1538  asf->mult_sub_len = 0;
1539  asf->nb_mult_left = 0;
1540  asf->nb_sub = 0;
1541  asf->prop_flags = 0;
1542  asf->sub_dts = 0;
1543  for (i = 0; i < asf->nb_streams; i++) {
1544  ASFPacket *pkt = &asf->asf_st[i]->pkt;
1545  reset_packet(pkt);
1546  }
1547 }
1548 
1549 /*
1550  * Find a timestamp for the requested position within the payload
1551  * where the pos (position) is the offset inside the Data Object.
1552  * When position is not on the packet boundary, asf_read_timestamp tries
1553  * to find the closest packet offset after this position. If this packet
1554  * is a key frame, this packet timestamp is read and an index entry is created
1555  * for the packet. If this packet belongs to the requested stream,
1556  * asf_read_timestamp upgrades pos to the packet beginning offset and
1557  * returns this packet's dts. So returned dts is the dts of the first key frame with
1558  * matching stream number after given position.
1559  */
1560 static int64_t asf_read_timestamp(AVFormatContext *s, int stream_index,
1561  int64_t *pos, int64_t pos_limit)
1562 {
1563  ASFContext *asf = s->priv_data;
1564  int64_t pkt_pos = *pos, pkt_offset, dts = AV_NOPTS_VALUE, data_end;
1565  AVPacket pkt;
1566  int n;
1567 
1568  data_end = asf->data_offset + asf->data_size;
1569 
1570  n = (pkt_pos - asf->first_packet_offset + asf->packet_size - 1) /
1571  asf->packet_size;
1572  n = av_clip(n, 0, ((data_end - asf->first_packet_offset) / asf->packet_size - 1));
1573  pkt_pos = asf->first_packet_offset + n * asf->packet_size;
1574 
1575  avio_seek(s->pb, pkt_pos, SEEK_SET);
1576  pkt_offset = pkt_pos;
1577 
1578  reset_packet_state(s);
1579  while (avio_tell(s->pb) < data_end) {
1580 
1581  int i, ret, st_found;
1582 
1583  av_init_packet(&pkt);
1584  pkt_offset = avio_tell(s->pb);
1585  if ((ret = asf_read_packet(s, &pkt)) < 0) {
1586  dts = AV_NOPTS_VALUE;
1587  return ret;
1588  }
1589  // ASFPacket may contain fragments of packets belonging to different streams,
1590  // pkt_offset is the offset of the first fragment within it.
1591  if ((pkt_offset >= (pkt_pos + asf->packet_size)))
1592  pkt_pos += asf->packet_size;
1593  for (i = 0; i < asf->nb_streams; i++) {
1594  ASFStream *st = asf->asf_st[i];
1595 
1596  st_found = 0;
1597  if (pkt.flags & AV_PKT_FLAG_KEY) {
1598  dts = pkt.dts;
1599  if (dts) {
1600  av_add_index_entry(s->streams[pkt.stream_index], pkt_pos,
1601  dts, pkt.size, 0, AVINDEX_KEYFRAME);
1602  if (stream_index == st->index) {
1603  st_found = 1;
1604  break;
1605  }
1606  }
1607  }
1608  }
1609  if (st_found)
1610  break;
1611  av_packet_unref(&pkt);
1612  }
1613  *pos = pkt_pos;
1614 
1615  av_packet_unref(&pkt);
1616  return dts;
1617 }
1618 
1619 static int asf_read_seek(AVFormatContext *s, int stream_index,
1620  int64_t timestamp, int flags)
1621 {
1622  ASFContext *asf = s->priv_data;
1623  int idx, ret;
1624 
1625  if (s->streams[stream_index]->internal->nb_index_entries && asf->is_simple_index) {
1626  idx = av_index_search_timestamp(s->streams[stream_index], timestamp, flags);
1627  if (idx < 0 || idx >= s->streams[stream_index]->internal->nb_index_entries)
1628  return AVERROR_INVALIDDATA;
1629  avio_seek(s->pb, s->streams[stream_index]->internal->index_entries[idx].pos, SEEK_SET);
1630  } else {
1631  if ((ret = ff_seek_frame_binary(s, stream_index, timestamp, flags)) < 0)
1632  return ret;
1633  }
1634 
1635  reset_packet_state(s);
1636 
1637  return 0;
1638 }
1639 
1641 {
1642  int j, ret;
1643  const GUIDParseTable *g;
1644 
1645  swap_guid(guid);
1646  g = gdef;
1647  for (j = 0; j < FF_ARRAY_ELEMS(gdef); j++) {
1648  if (!(ret = memcmp(guid, g->guid, sizeof(g->guid))))
1649  return g;
1650  g++;
1651  }
1652 
1653  return NULL;
1654 }
1655 
1656 static int detect_unknown_subobject(AVFormatContext *s, int64_t offset, int64_t size)
1657 {
1658  ASFContext *asf = s->priv_data;
1659  AVIOContext *pb = s->pb;
1660  const GUIDParseTable *g = NULL;
1661  ff_asf_guid guid;
1662  int ret;
1663 
1664  while (avio_tell(pb) <= offset + size) {
1665  if (avio_tell(pb) == asf->offset)
1666  break;
1667  asf->offset = avio_tell(pb);
1668  if ((ret = ff_get_guid(pb, &guid)) < 0)
1669  return ret;
1670  g = find_guid(guid);
1671  if (g) {
1672  if ((ret = g->read_object(s, g)) < 0)
1673  return ret;
1674  } else {
1675  GUIDParseTable g2;
1676 
1677  g2.name = "Unknown";
1678  g2.is_subobject = 1;
1679  asf_read_unknown(s, &g2);
1680  }
1681  }
1682 
1683  return 0;
1684 }
1685 
1687 {
1688  ASFContext *asf = s->priv_data;
1689  AVIOContext *pb = s->pb;
1690  const GUIDParseTable *g = NULL;
1691  ff_asf_guid guid;
1692  int i, ret;
1693  uint64_t size;
1694 
1695  asf->preroll = 0;
1696  asf->is_simple_index = 0;
1697  ff_get_guid(pb, &guid);
1698  if (ff_guidcmp(&guid, &ff_asf_header))
1699  return AVERROR_INVALIDDATA;
1700  avio_skip(pb, 8); // skip header object size
1701  avio_skip(pb, 6); // skip number of header objects and 2 reserved bytes
1702  asf->data_reached = 0;
1703 
1704  /* 1 is here instead of pb->eof_reached because (when not streaming), Data are skipped
1705  * for the first time,
1706  * Index object is processed and got eof and then seeking back to the Data is performed.
1707  */
1708  while (1) {
1709  // for the cases when object size is invalid
1710  if (avio_tell(pb) == asf->offset)
1711  break;
1712  asf->offset = avio_tell(pb);
1713  if ((ret = ff_get_guid(pb, &guid)) < 0) {
1714  if (ret == AVERROR_EOF && asf->data_reached)
1715  break;
1716  else
1717  goto failed;
1718  }
1719  g = find_guid(guid);
1720  if (g) {
1721  asf->unknown_offset = asf->offset;
1722  asf->is_header = 1;
1723  if ((ret = g->read_object(s, g)) < 0)
1724  goto failed;
1725  } else {
1726  size = avio_rl64(pb);
1727  align_position(pb, asf->offset, size);
1728  }
1729  if (asf->data_reached &&
1730  (!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
1731  (asf->b_flags & ASF_FLAG_BROADCAST)))
1732  break;
1733  }
1734 
1735  if (!asf->data_reached) {
1736  av_log(s, AV_LOG_ERROR, "Data Object was not found.\n");
1737  ret = AVERROR_INVALIDDATA;
1738  goto failed;
1739  }
1740  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
1741  avio_seek(pb, asf->first_packet_offset, SEEK_SET);
1742 
1743  for (i = 0; i < asf->nb_streams; i++) {
1744  const char *rfc1766 = asf->asf_sd[asf->asf_st[i]->lang_idx].langs;
1745  AVStream *st = s->streams[asf->asf_st[i]->index];
1746  set_language(s, rfc1766, &st->metadata);
1747  }
1748 
1749  for (i = 0; i < ASF_MAX_STREAMS; i++) {
1750  AVStream *st = NULL;
1751 
1752  st = find_stream(s, i);
1753  if (st) {
1755  if (asf->asf_sd[i].aspect_ratio.num > 0 && asf->asf_sd[i].aspect_ratio.den > 0) {
1758  }
1759  }
1760  }
1761 
1762  return 0;
1763 
1764 failed:
1765  asf_read_close(s);
1766  return ret;
1767 }
1768 
1770  .name = "asf_o",
1771  .long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
1772  .priv_data_size = sizeof(ASFContext),
1773  .read_probe = asf_probe,
1777  .read_timestamp = asf_read_timestamp,
1780 };
int nb_streams
Definition: asfdec_o.c:120
int data_reached
Definition: asfdec_o.c:95
const ff_asf_guid ff_asf_header
Definition: asf.c:23
static void swap_guid(ff_asf_guid guid)
Definition: asfdec_o.c:159
static int asf_read_ext_stream_properties(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:835
#define NULL
Definition: coverity.c:32
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:468
static int asf_read_close(AVFormatContext *s)
Definition: asfdec_o.c:1507
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define ASF_BYTE_ARRAY
Definition: asfdec_o.c:48
uint8_t stream_index
Definition: asfdec_o.c:77
static int asf_read_packet_header(AVFormatContext *s)
Definition: asfdec_o.c:1346
int64_t data_offset
Definition: asfdec_o.c:113
static int asf_read_unknown(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:173
#define ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE
Definition: asf.h:137
static void align_position(AVIOContext *pb, int64_t offset, uint64_t size)
Definition: asfdec_o.c:167
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
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3097
int size_left
Definition: asfdec_o.c:72
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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
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
int data_size
Definition: asfdec_o.c:70
static int asf_read_marker(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:220
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
uint32_t packet_size
Definition: asfdec_o.c:101
#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
uint16_t virtual_pkt_len
Definition: asfdec_o.c:82
#define ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE
Definition: asf.h:153
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GLint GLenum type
Definition: opengl_enc.c:104
const ff_asf_guid ff_asf_command_stream
Definition: asf.c:65
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
const char * name
Definition: asfdec_o.c:59
static void get_id3_tag(AVFormatContext *s, int len)
Definition: asfdec_o.c:448
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
#define PUT_UTF8(val, tmp, PUT_BYTE)
Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
Definition: common.h:479
static int asf_read_stream_properties(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:718
static AVPacket pkt
#define ASF_UNICODE
Definition: asfdec_o.c:46
static int asf_read_replicated_data(AVFormatContext *s, ASFPacket *asf_pkt)
Definition: asfdec_o.c:1141
ASFStreamData asf_sd[ASF_MAX_STREAMS]
Definition: asfdec_o.c:119
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.
int return_subpayload
Definition: asfdec_o.c:138
static int asf_read_language_list(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:903
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
static const GUIDParseTable * find_guid(ff_asf_guid guid)
Definition: asfdec_o.c:1640
#define gmtime_r
Definition: time_internal.h:34
char str[32]
Definition: internal.h:48
#define ASF_STREAM_NUM
Definition: asfdec_o.c:51
static int process_metadata(AVFormatContext *s, const uint8_t *name, uint16_t name_len, uint16_t val_len, uint16_t type, AVDictionary **met)
Definition: asfdec_o.c:460
Public dictionary API.
static int64_t start_time
Definition: ffplay.c:332
static int asf_read_metadata_obj(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:565
uint8_t
static int asf_read_generic_value(AVIOContext *pb, int type, uint64_t *value)
Definition: asfdec_o.c:314
uint8_t stream_index
Definition: asfdec_o.c:73
static int nb_streams
Definition: ffprobe.c:282
#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
static int asf_store_aspect_ratio(AVFormatContext *s, uint8_t st_num, uint8_t *name, int type)
Definition: asfdec_o.c:545
int is_simple_index
Definition: asfdec_o.c:96
AVOptions.
uint8_t dts_delta
Definition: asfdec_o.c:127
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 BMP_HEADER_SIZE
Definition: asfdec_o.c:53
int id
Format-specific stream ID.
Definition: avformat.h:887
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
int64_t send_time
Definition: asfdec_o.c:102
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
static int asf_read_data(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:929
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
uint8_t * data
Definition: packet.h:363
int64_t offset
Definition: asfdec_o.c:111
int64_t packet_offset
Definition: asfdec_o.c:129
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:664
static void reset_packet_state(AVFormatContext *s)
Definition: asfdec_o.c:1524
uint32_t tag
Definition: movenc.c:1597
#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
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
#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
uint32_t pad_len
Definition: asfdec_o.c:130
AVRational aspect_ratio
Definition: asfdec_o.c:91
static int asf_read_content_desc(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:613
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
#define GET_UTF16(val, GET_16BIT, ERROR)
Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:451
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
int16_t lang_idx
Definition: asfdec_o.c:84
#define AVINDEX_KEYFRAME
Definition: avformat.h:816
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
int indexed
Definition: asfdec_o.c:80
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2101
#define ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE
Definition: asf.h:148
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:754
int type
Definition: asfdec_o.c:79
#define ASF_QWORD
Definition: asfdec_o.c:45
uint64_t preroll
Definition: asfdec_o.c:99
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
void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len)
Definition: asfcrypt.c:147
unsigned int pos
Definition: spdifenc.c:410
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
static int asf_read_ext_content(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:492
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1114
int64_t sub_dts
Definition: asfdec_o.c:126
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
Definition: riffdec.c:32
ff_asf_guid guid
Definition: asfdec_o.c:60
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:953
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:123
int index
Definition: asfdec_o.c:78
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
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
static int asf_deinterleave(AVFormatContext *s, ASFPacket *asf_pkt, int st_num)
Definition: asfdec_o.c:1381
#define ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT
Definition: asf.h:127
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
static int asf_read_multiple_payload(AVFormatContext *s, AVPacket *pkt, ASFPacket *asf_pkt)
Definition: asfdec_o.c:1163
#define ASF_FLAG_BROADCAST
Definition: asfdec_o.c:47
static int asf_read_single_payload(AVFormatContext *s, ASFPacket *asf_pkt)
Definition: asfdec_o.c:1214
static int asf_read_payload(AVFormatContext *s, AVPacket *pkt)
Definition: asfdec_o.c:1266
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
static int asf_read_value(AVFormatContext *s, const uint8_t *name, uint16_t val_len, int type, AVDictionary **met)
Definition: asfdec_o.c:273
static struct @322 state
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
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:965
#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE
Definition: asfdec_o.c:56
#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
uint32_t frame_num
Definition: asfdec_o.c:68
AVInputFormat ff_asf_o_demuxer
Definition: asfdec_o.c:1769
int64_t dts
Definition: asfdec_o.c:67
ASFStream * asf_st
currently decoded stream
Definition: asfdec_f.c:112
static int get_asf_string(AVIOContext *pb, int maxlen, char *buf, int buflen)
Definition: asfdec_o.c:203
uint64_t data_size
Definition: asfdec_o.c:108
#define ASF_WORD
Definition: asfdec_o.c:42
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
#define ASF_ERROR_CORRECTION_LENGTH_TYPE
Definition: asfdec_o.c:55
int32_t
#define READ_LEN(flag, name, len)
Definition: asfdec_o.c:1064
#define s(width, name)
Definition: cbs_vp9.c:257
const ff_asf_guid ff_asf_ext_stream_embed_stream_header
Definition: asf.c:100
static void set_language(AVFormatContext *s, const char *rfc1766, AVDictionary **met)
Definition: asfdec_o.c:822
AVDictionary * metadata
Definition: avformat.h:944
static int64_t asf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Definition: asfdec_o.c:1560
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: asfdec_o.c:1619
#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 asf_probe(const AVProbeData *pd)
Definition: asfdec_o.c:150
unsigned int nb_sub
Definition: asfdec_o.c:135
#define ASF_BOOL
Definition: asfdec_o.c:41
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
if(ret)
#define ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT
Definition: asf.h:108
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
#define ASF_NUM_OF_PAYLOADS
Definition: asfdec_o.c:54
uint32_t rep_data_len
Definition: asfdec_o.c:131
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
uint32_t prop_flags
Definition: asfdec_o.c:106
AVPacket avpkt
Definition: asfdec_o.c:66
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1119
uint32_t packet_size_internal
Definition: asfdec_o.c:128
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
const ff_asf_guid ff_asf_video_stream
Definition: asf.c:53
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
static int asf_read_picture(AVFormatContext *s, int len)
Definition: asfdec_o.c:358
#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
int64_t first_packet_offset
Definition: asfdec_o.c:114
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
static const GUIDParseTable gdef[]
Definition: asfdec_o.c:1014
AVDictionary * asf_met
Definition: asfdec_o.c:90
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: asfdec_o.c:1423
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define ASF_PPI_MASK_SEQUENCE_FIELD_SIZE
Definition: asf.h:132
#define ASF_DWORD
Definition: asfdec_o.c:44
byte swapping routines
uint64_t sub_left
Definition: asfdec_o.c:134
uint64_t unknown_size
Definition: asfdec_o.c:109
AVMediaType
Definition: avutil.h:199
#define snprintf
Definition: snprintf.h:34
uint16_t mult_sub_len
Definition: asfdec_o.c:136
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
uint32_t b_flags
Definition: asfdec_o.c:105
int nb_index_entries
Definition: internal.h:230
ASFPacket pkt
Definition: asfdec_o.c:85
static int64_t pts
int64_t unknown_offset
Definition: asfdec_o.c:115
static void reset_packet(ASFPacket *asf_pkt)
Definition: asfdec_o.c:1131
#define flags(name, subs,...)
Definition: cbs_av1.c:560
int duration
Definition: asfdec_o.c:71
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:929
int is_header
Definition: asfdec_o.c:97
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
const uint8_t * key
Definition: avformat.h:1415
int64_t bitrate
Definition: h264_levels.c:131
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:738
Main libavformat public API header.
int
#define ASF_MAX_STREAMS
Definition: asfdec_o.c:52
uint64_t sub_header_offset
Definition: asfdec_o.c:125
const ff_asf_guid ff_asf_jfif_media
Definition: asf.c:57
#define ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE
Definition: asf.h:142
common internal and external API header
static int asf_read_metadata(AVFormatContext *s, const char *title, uint16_t len, unsigned char *ch, uint16_t buflen)
Definition: asfdec_o.c:259
int is_subobject
Definition: asfdec_o.c:62
uint64_t nb_packets
how many packets are there in the file, invalid if broadcasting
Definition: asfdec_o.c:100
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:919
static int asf_read_subpayload(AVFormatContext *s, AVPacket *pkt, int is_header)
Definition: asfdec_o.c:1076
#define ASF_GUID
Definition: asfdec_o.c:43
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
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
#define ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE
Definition: asf.h:158
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
Read BITMAPINFOHEADER structure and set AVStream codec width, height and bits_per_encoded_sample fiel...
Definition: riffdec.c:209
static int asf_read_properties(AVFormatContext *s, const GUIDParseTable *g)
Definition: asfdec_o.c:642
#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 eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
int len
static int asf_set_metadata(AVFormatContext *s, const uint8_t *name, int type, AVDictionary **met)
Definition: asfdec_o.c:337
void * priv_data
Format private data.
Definition: avformat.h:1267
static AVStream * find_stream(AVFormatContext *s, uint16_t st_num)
Definition: asfdec_o.c:529
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
int duration
Definition: asfdec_o.c:103
uint64_t nb_mult_left
Definition: asfdec_o.c:137
char langs[32]
Definition: asfdec_o.c:89
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
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
enum ASFContext::@246 state
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
static int parse_video_info(AVIOContext *pb, AVStream *st)
Definition: asfdec_o.c:685
const char *const ff_id3v2_picture_types[21]
Definition: id3v2.c:107
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
#define FFSWAP(type, a, b)
Definition: common.h:99
int stream_index
Definition: packet.h:365
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
int(* read_object)(AVFormatContext *, const struct GUIDParseTable *)
Definition: asfdec_o.c:61
int flags
Definition: asfdec_o.c:69
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
int8_t span
Definition: asfdec_o.c:81
uint16_t virtual_chunk_len
Definition: asfdec_o.c:83
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:962
int i
Definition: input.c:407
#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
const char * name
Definition: opengl_enc.c:102
static int asf_read_header(AVFormatContext *s)
Definition: asfdec_o.c:1686
static int detect_unknown_subobject(AVFormatContext *s, int64_t offset, int64_t size)
Definition: asfdec_o.c:1656
static uint8_t tmp[11]
Definition: aes_ctr.c:26