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