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