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