FFmpeg  4.4
mov.c
Go to the documentation of this file.
1 /*
2  * MOV demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
5  *
6  * first version by Francois Revol <revol@free.fr>
7  * seek function by Gael Chardon <gael.dev@4now.net>
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include <inttypes.h>
27 #include <limits.h>
28 #include <stdint.h>
29 
30 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/intfloat.h"
35 #include "libavutil/mathematics.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/display.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/aes.h"
43 #include "libavutil/aes_ctr.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/sha.h"
46 #include "libavutil/spherical.h"
47 #include "libavutil/stereo3d.h"
48 #include "libavutil/timecode.h"
49 #include "libavutil/dovi_meta.h"
50 #include "libavcodec/ac3tab.h"
51 #include "libavcodec/flac.h"
53 #include "libavcodec/mlp_parse.h"
54 #include "avformat.h"
55 #include "internal.h"
56 #include "avio_internal.h"
57 #include "riff.h"
58 #include "isom.h"
59 #include "libavcodec/get_bits.h"
60 #include "id3v1.h"
61 #include "mov_chan.h"
62 #include "replaygain.h"
63 
64 #if CONFIG_ZLIB
65 #include <zlib.h>
66 #endif
67 
68 #include "qtpalette.h"
69 
70 /* those functions parse an atom */
71 /* links atom IDs to parse functions */
72 typedef struct MOVParseTableEntry {
73  uint32_t type;
76 
77 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
78 static int mov_read_mfra(MOVContext *c, AVIOContext *f);
79 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
80  int count, int duration);
81 
83  unsigned len, const char *key)
84 {
85  char buf[16];
86 
87  short current, total = 0;
88  avio_rb16(pb); // unknown
89  current = avio_rb16(pb);
90  if (len >= 6)
91  total = avio_rb16(pb);
92  if (!total)
93  snprintf(buf, sizeof(buf), "%d", current);
94  else
95  snprintf(buf, sizeof(buf), "%d/%d", current, total);
96  c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
97  av_dict_set(&c->fc->metadata, key, buf, 0);
98 
99  return 0;
100 }
101 
103  unsigned len, const char *key)
104 {
105  /* bypass padding bytes */
106  avio_r8(pb);
107  avio_r8(pb);
108  avio_r8(pb);
109 
110  c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
111  av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
112 
113  return 0;
114 }
115 
117  unsigned len, const char *key)
118 {
119  c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
120  av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
121 
122  return 0;
123 }
124 
126  unsigned len, const char *key)
127 {
128  short genre;
129 
130  avio_r8(pb); // unknown
131 
132  genre = avio_r8(pb);
133  if (genre < 1 || genre > ID3v1_GENRE_MAX)
134  return 0;
135  c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
136  av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
137 
138  return 0;
139 }
140 
141 static const uint32_t mac_to_unicode[128] = {
142  0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
143  0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
144  0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
145  0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
146  0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
147  0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
148  0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
149  0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
150  0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
151  0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
152  0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
153  0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
154  0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
155  0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
156  0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
157  0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
158 };
159 
161  char *dst, int dstlen)
162 {
163  char *p = dst;
164  char *end = dst+dstlen-1;
165  int i;
166 
167  for (i = 0; i < len; i++) {
168  uint8_t t, c = avio_r8(pb);
169 
170  if (p >= end)
171  continue;
172 
173  if (c < 0x80)
174  *p++ = c;
175  else if (p < end)
176  PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
177  }
178  *p = 0;
179  return p - dst;
180 }
181 
182 static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
183 {
184  AVStream *st;
185  MOVStreamContext *sc;
186  enum AVCodecID id;
187  int ret;
188 
189  switch (type) {
190  case 0xd: id = AV_CODEC_ID_MJPEG; break;
191  case 0xe: id = AV_CODEC_ID_PNG; break;
192  case 0x1b: id = AV_CODEC_ID_BMP; break;
193  default:
194  av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
195  avio_skip(pb, len);
196  return 0;
197  }
198 
199  st = avformat_new_stream(c->fc, NULL);
200  if (!st)
201  return AVERROR(ENOMEM);
202  sc = av_mallocz(sizeof(*sc));
203  if (!sc)
204  return AVERROR(ENOMEM);
205  st->priv_data = sc;
206 
207  ret = av_get_packet(pb, &st->attached_pic, len);
208  if (ret < 0)
209  return ret;
210 
211  if (st->attached_pic.size >= 8 && id != AV_CODEC_ID_BMP) {
212  if (AV_RB64(st->attached_pic.data) == 0x89504e470d0a1a0a) {
213  id = AV_CODEC_ID_PNG;
214  } else {
215  id = AV_CODEC_ID_MJPEG;
216  }
217  }
218 
220 
221  st->attached_pic.stream_index = st->index;
223 
225  st->codecpar->codec_id = id;
226 
227  return 0;
228 }
229 
230 // 3GPP TS 26.244
231 static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
232 {
233  char language[4] = { 0 };
234  char buf[200], place[100];
235  uint16_t langcode = 0;
236  double longitude, latitude, altitude;
237  const char *key = "location";
238 
239  if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4) {
240  av_log(c->fc, AV_LOG_ERROR, "loci too short\n");
241  return AVERROR_INVALIDDATA;
242  }
243 
244  avio_skip(pb, 4); // version+flags
245  langcode = avio_rb16(pb);
246  ff_mov_lang_to_iso639(langcode, language);
247  len -= 6;
248 
249  len -= avio_get_str(pb, len, place, sizeof(place));
250  if (len < 1) {
251  av_log(c->fc, AV_LOG_ERROR, "place name too long\n");
252  return AVERROR_INVALIDDATA;
253  }
254  avio_skip(pb, 1); // role
255  len -= 1;
256 
257  if (len < 12) {
258  av_log(c->fc, AV_LOG_ERROR,
259  "loci too short (%u bytes left, need at least %d)\n", len, 12);
260  return AVERROR_INVALIDDATA;
261  }
262  longitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
263  latitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
264  altitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
265 
266  // Try to output in the same format as the ?xyz field
267  snprintf(buf, sizeof(buf), "%+08.4f%+09.4f", latitude, longitude);
268  if (altitude)
269  av_strlcatf(buf, sizeof(buf), "%+f", altitude);
270  av_strlcatf(buf, sizeof(buf), "/%s", place);
271 
272  if (*language && strcmp(language, "und")) {
273  char key2[16];
274  snprintf(key2, sizeof(key2), "%s-%s", key, language);
275  av_dict_set(&c->fc->metadata, key2, buf, 0);
276  }
277  c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
278  return av_dict_set(&c->fc->metadata, key, buf, 0);
279 }
280 
281 static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
282 {
283  int i, n_hmmt;
284 
285  if (len < 2)
286  return 0;
287  if (c->ignore_chapters)
288  return 0;
289 
290  n_hmmt = avio_rb32(pb);
291  if (n_hmmt > len / 4)
292  return AVERROR_INVALIDDATA;
293  for (i = 0; i < n_hmmt && !pb->eof_reached; i++) {
294  int moment_time = avio_rb32(pb);
295  avpriv_new_chapter(c->fc, i, av_make_q(1, 1000), moment_time, AV_NOPTS_VALUE, NULL);
296  }
297  return 0;
298 }
299 
301 {
302  char tmp_key[AV_FOURCC_MAX_STRING_SIZE] = {0};
303  char key2[32], language[4] = {0};
304  char *str = NULL;
305  const char *key = NULL;
306  uint16_t langcode = 0;
307  uint32_t data_type = 0, str_size, str_size_alloc;
308  int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
309  int raw = 0;
310  int num = 0;
311 
312  switch (atom.type) {
313  case MKTAG( '@','P','R','M'): key = "premiere_version"; raw = 1; break;
314  case MKTAG( '@','P','R','Q'): key = "quicktime_version"; raw = 1; break;
315  case MKTAG( 'X','M','P','_'):
316  if (c->export_xmp) { key = "xmp"; raw = 1; } break;
317  case MKTAG( 'a','A','R','T'): key = "album_artist"; break;
318  case MKTAG( 'a','k','I','D'): key = "account_type";
320  case MKTAG( 'a','p','I','D'): key = "account_id"; break;
321  case MKTAG( 'c','a','t','g'): key = "category"; break;
322  case MKTAG( 'c','p','i','l'): key = "compilation";
324  case MKTAG( 'c','p','r','t'): key = "copyright"; break;
325  case MKTAG( 'd','e','s','c'): key = "description"; break;
326  case MKTAG( 'd','i','s','k'): key = "disc";
328  case MKTAG( 'e','g','i','d'): key = "episode_uid";
330  case MKTAG( 'F','I','R','M'): key = "firmware"; raw = 1; break;
331  case MKTAG( 'g','n','r','e'): key = "genre";
332  parse = mov_metadata_gnre; break;
333  case MKTAG( 'h','d','v','d'): key = "hd_video";
335  case MKTAG( 'H','M','M','T'):
336  return mov_metadata_hmmt(c, pb, atom.size);
337  case MKTAG( 'k','e','y','w'): key = "keywords"; break;
338  case MKTAG( 'l','d','e','s'): key = "synopsis"; break;
339  case MKTAG( 'l','o','c','i'):
340  return mov_metadata_loci(c, pb, atom.size);
341  case MKTAG( 'm','a','n','u'): key = "make"; break;
342  case MKTAG( 'm','o','d','l'): key = "model"; break;
343  case MKTAG( 'p','c','s','t'): key = "podcast";
345  case MKTAG( 'p','g','a','p'): key = "gapless_playback";
347  case MKTAG( 'p','u','r','d'): key = "purchase_date"; break;
348  case MKTAG( 'r','t','n','g'): key = "rating";
350  case MKTAG( 's','o','a','a'): key = "sort_album_artist"; break;
351  case MKTAG( 's','o','a','l'): key = "sort_album"; break;
352  case MKTAG( 's','o','a','r'): key = "sort_artist"; break;
353  case MKTAG( 's','o','c','o'): key = "sort_composer"; break;
354  case MKTAG( 's','o','n','m'): key = "sort_name"; break;
355  case MKTAG( 's','o','s','n'): key = "sort_show"; break;
356  case MKTAG( 's','t','i','k'): key = "media_type";
358  case MKTAG( 't','r','k','n'): key = "track";
360  case MKTAG( 't','v','e','n'): key = "episode_id"; break;
361  case MKTAG( 't','v','e','s'): key = "episode_sort";
363  case MKTAG( 't','v','n','n'): key = "network"; break;
364  case MKTAG( 't','v','s','h'): key = "show"; break;
365  case MKTAG( 't','v','s','n'): key = "season_number";
367  case MKTAG(0xa9,'A','R','T'): key = "artist"; break;
368  case MKTAG(0xa9,'P','R','D'): key = "producer"; break;
369  case MKTAG(0xa9,'a','l','b'): key = "album"; break;
370  case MKTAG(0xa9,'a','u','t'): key = "artist"; break;
371  case MKTAG(0xa9,'c','h','p'): key = "chapter"; break;
372  case MKTAG(0xa9,'c','m','t'): key = "comment"; break;
373  case MKTAG(0xa9,'c','o','m'): key = "composer"; break;
374  case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
375  case MKTAG(0xa9,'d','a','y'): key = "date"; break;
376  case MKTAG(0xa9,'d','i','r'): key = "director"; break;
377  case MKTAG(0xa9,'d','i','s'): key = "disclaimer"; break;
378  case MKTAG(0xa9,'e','d','1'): key = "edit_date"; break;
379  case MKTAG(0xa9,'e','n','c'): key = "encoder"; break;
380  case MKTAG(0xa9,'f','m','t'): key = "original_format"; break;
381  case MKTAG(0xa9,'g','e','n'): key = "genre"; break;
382  case MKTAG(0xa9,'g','r','p'): key = "grouping"; break;
383  case MKTAG(0xa9,'h','s','t'): key = "host_computer"; break;
384  case MKTAG(0xa9,'i','n','f'): key = "comment"; break;
385  case MKTAG(0xa9,'l','y','r'): key = "lyrics"; break;
386  case MKTAG(0xa9,'m','a','k'): key = "make"; break;
387  case MKTAG(0xa9,'m','o','d'): key = "model"; break;
388  case MKTAG(0xa9,'n','a','m'): key = "title"; break;
389  case MKTAG(0xa9,'o','p','e'): key = "original_artist"; break;
390  case MKTAG(0xa9,'p','r','d'): key = "producer"; break;
391  case MKTAG(0xa9,'p','r','f'): key = "performers"; break;
392  case MKTAG(0xa9,'r','e','q'): key = "playback_requirements"; break;
393  case MKTAG(0xa9,'s','r','c'): key = "original_source"; break;
394  case MKTAG(0xa9,'s','t','3'): key = "subtitle"; break;
395  case MKTAG(0xa9,'s','w','r'): key = "encoder"; break;
396  case MKTAG(0xa9,'t','o','o'): key = "encoder"; break;
397  case MKTAG(0xa9,'t','r','k'): key = "track"; break;
398  case MKTAG(0xa9,'u','r','l'): key = "URL"; break;
399  case MKTAG(0xa9,'w','r','n'): key = "warning"; break;
400  case MKTAG(0xa9,'w','r','t'): key = "composer"; break;
401  case MKTAG(0xa9,'x','y','z'): key = "location"; break;
402  }
403 retry:
404  if (c->itunes_metadata && atom.size > 8) {
405  int data_size = avio_rb32(pb);
406  int tag = avio_rl32(pb);
407  if (tag == MKTAG('d','a','t','a') && data_size <= atom.size && data_size >= 16) {
408  data_type = avio_rb32(pb); // type
409  avio_rb32(pb); // unknown
410  str_size = data_size - 16;
411  atom.size -= 16;
412 
413  if (atom.type == MKTAG('c', 'o', 'v', 'r')) {
414  int ret = mov_read_covr(c, pb, data_type, str_size);
415  if (ret < 0) {
416  av_log(c->fc, AV_LOG_ERROR, "Error parsing cover art.\n");
417  return ret;
418  }
419  atom.size -= str_size;
420  if (atom.size > 8)
421  goto retry;
422  return ret;
423  } else if (!key && c->found_hdlr_mdta && c->meta_keys) {
424  uint32_t index = AV_RB32(&atom.type);
425  if (index < c->meta_keys_count && index > 0) {
426  key = c->meta_keys[index];
427  } else {
428  av_log(c->fc, AV_LOG_WARNING,
429  "The index of 'data' is out of range: %"PRId32" < 1 or >= %d.\n",
430  index, c->meta_keys_count);
431  }
432  }
433  } else return 0;
434  } else if (atom.size > 4 && key && !c->itunes_metadata && !raw) {
435  str_size = avio_rb16(pb); // string length
436  if (str_size > atom.size) {
437  raw = 1;
438  avio_seek(pb, -2, SEEK_CUR);
439  av_log(c->fc, AV_LOG_WARNING, "UDTA parsing failed retrying raw\n");
440  goto retry;
441  }
442  langcode = avio_rb16(pb);
443  ff_mov_lang_to_iso639(langcode, language);
444  atom.size -= 4;
445  } else
446  str_size = atom.size;
447 
448  if (c->export_all && !key) {
449  key = av_fourcc_make_string(tmp_key, atom.type);
450  }
451 
452  if (!key)
453  return 0;
454  if (atom.size < 0 || str_size >= INT_MAX/2)
455  return AVERROR_INVALIDDATA;
456 
457  // Allocates enough space if data_type is a int32 or float32 number, otherwise
458  // worst-case requirement for output string in case of utf8 coded input
459  num = (data_type >= 21 && data_type <= 23);
460  str_size_alloc = (num ? 512 : (raw ? str_size : str_size * 2)) + 1;
461  str = av_mallocz(str_size_alloc);
462  if (!str)
463  return AVERROR(ENOMEM);
464 
465  if (parse)
466  parse(c, pb, str_size, key);
467  else {
468  if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
469  mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
470  } else if (data_type == 21) { // BE signed integer, variable size
471  int val = 0;
472  if (str_size == 1)
473  val = (int8_t)avio_r8(pb);
474  else if (str_size == 2)
475  val = (int16_t)avio_rb16(pb);
476  else if (str_size == 3)
477  val = ((int32_t)(avio_rb24(pb)<<8))>>8;
478  else if (str_size == 4)
479  val = (int32_t)avio_rb32(pb);
480  if (snprintf(str, str_size_alloc, "%d", val) >= str_size_alloc) {
481  av_log(c->fc, AV_LOG_ERROR,
482  "Failed to store the number (%d) in string.\n", val);
483  av_free(str);
484  return AVERROR_INVALIDDATA;
485  }
486  } else if (data_type == 22) { // BE unsigned integer, variable size
487  unsigned int val = 0;
488  if (str_size == 1)
489  val = avio_r8(pb);
490  else if (str_size == 2)
491  val = avio_rb16(pb);
492  else if (str_size == 3)
493  val = avio_rb24(pb);
494  else if (str_size == 4)
495  val = avio_rb32(pb);
496  if (snprintf(str, str_size_alloc, "%u", val) >= str_size_alloc) {
497  av_log(c->fc, AV_LOG_ERROR,
498  "Failed to store the number (%u) in string.\n", val);
499  av_free(str);
500  return AVERROR_INVALIDDATA;
501  }
502  } else if (data_type == 23 && str_size >= 4) { // BE float32
503  float val = av_int2float(avio_rb32(pb));
504  if (snprintf(str, str_size_alloc, "%f", val) >= str_size_alloc) {
505  av_log(c->fc, AV_LOG_ERROR,
506  "Failed to store the float32 number (%f) in string.\n", val);
507  av_free(str);
508  return AVERROR_INVALIDDATA;
509  }
510  } else {
511  int ret = ffio_read_size(pb, str, str_size);
512  if (ret < 0) {
513  av_free(str);
514  return ret;
515  }
516  str[str_size] = 0;
517  }
518  c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
519  av_dict_set(&c->fc->metadata, key, str, 0);
520  if (*language && strcmp(language, "und")) {
521  snprintf(key2, sizeof(key2), "%s-%s", key, language);
522  av_dict_set(&c->fc->metadata, key2, str, 0);
523  }
524  if (!strcmp(key, "encoder")) {
525  int major, minor, micro;
526  if (sscanf(str, "HandBrake %d.%d.%d", &major, &minor, &micro) == 3) {
527  c->handbrake_version = 1000000*major + 1000*minor + micro;
528  }
529  }
530  }
531 
532  av_freep(&str);
533  return 0;
534 }
535 
537 {
538  int64_t start;
539  int i, nb_chapters, str_len, version;
540  char str[256+1];
541  int ret;
542 
543  if (c->ignore_chapters)
544  return 0;
545 
546  if ((atom.size -= 5) < 0)
547  return 0;
548 
549  version = avio_r8(pb);
550  avio_rb24(pb);
551  if (version)
552  avio_rb32(pb); // ???
553  nb_chapters = avio_r8(pb);
554 
555  for (i = 0; i < nb_chapters; i++) {
556  if (atom.size < 9)
557  return 0;
558 
559  start = avio_rb64(pb);
560  str_len = avio_r8(pb);
561 
562  if ((atom.size -= 9+str_len) < 0)
563  return 0;
564 
565  ret = ffio_read_size(pb, str, str_len);
566  if (ret < 0)
567  return ret;
568  str[str_len] = 0;
569  avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
570  }
571  return 0;
572 }
573 
574 #define MIN_DATA_ENTRY_BOX_SIZE 12
576 {
577  AVStream *st;
578  MOVStreamContext *sc;
579  int entries, i, j;
580 
581  if (c->fc->nb_streams < 1)
582  return 0;
583  st = c->fc->streams[c->fc->nb_streams-1];
584  sc = st->priv_data;
585 
586  avio_rb32(pb); // version + flags
587  entries = avio_rb32(pb);
588  if (!entries ||
589  entries > (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
590  entries >= UINT_MAX / sizeof(*sc->drefs))
591  return AVERROR_INVALIDDATA;
592 
593  for (i = 0; i < sc->drefs_count; i++) {
594  MOVDref *dref = &sc->drefs[i];
595  av_freep(&dref->path);
596  av_freep(&dref->dir);
597  }
598  av_free(sc->drefs);
599  sc->drefs_count = 0;
600  sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
601  if (!sc->drefs)
602  return AVERROR(ENOMEM);
603  sc->drefs_count = entries;
604 
605  for (i = 0; i < entries; i++) {
606  MOVDref *dref = &sc->drefs[i];
607  uint32_t size = avio_rb32(pb);
608  int64_t next = avio_tell(pb) + size - 4;
609 
610  if (size < 12)
611  return AVERROR_INVALIDDATA;
612 
613  dref->type = avio_rl32(pb);
614  avio_rb32(pb); // version + flags
615 
616  if (dref->type == MKTAG('a','l','i','s') && size > 150) {
617  /* macintosh alias record */
618  uint16_t volume_len, len;
619  int16_t type;
620  int ret;
621 
622  avio_skip(pb, 10);
623 
624  volume_len = avio_r8(pb);
625  volume_len = FFMIN(volume_len, 27);
626  ret = ffio_read_size(pb, dref->volume, 27);
627  if (ret < 0)
628  return ret;
629  dref->volume[volume_len] = 0;
630  av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
631 
632  avio_skip(pb, 12);
633 
634  len = avio_r8(pb);
635  len = FFMIN(len, 63);
636  ret = ffio_read_size(pb, dref->filename, 63);
637  if (ret < 0)
638  return ret;
639  dref->filename[len] = 0;
640  av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
641 
642  avio_skip(pb, 16);
643 
644  /* read next level up_from_alias/down_to_target */
645  dref->nlvl_from = avio_rb16(pb);
646  dref->nlvl_to = avio_rb16(pb);
647  av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
648  dref->nlvl_from, dref->nlvl_to);
649 
650  avio_skip(pb, 16);
651 
652  for (type = 0; type != -1 && avio_tell(pb) < next; ) {
653  if (avio_feof(pb))
654  return AVERROR_EOF;
655  type = avio_rb16(pb);
656  len = avio_rb16(pb);
657  av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
658  if (len&1)
659  len += 1;
660  if (type == 2) { // absolute path
661  av_free(dref->path);
662  dref->path = av_mallocz(len+1);
663  if (!dref->path)
664  return AVERROR(ENOMEM);
665 
666  ret = ffio_read_size(pb, dref->path, len);
667  if (ret < 0) {
668  av_freep(&dref->path);
669  return ret;
670  }
671  if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
672  len -= volume_len;
673  memmove(dref->path, dref->path+volume_len, len);
674  dref->path[len] = 0;
675  }
676  // trim string of any ending zeros
677  for (j = len - 1; j >= 0; j--) {
678  if (dref->path[j] == 0)
679  len--;
680  else
681  break;
682  }
683  for (j = 0; j < len; j++)
684  if (dref->path[j] == ':' || dref->path[j] == 0)
685  dref->path[j] = '/';
686  av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
687  } else if (type == 0) { // directory name
688  av_free(dref->dir);
689  dref->dir = av_malloc(len+1);
690  if (!dref->dir)
691  return AVERROR(ENOMEM);
692 
693  ret = ffio_read_size(pb, dref->dir, len);
694  if (ret < 0) {
695  av_freep(&dref->dir);
696  return ret;
697  }
698  dref->dir[len] = 0;
699  for (j = 0; j < len; j++)
700  if (dref->dir[j] == ':')
701  dref->dir[j] = '/';
702  av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
703  } else
704  avio_skip(pb, len);
705  }
706  } else {
707  av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x%08"PRIx32" size %"PRIu32"\n",
708  dref->type, size);
709  entries--;
710  i--;
711  }
712  avio_seek(pb, next, SEEK_SET);
713  }
714  return 0;
715 }
716 
718 {
719  AVStream *st;
720  uint32_t type;
721  uint32_t ctype;
722  int64_t title_size;
723  char *title_str;
724  int ret;
725 
726  avio_r8(pb); /* version */
727  avio_rb24(pb); /* flags */
728 
729  /* component type */
730  ctype = avio_rl32(pb);
731  type = avio_rl32(pb); /* component subtype */
732 
733  av_log(c->fc, AV_LOG_TRACE, "ctype=%s\n", av_fourcc2str(ctype));
734  av_log(c->fc, AV_LOG_TRACE, "stype=%s\n", av_fourcc2str(type));
735 
736  if (c->trak_index < 0) { // meta not inside a trak
737  if (type == MKTAG('m','d','t','a')) {
738  c->found_hdlr_mdta = 1;
739  }
740  return 0;
741  }
742 
743  st = c->fc->streams[c->fc->nb_streams-1];
744 
745  if (type == MKTAG('v','i','d','e'))
747  else if (type == MKTAG('s','o','u','n'))
749  else if (type == MKTAG('m','1','a',' '))
751  else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
753 
754  avio_rb32(pb); /* component manufacture */
755  avio_rb32(pb); /* component flags */
756  avio_rb32(pb); /* component flags mask */
757 
758  title_size = atom.size - 24;
759  if (title_size > 0) {
760  if (title_size > FFMIN(INT_MAX, SIZE_MAX-1))
761  return AVERROR_INVALIDDATA;
762  title_str = av_malloc(title_size + 1); /* Add null terminator */
763  if (!title_str)
764  return AVERROR(ENOMEM);
765 
766  ret = ffio_read_size(pb, title_str, title_size);
767  if (ret < 0) {
768  av_freep(&title_str);
769  return ret;
770  }
771  title_str[title_size] = 0;
772  if (title_str[0]) {
773  int off = (!c->isom && title_str[0] == title_size - 1);
774  // flag added so as to not set stream handler name if already set from mdia->hdlr
775  av_dict_set(&st->metadata, "handler_name", title_str + off, AV_DICT_DONT_OVERWRITE);
776  }
777  av_freep(&title_str);
778  }
779 
780  return 0;
781 }
782 
784 {
785  return ff_mov_read_esds(c->fc, pb);
786 }
787 
789 {
790  AVStream *st;
791  enum AVAudioServiceType *ast;
792  int ac3info, acmod, lfeon, bsmod;
793 
794  if (c->fc->nb_streams < 1)
795  return 0;
796  st = c->fc->streams[c->fc->nb_streams-1];
797 
799  sizeof(*ast));
800  if (!ast)
801  return AVERROR(ENOMEM);
802 
803  ac3info = avio_rb24(pb);
804  bsmod = (ac3info >> 14) & 0x7;
805  acmod = (ac3info >> 11) & 0x7;
806  lfeon = (ac3info >> 10) & 0x1;
807  st->codecpar->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
809  if (lfeon)
811  *ast = bsmod;
812  if (st->codecpar->channels > 1 && bsmod == 0x7)
814 
815 #if FF_API_LAVF_AVCTX
817  st->codec->audio_service_type = *ast;
819 #endif
820 
821  return 0;
822 }
823 
825 {
826  AVStream *st;
827  enum AVAudioServiceType *ast;
828  int eac3info, acmod, lfeon, bsmod;
829 
830  if (c->fc->nb_streams < 1)
831  return 0;
832  st = c->fc->streams[c->fc->nb_streams-1];
833 
835  sizeof(*ast));
836  if (!ast)
837  return AVERROR(ENOMEM);
838 
839  /* No need to parse fields for additional independent substreams and its
840  * associated dependent substreams since libavcodec's E-AC-3 decoder
841  * does not support them yet. */
842  avio_rb16(pb); /* data_rate and num_ind_sub */
843  eac3info = avio_rb24(pb);
844  bsmod = (eac3info >> 12) & 0x1f;
845  acmod = (eac3info >> 9) & 0x7;
846  lfeon = (eac3info >> 8) & 0x1;
848  if (lfeon)
851  *ast = bsmod;
852  if (st->codecpar->channels > 1 && bsmod == 0x7)
854 
855 #if FF_API_LAVF_AVCTX
857  st->codec->audio_service_type = *ast;
859 #endif
860 
861  return 0;
862 }
863 
865 {
866 #define DDTS_SIZE 20
868  AVStream *st = NULL;
869  uint32_t frame_duration_code = 0;
870  uint32_t channel_layout_code = 0;
871  GetBitContext gb;
872  int ret;
873 
874  if ((ret = ffio_read_size(pb, buf, DDTS_SIZE)) < 0)
875  return ret;
876 
877  init_get_bits(&gb, buf, 8 * DDTS_SIZE);
878 
879  if (c->fc->nb_streams < 1) {
880  return 0;
881  }
882  st = c->fc->streams[c->fc->nb_streams-1];
883 
884  st->codecpar->sample_rate = get_bits_long(&gb, 32);
885  if (st->codecpar->sample_rate <= 0) {
886  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
887  return AVERROR_INVALIDDATA;
888  }
889  skip_bits_long(&gb, 32); /* max bitrate */
890  st->codecpar->bit_rate = get_bits_long(&gb, 32);
891  st->codecpar->bits_per_coded_sample = get_bits(&gb, 8);
892  frame_duration_code = get_bits(&gb, 2);
893  skip_bits(&gb, 30); /* various fields */
894  channel_layout_code = get_bits(&gb, 16);
895 
896  st->codecpar->frame_size =
897  (frame_duration_code == 0) ? 512 :
898  (frame_duration_code == 1) ? 1024 :
899  (frame_duration_code == 2) ? 2048 :
900  (frame_duration_code == 3) ? 4096 : 0;
901 
902  if (channel_layout_code > 0xff) {
903  av_log(c->fc, AV_LOG_WARNING, "Unsupported DTS audio channel layout\n");
904  }
905  st->codecpar->channel_layout =
906  ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
907  ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
908  ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
909  ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
910  ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
911  ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0);
912 
914 
915  return 0;
916 }
917 
919 {
920  AVStream *st;
921 
922  if (c->fc->nb_streams < 1)
923  return 0;
924  st = c->fc->streams[c->fc->nb_streams-1];
925 
926  if (atom.size < 16)
927  return 0;
928 
929  /* skip version and flags */
930  avio_skip(pb, 4);
931 
932  ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
933 
934  return 0;
935 }
936 
938 {
939  AVStream *st;
940  int ret;
941 
942  if (c->fc->nb_streams < 1)
943  return 0;
944  st = c->fc->streams[c->fc->nb_streams-1];
945 
946  if ((ret = ff_get_wav_header(c->fc, pb, st->codecpar, atom.size, 0)) < 0)
947  av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
948 
949  return ret;
950 }
951 
953 {
954  const int num = avio_rb32(pb);
955  const int den = avio_rb32(pb);
956  AVStream *st;
957 
958  if (c->fc->nb_streams < 1)
959  return 0;
960  st = c->fc->streams[c->fc->nb_streams-1];
961 
962  if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
963  (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
964  av_log(c->fc, AV_LOG_WARNING,
965  "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
967  num, den);
968  } else if (den != 0) {
970  num, den, 32767);
971  }
972  return 0;
973 }
974 
975 /* this atom contains actual media data */
977 {
978  if (atom.size == 0) /* wrong one (MP4) */
979  return 0;
980  c->found_mdat=1;
981  return 0; /* now go for moov */
982 }
983 
984 #define DRM_BLOB_SIZE 56
985 
987 {
988  uint8_t intermediate_key[20];
989  uint8_t intermediate_iv[20];
990  uint8_t input[64];
991  uint8_t output[64];
992  uint8_t file_checksum[20];
993  uint8_t calculated_checksum[20];
994  struct AVSHA *sha;
995  int i;
996  int ret = 0;
997  uint8_t *activation_bytes = c->activation_bytes;
998  uint8_t *fixed_key = c->audible_fixed_key;
999 
1000  c->aax_mode = 1;
1001 
1002  sha = av_sha_alloc();
1003  if (!sha)
1004  return AVERROR(ENOMEM);
1005  av_free(c->aes_decrypt);
1006  c->aes_decrypt = av_aes_alloc();
1007  if (!c->aes_decrypt) {
1008  ret = AVERROR(ENOMEM);
1009  goto fail;
1010  }
1011 
1012  /* drm blob processing */
1013  avio_read(pb, output, 8); // go to offset 8, absolute position 0x251
1014  avio_read(pb, input, DRM_BLOB_SIZE);
1015  avio_read(pb, output, 4); // go to offset 4, absolute position 0x28d
1016  avio_read(pb, file_checksum, 20);
1017 
1018  av_log(c->fc, AV_LOG_INFO, "[aax] file checksum == "); // required by external tools
1019  for (i = 0; i < 20; i++)
1020  av_log(c->fc, AV_LOG_INFO, "%02x", file_checksum[i]);
1021  av_log(c->fc, AV_LOG_INFO, "\n");
1022 
1023  /* verify activation data */
1024  if (!activation_bytes) {
1025  av_log(c->fc, AV_LOG_WARNING, "[aax] activation_bytes option is missing!\n");
1026  ret = 0; /* allow ffprobe to continue working on .aax files */
1027  goto fail;
1028  }
1029  if (c->activation_bytes_size != 4) {
1030  av_log(c->fc, AV_LOG_FATAL, "[aax] activation_bytes value needs to be 4 bytes!\n");
1031  ret = AVERROR(EINVAL);
1032  goto fail;
1033  }
1034 
1035  /* verify fixed key */
1036  if (c->audible_fixed_key_size != 16) {
1037  av_log(c->fc, AV_LOG_FATAL, "[aax] audible_fixed_key value needs to be 16 bytes!\n");
1038  ret = AVERROR(EINVAL);
1039  goto fail;
1040  }
1041 
1042  /* AAX (and AAX+) key derivation */
1043  av_sha_init(sha, 160);
1044  av_sha_update(sha, fixed_key, 16);
1045  av_sha_update(sha, activation_bytes, 4);
1046  av_sha_final(sha, intermediate_key);
1047  av_sha_init(sha, 160);
1048  av_sha_update(sha, fixed_key, 16);
1049  av_sha_update(sha, intermediate_key, 20);
1050  av_sha_update(sha, activation_bytes, 4);
1051  av_sha_final(sha, intermediate_iv);
1052  av_sha_init(sha, 160);
1053  av_sha_update(sha, intermediate_key, 16);
1054  av_sha_update(sha, intermediate_iv, 16);
1055  av_sha_final(sha, calculated_checksum);
1056  if (memcmp(calculated_checksum, file_checksum, 20)) { // critical error
1057  av_log(c->fc, AV_LOG_ERROR, "[aax] mismatch in checksums!\n");
1058  ret = AVERROR_INVALIDDATA;
1059  goto fail;
1060  }
1061  av_aes_init(c->aes_decrypt, intermediate_key, 128, 1);
1062  av_aes_crypt(c->aes_decrypt, output, input, DRM_BLOB_SIZE >> 4, intermediate_iv, 1);
1063  for (i = 0; i < 4; i++) {
1064  // file data (in output) is stored in big-endian mode
1065  if (activation_bytes[i] != output[3 - i]) { // critical error
1066  av_log(c->fc, AV_LOG_ERROR, "[aax] error in drm blob decryption!\n");
1067  ret = AVERROR_INVALIDDATA;
1068  goto fail;
1069  }
1070  }
1071  memcpy(c->file_key, output + 8, 16);
1072  memcpy(input, output + 26, 16);
1073  av_sha_init(sha, 160);
1074  av_sha_update(sha, input, 16);
1075  av_sha_update(sha, c->file_key, 16);
1076  av_sha_update(sha, fixed_key, 16);
1077  av_sha_final(sha, c->file_iv);
1078 
1079 fail:
1080  av_free(sha);
1081 
1082  return ret;
1083 }
1084 
1086 {
1087  if (c->audible_key_size != 16) {
1088  av_log(c->fc, AV_LOG_FATAL, "[aaxc] audible_key value needs to be 16 bytes!\n");
1089  return AVERROR(EINVAL);
1090  }
1091 
1092  if (c->audible_iv_size != 16) {
1093  av_log(c->fc, AV_LOG_FATAL, "[aaxc] audible_iv value needs to be 16 bytes!\n");
1094  return AVERROR(EINVAL);
1095  }
1096 
1097  c->aes_decrypt = av_aes_alloc();
1098  if (!c->aes_decrypt) {
1099  return AVERROR(ENOMEM);
1100  }
1101 
1102  memcpy(c->file_key, c->audible_key, 16);
1103  memcpy(c->file_iv, c->audible_iv, 16);
1104  c->aax_mode = 1;
1105 
1106  return 0;
1107 }
1108 
1109 // Audible AAX (and AAX+) bytestream decryption
1110 static int aax_filter(uint8_t *input, int size, MOVContext *c)
1111 {
1112  int blocks = 0;
1113  unsigned char iv[16];
1114 
1115  memcpy(iv, c->file_iv, 16); // iv is overwritten
1116  blocks = size >> 4; // trailing bytes are not encrypted!
1117  av_aes_init(c->aes_decrypt, c->file_key, 128, 1);
1118  av_aes_crypt(c->aes_decrypt, input, input, blocks, iv, 1);
1119 
1120  return 0;
1121 }
1122 
1123 /* read major brand, minor version and compatible brands and store them as metadata */
1125 {
1126  uint32_t minor_ver;
1127  int comp_brand_size;
1128  char* comp_brands_str;
1129  uint8_t type[5] = {0};
1130  int ret = ffio_read_size(pb, type, 4);
1131  if (ret < 0)
1132  return ret;
1133 
1134  if (strcmp(type, "qt "))
1135  c->isom = 1;
1136  av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
1137  av_dict_set(&c->fc->metadata, "major_brand", type, 0);
1138  minor_ver = avio_rb32(pb); /* minor version */
1139  av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
1140 
1141  comp_brand_size = atom.size - 8;
1142  if (comp_brand_size < 0 || comp_brand_size == INT_MAX)
1143  return AVERROR_INVALIDDATA;
1144  comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
1145  if (!comp_brands_str)
1146  return AVERROR(ENOMEM);
1147 
1148  ret = ffio_read_size(pb, comp_brands_str, comp_brand_size);
1149  if (ret < 0) {
1150  av_freep(&comp_brands_str);
1151  return ret;
1152  }
1153  comp_brands_str[comp_brand_size] = 0;
1154  av_dict_set(&c->fc->metadata, "compatible_brands",
1155  comp_brands_str, AV_DICT_DONT_STRDUP_VAL);
1156 
1157  // Logic for handling Audible's .aaxc files
1158  if (!strcmp(type, "aaxc")) {
1159  mov_aaxc_crypto(c);
1160  }
1161 
1162  return 0;
1163 }
1164 
1165 /* this atom should contain all header atoms */
1167 {
1168  int ret;
1169 
1170  if (c->found_moov) {
1171  av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
1172  avio_skip(pb, atom.size);
1173  return 0;
1174  }
1175 
1176  if ((ret = mov_read_default(c, pb, atom)) < 0)
1177  return ret;
1178  /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
1179  /* so we don't parse the whole file if over a network */
1180  c->found_moov=1;
1181  return 0; /* now go for mdat */
1182 }
1183 
1185  MOVFragmentIndex *frag_index,
1186  int index,
1187  int id)
1188 {
1189  int i;
1190  MOVFragmentIndexItem * item;
1191 
1192  if (index < 0 || index >= frag_index->nb_items)
1193  return NULL;
1194  item = &frag_index->item[index];
1195  for (i = 0; i < item->nb_stream_info; i++)
1196  if (item->stream_info[i].id == id)
1197  return &item->stream_info[i];
1198 
1199  // This shouldn't happen
1200  return NULL;
1201 }
1202 
1203 static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
1204 {
1205  int i;
1206  MOVFragmentIndexItem * item;
1207 
1208  if (frag_index->current < 0 ||
1209  frag_index->current >= frag_index->nb_items)
1210  return;
1211 
1212  item = &frag_index->item[frag_index->current];
1213  for (i = 0; i < item->nb_stream_info; i++)
1214  if (item->stream_info[i].id == id) {
1215  item->current = i;
1216  return;
1217  }
1218 
1219  // id not found. This shouldn't happen.
1220  item->current = -1;
1221 }
1222 
1224  MOVFragmentIndex *frag_index)
1225 {
1226  MOVFragmentIndexItem *item;
1227  if (frag_index->current < 0 ||
1228  frag_index->current >= frag_index->nb_items)
1229  return NULL;
1230 
1231  item = &frag_index->item[frag_index->current];
1232  if (item->current >= 0 && item->current < item->nb_stream_info)
1233  return &item->stream_info[item->current];
1234 
1235  // This shouldn't happen
1236  return NULL;
1237 }
1238 
1239 static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
1240 {
1241  int a, b, m;
1242  int64_t moof_offset;
1243 
1244  // Optimize for appending new entries
1245  if (!frag_index->nb_items ||
1246  frag_index->item[frag_index->nb_items - 1].moof_offset < offset)
1247  return frag_index->nb_items;
1248 
1249  a = -1;
1250  b = frag_index->nb_items;
1251 
1252  while (b - a > 1) {
1253  m = (a + b) >> 1;
1254  moof_offset = frag_index->item[m].moof_offset;
1255  if (moof_offset >= offset)
1256  b = m;
1257  if (moof_offset <= offset)
1258  a = m;
1259  }
1260  return b;
1261 }
1262 
1263 static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
1264 {
1265  av_assert0(frag_stream_info);
1266  if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1267  return frag_stream_info->sidx_pts;
1268  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1269  return frag_stream_info->first_tfra_pts;
1270  return frag_stream_info->tfdt_dts;
1271 }
1272 
1273 static int64_t get_frag_time(MOVFragmentIndex *frag_index,
1274  int index, int track_id)
1275 {
1276  MOVFragmentStreamInfo * frag_stream_info;
1277  int64_t timestamp;
1278  int i;
1279 
1280  if (track_id >= 0) {
1281  frag_stream_info = get_frag_stream_info(frag_index, index, track_id);
1282  if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1283  return frag_stream_info->sidx_pts;
1284  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1285  return frag_stream_info->first_tfra_pts;
1286  return frag_stream_info->sidx_pts;
1287  }
1288 
1289  for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
1290  frag_stream_info = &frag_index->item[index].stream_info[i];
1291  timestamp = get_stream_info_time(frag_stream_info);
1292  if (timestamp != AV_NOPTS_VALUE)
1293  return timestamp;
1294  }
1295  return AV_NOPTS_VALUE;
1296 }
1297 
1299  AVStream *st, int64_t timestamp)
1300 {
1301  int a, b, m, m0;
1302  int64_t frag_time;
1303  int id = -1;
1304 
1305  if (st) {
1306  // If the stream is referenced by any sidx, limit the search
1307  // to fragments that referenced this stream in the sidx
1308  MOVStreamContext *sc = st->priv_data;
1309  if (sc->has_sidx)
1310  id = st->id;
1311  }
1312 
1313  a = -1;
1314  b = frag_index->nb_items;
1315 
1316  while (b - a > 1) {
1317  m0 = m = (a + b) >> 1;
1318 
1319  while (m < b &&
1320  (frag_time = get_frag_time(frag_index, m, id)) == AV_NOPTS_VALUE)
1321  m++;
1322 
1323  if (m < b && frag_time <= timestamp)
1324  a = m;
1325  else
1326  b = m0;
1327  }
1328 
1329  return a;
1330 }
1331 
1332 static int update_frag_index(MOVContext *c, int64_t offset)
1333 {
1334  int index, i;
1335  MOVFragmentIndexItem * item;
1336  MOVFragmentStreamInfo * frag_stream_info;
1337 
1338  // If moof_offset already exists in frag_index, return index to it
1339  index = search_frag_moof_offset(&c->frag_index, offset);
1340  if (index < c->frag_index.nb_items &&
1341  c->frag_index.item[index].moof_offset == offset)
1342  return index;
1343 
1344  // offset is not yet in frag index.
1345  // Insert new item at index (sorted by moof offset)
1346  item = av_fast_realloc(c->frag_index.item,
1347  &c->frag_index.allocated_size,
1348  (c->frag_index.nb_items + 1) *
1349  sizeof(*c->frag_index.item));
1350  if (!item)
1351  return -1;
1352  c->frag_index.item = item;
1353 
1354  frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
1355  sizeof(*item->stream_info));
1356  if (!frag_stream_info)
1357  return -1;
1358 
1359  for (i = 0; i < c->fc->nb_streams; i++) {
1360  // Avoid building frag index if streams lack track id.
1361  if (c->fc->streams[i]->id < 0) {
1362  av_free(frag_stream_info);
1363  return AVERROR_INVALIDDATA;
1364  }
1365 
1366  frag_stream_info[i].id = c->fc->streams[i]->id;
1367  frag_stream_info[i].sidx_pts = AV_NOPTS_VALUE;
1368  frag_stream_info[i].tfdt_dts = AV_NOPTS_VALUE;
1369  frag_stream_info[i].next_trun_dts = AV_NOPTS_VALUE;
1370  frag_stream_info[i].first_tfra_pts = AV_NOPTS_VALUE;
1371  frag_stream_info[i].index_entry = -1;
1372  frag_stream_info[i].encryption_index = NULL;
1373  }
1374 
1375  if (index < c->frag_index.nb_items)
1376  memmove(c->frag_index.item + index + 1, c->frag_index.item + index,
1377  (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
1378 
1379  item = &c->frag_index.item[index];
1380  item->headers_read = 0;
1381  item->current = 0;
1382  item->nb_stream_info = c->fc->nb_streams;
1383  item->moof_offset = offset;
1384  item->stream_info = frag_stream_info;
1385  c->frag_index.nb_items++;
1386 
1387  return index;
1388 }
1389 
1390 static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
1391  int id, int entries)
1392 {
1393  int i;
1394  MOVFragmentStreamInfo * frag_stream_info;
1395 
1396  if (index < 0)
1397  return;
1398  for (i = index; i < frag_index->nb_items; i++) {
1399  frag_stream_info = get_frag_stream_info(frag_index, i, id);
1400  if (frag_stream_info && frag_stream_info->index_entry >= 0)
1401  frag_stream_info->index_entry += entries;
1402  }
1403 }
1404 
1406 {
1407  // Set by mov_read_tfhd(). mov_read_trun() will reject files missing tfhd.
1408  c->fragment.found_tfhd = 0;
1409 
1410  if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
1411  c->has_looked_for_mfra = 1;
1412  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1413  int ret;
1414  av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
1415  "for a mfra\n");
1416  if ((ret = mov_read_mfra(c, pb)) < 0) {
1417  av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
1418  "read the mfra (may be a live ismv)\n");
1419  }
1420  } else {
1421  av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
1422  "seekable, can not look for mfra\n");
1423  }
1424  }
1425  c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8;
1426  av_log(c->fc, AV_LOG_TRACE, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
1427  c->frag_index.current = update_frag_index(c, c->fragment.moof_offset);
1428  return mov_read_default(c, pb, atom);
1429 }
1430 
1431 static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time, void *logctx)
1432 {
1433  if (time) {
1434  if (time >= 2082844800)
1435  time -= 2082844800; /* seconds between 1904-01-01 and Epoch */
1436 
1437  if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
1438  av_log(logctx, AV_LOG_DEBUG, "creation_time is not representable\n");
1439  return;
1440  }
1441 
1442  avpriv_dict_set_timestamp(metadata, "creation_time", time * 1000000);
1443  }
1444 }
1445 
1447 {
1448  AVStream *st;
1449  MOVStreamContext *sc;
1450  int version;
1451  char language[4] = {0};
1452  unsigned lang;
1453  int64_t creation_time;
1454 
1455  if (c->fc->nb_streams < 1)
1456  return 0;
1457  st = c->fc->streams[c->fc->nb_streams-1];
1458  sc = st->priv_data;
1459 
1460  if (sc->time_scale) {
1461  av_log(c->fc, AV_LOG_ERROR, "Multiple mdhd?\n");
1462  return AVERROR_INVALIDDATA;
1463  }
1464 
1465  version = avio_r8(pb);
1466  if (version > 1) {
1467  avpriv_request_sample(c->fc, "Version %d", version);
1468  return AVERROR_PATCHWELCOME;
1469  }
1470  avio_rb24(pb); /* flags */
1471  if (version == 1) {
1472  creation_time = avio_rb64(pb);
1473  avio_rb64(pb);
1474  } else {
1475  creation_time = avio_rb32(pb);
1476  avio_rb32(pb); /* modification time */
1477  }
1478  mov_metadata_creation_time(&st->metadata, creation_time, c->fc);
1479 
1480  sc->time_scale = avio_rb32(pb);
1481  if (sc->time_scale <= 0) {
1482  av_log(c->fc, AV_LOG_ERROR, "Invalid mdhd time scale %d, defaulting to 1\n", sc->time_scale);
1483  sc->time_scale = 1;
1484  }
1485  st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1486 
1487  lang = avio_rb16(pb); /* language */
1488  if (ff_mov_lang_to_iso639(lang, language))
1489  av_dict_set(&st->metadata, "language", language, 0);
1490  avio_rb16(pb); /* quality */
1491 
1492  return 0;
1493 }
1494 
1496 {
1497  int i;
1498  int64_t creation_time;
1499  int version = avio_r8(pb); /* version */
1500  avio_rb24(pb); /* flags */
1501 
1502  if (version == 1) {
1503  creation_time = avio_rb64(pb);
1504  avio_rb64(pb);
1505  } else {
1506  creation_time = avio_rb32(pb);
1507  avio_rb32(pb); /* modification time */
1508  }
1509  mov_metadata_creation_time(&c->fc->metadata, creation_time, c->fc);
1510  c->time_scale = avio_rb32(pb); /* time scale */
1511  if (c->time_scale <= 0) {
1512  av_log(c->fc, AV_LOG_ERROR, "Invalid mvhd time scale %d, defaulting to 1\n", c->time_scale);
1513  c->time_scale = 1;
1514  }
1515  av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale);
1516 
1517  c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1518  // set the AVFormatContext duration because the duration of individual tracks
1519  // may be inaccurate
1520  if (!c->trex_data)
1521  c->fc->duration = av_rescale(c->duration, AV_TIME_BASE, c->time_scale);
1522  avio_rb32(pb); /* preferred scale */
1523 
1524  avio_rb16(pb); /* preferred volume */
1525 
1526  avio_skip(pb, 10); /* reserved */
1527 
1528  /* movie display matrix, store it in main context and use it later on */
1529  for (i = 0; i < 3; i++) {
1530  c->movie_display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
1531  c->movie_display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
1532  c->movie_display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
1533  }
1534 
1535  avio_rb32(pb); /* preview time */
1536  avio_rb32(pb); /* preview duration */
1537  avio_rb32(pb); /* poster time */
1538  avio_rb32(pb); /* selection time */
1539  avio_rb32(pb); /* selection duration */
1540  avio_rb32(pb); /* current time */
1541  avio_rb32(pb); /* next track ID */
1542 
1543  return 0;
1544 }
1545 
1547 {
1548  AVStream *st;
1549  int little_endian;
1550 
1551  if (c->fc->nb_streams < 1)
1552  return 0;
1553  st = c->fc->streams[c->fc->nb_streams-1];
1554 
1555  little_endian = avio_rb16(pb) & 0xFF;
1556  av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian);
1557  if (little_endian == 1) {
1558  switch (st->codecpar->codec_id) {
1559  case AV_CODEC_ID_PCM_S24BE:
1561  break;
1562  case AV_CODEC_ID_PCM_S32BE:
1564  break;
1565  case AV_CODEC_ID_PCM_F32BE:
1567  break;
1568  case AV_CODEC_ID_PCM_F64BE:
1570  break;
1571  default:
1572  break;
1573  }
1574  }
1575  return 0;
1576 }
1577 
1579 {
1580  AVStream *st;
1581  uint8_t *icc_profile;
1582  char color_parameter_type[5] = { 0 };
1583  uint16_t color_primaries, color_trc, color_matrix;
1584  int ret;
1585 
1586  if (c->fc->nb_streams < 1)
1587  return 0;
1588  st = c->fc->streams[c->fc->nb_streams - 1];
1589 
1590  ret = ffio_read_size(pb, color_parameter_type, 4);
1591  if (ret < 0)
1592  return ret;
1593  if (strncmp(color_parameter_type, "nclx", 4) &&
1594  strncmp(color_parameter_type, "nclc", 4) &&
1595  strncmp(color_parameter_type, "prof", 4)) {
1596  av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
1597  color_parameter_type);
1598  return 0;
1599  }
1600 
1601  if (!strncmp(color_parameter_type, "prof", 4)) {
1602  icc_profile = av_stream_new_side_data(st, AV_PKT_DATA_ICC_PROFILE, atom.size - 4);
1603  if (!icc_profile)
1604  return AVERROR(ENOMEM);
1605  ret = ffio_read_size(pb, icc_profile, atom.size - 4);
1606  if (ret < 0)
1607  return ret;
1608  } else {
1609  color_primaries = avio_rb16(pb);
1610  color_trc = avio_rb16(pb);
1611  color_matrix = avio_rb16(pb);
1612 
1613  av_log(c->fc, AV_LOG_TRACE,
1614  "%s: pri %d trc %d matrix %d",
1615  color_parameter_type, color_primaries, color_trc, color_matrix);
1616 
1617  if (!strncmp(color_parameter_type, "nclx", 4)) {
1618  uint8_t color_range = avio_r8(pb) >> 7;
1619  av_log(c->fc, AV_LOG_TRACE, " full %"PRIu8"", color_range);
1620  if (color_range)
1622  else
1624  }
1625 
1628  if (!av_color_transfer_name(color_trc))
1629  color_trc = AVCOL_TRC_UNSPECIFIED;
1630  if (!av_color_space_name(color_matrix))
1631  color_matrix = AVCOL_SPC_UNSPECIFIED;
1632 
1634  st->codecpar->color_trc = color_trc;
1635  st->codecpar->color_space = color_matrix;
1636  av_log(c->fc, AV_LOG_TRACE, "\n");
1637  }
1638  return 0;
1639 }
1640 
1642 {
1643  AVStream *st;
1644  unsigned mov_field_order;
1645  enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
1646 
1647  if (c->fc->nb_streams < 1) // will happen with jp2 files
1648  return 0;
1649  st = c->fc->streams[c->fc->nb_streams-1];
1650  if (atom.size < 2)
1651  return AVERROR_INVALIDDATA;
1652  mov_field_order = avio_rb16(pb);
1653  if ((mov_field_order & 0xFF00) == 0x0100)
1654  decoded_field_order = AV_FIELD_PROGRESSIVE;
1655  else if ((mov_field_order & 0xFF00) == 0x0200) {
1656  switch (mov_field_order & 0xFF) {
1657  case 0x01: decoded_field_order = AV_FIELD_TT;
1658  break;
1659  case 0x06: decoded_field_order = AV_FIELD_BB;
1660  break;
1661  case 0x09: decoded_field_order = AV_FIELD_TB;
1662  break;
1663  case 0x0E: decoded_field_order = AV_FIELD_BT;
1664  break;
1665  }
1666  }
1667  if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
1668  av_log(c->fc, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
1669  }
1670  st->codecpar->field_order = decoded_field_order;
1671 
1672  return 0;
1673 }
1674 
1676 {
1677  int err = 0;
1678  uint64_t size = (uint64_t)par->extradata_size + atom.size + 8 + AV_INPUT_BUFFER_PADDING_SIZE;
1679  if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
1680  return AVERROR_INVALIDDATA;
1681  if ((err = av_reallocp(&par->extradata, size)) < 0) {
1682  par->extradata_size = 0;
1683  return err;
1684  }
1686  return 0;
1687 }
1688 
1689 /* Read a whole atom into the extradata return the size of the atom read, possibly truncated if != atom.size */
1691  AVCodecParameters *par, uint8_t *buf)
1692 {
1693  int64_t result = atom.size;
1694  int err;
1695 
1696  AV_WB32(buf , atom.size + 8);
1697  AV_WL32(buf + 4, atom.type);
1698  err = ffio_read_size(pb, buf + 8, atom.size);
1699  if (err < 0) {
1700  par->extradata_size -= atom.size;
1701  return err;
1702  } else if (err < atom.size) {
1703  av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
1704  par->extradata_size -= atom.size - err;
1705  result = err;
1706  }
1707  memset(buf + 8 + err, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1708  return result;
1709 }
1710 
1711 /* FIXME modify QDM2/SVQ3/H.264 decoders to take full atom as extradata */
1713  enum AVCodecID codec_id)
1714 {
1715  AVStream *st;
1716  uint64_t original_size;
1717  int err;
1718 
1719  if (c->fc->nb_streams < 1) // will happen with jp2 files
1720  return 0;
1721  st = c->fc->streams[c->fc->nb_streams-1];
1722 
1723  if (st->codecpar->codec_id != codec_id)
1724  return 0; /* unexpected codec_id - don't mess with extradata */
1725 
1726  original_size = st->codecpar->extradata_size;
1727  err = mov_realloc_extradata(st->codecpar, atom);
1728  if (err)
1729  return err;
1730 
1731  err = mov_read_atom_into_extradata(c, pb, atom, st->codecpar, st->codecpar->extradata + original_size);
1732  if (err < 0)
1733  return err;
1734  return 0; // Note: this is the original behavior to ignore truncation.
1735 }
1736 
1737 /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
1739 {
1740  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
1741 }
1742 
1744 {
1745  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
1746 }
1747 
1749 {
1750  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
1751 }
1752 
1754 {
1755  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
1756 }
1757 
1759 {
1760  int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
1761  if (!ret)
1762  ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_DNXHD);
1763  return ret;
1764 }
1765 
1767 {
1768  int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
1769 
1770  if (!ret && c->fc->nb_streams >= 1) {
1771  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1772  if (par->extradata_size >= 40) {
1773  par->height = AV_RB16(&par->extradata[36]);
1774  par->width = AV_RB16(&par->extradata[38]);
1775  }
1776  }
1777  return ret;
1778 }
1779 
1781 {
1782  if (c->fc->nb_streams >= 1) {
1783  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1784  if (par->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
1785  par->codec_id == AV_CODEC_ID_H264 &&
1786  atom.size > 11) {
1787  int cid;
1788  avio_skip(pb, 10);
1789  cid = avio_rb16(pb);
1790  /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
1791  if (cid == 0xd4d || cid == 0xd4e)
1792  par->width = 1440;
1793  return 0;
1794  } else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
1795  par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
1796  par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
1797  atom.size >= 24) {
1798  int num, den;
1799  avio_skip(pb, 12);
1800  num = avio_rb32(pb);
1801  den = avio_rb32(pb);
1802  if (num <= 0 || den <= 0)
1803  return 0;
1804  switch (avio_rb32(pb)) {
1805  case 2:
1806  if (den >= INT_MAX / 2)
1807  return 0;
1808  den *= 2;
1809  case 1:
1810  c->fc->streams[c->fc->nb_streams-1]->internal->display_aspect_ratio.num = num;
1811  c->fc->streams[c->fc->nb_streams-1]->internal->display_aspect_ratio.den = den;
1812  default:
1813  return 0;
1814  }
1815  }
1816  }
1817 
1818  return mov_read_avid(c, pb, atom);
1819 }
1820 
1822 {
1823  int ret = 0;
1824  int length = 0;
1825  uint64_t original_size;
1826  if (c->fc->nb_streams >= 1) {
1827  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1828  if (par->codec_id == AV_CODEC_ID_H264)
1829  return 0;
1830  if (atom.size == 16) {
1831  original_size = par->extradata_size;
1832  ret = mov_realloc_extradata(par, atom);
1833  if (!ret) {
1834  length = mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
1835  if (length == atom.size) {
1836  const uint8_t range_value = par->extradata[original_size + 19];
1837  switch (range_value) {
1838  case 1:
1840  break;
1841  case 2:
1843  break;
1844  default:
1845  av_log(c->fc, AV_LOG_WARNING, "ignored unknown aclr value (%d)\n", range_value);
1846  break;
1847  }
1848  ff_dlog(c->fc, "color_range: %d\n", par->color_range);
1849  } else {
1850  /* For some reason the whole atom was not added to the extradata */
1851  av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
1852  }
1853  } else {
1854  av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - unable to add atom to extradata\n");
1855  }
1856  } else {
1857  av_log(c->fc, AV_LOG_WARNING, "aclr not decoded - unexpected size %"PRId64"\n", atom.size);
1858  }
1859  }
1860 
1861  return ret;
1862 }
1863 
1865 {
1866  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
1867 }
1868 
1870 {
1871  AVStream *st;
1872  int ret;
1873 
1874  if (c->fc->nb_streams < 1)
1875  return 0;
1876  st = c->fc->streams[c->fc->nb_streams-1];
1877 
1878  if ((uint64_t)atom.size > (1<<30))
1879  return AVERROR_INVALIDDATA;
1880 
1881  if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
1884  // pass all frma atom to codec, needed at least for QDMC and QDM2
1885  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1886  if (ret < 0)
1887  return ret;
1888  } else if (atom.size > 8) { /* to read frma, esds atoms */
1889  if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
1890  uint64_t buffer;
1891  ret = ffio_ensure_seekback(pb, 8);
1892  if (ret < 0)
1893  return ret;
1894  buffer = avio_rb64(pb);
1895  atom.size -= 8;
1896  if ( (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
1897  && buffer >> 32 <= atom.size
1898  && buffer >> 32 >= 8) {
1899  avio_skip(pb, -8);
1900  atom.size += 8;
1901  } else if (!st->codecpar->extradata_size) {
1902 #define ALAC_EXTRADATA_SIZE 36
1904  if (!st->codecpar->extradata)
1905  return AVERROR(ENOMEM);
1908  AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
1909  AV_WB64(st->codecpar->extradata + 12, buffer);
1910  avio_read(pb, st->codecpar->extradata + 20, 16);
1911  avio_skip(pb, atom.size - 24);
1912  return 0;
1913  }
1914  }
1915  if ((ret = mov_read_default(c, pb, atom)) < 0)
1916  return ret;
1917  } else
1918  avio_skip(pb, atom.size);
1919  return 0;
1920 }
1921 
1922 /**
1923  * This function reads atom content and puts data in extradata without tag
1924  * nor size unlike mov_read_extradata.
1925  */
1927 {
1928  AVStream *st;
1929  int ret;
1930 
1931  if (c->fc->nb_streams < 1)
1932  return 0;
1933  st = c->fc->streams[c->fc->nb_streams-1];
1934 
1935  if ((uint64_t)atom.size > (1<<30))
1936  return AVERROR_INVALIDDATA;
1937 
1938  if (atom.size >= 10) {
1939  // Broken files created by legacy versions of libavformat will
1940  // wrap a whole fiel atom inside of a glbl atom.
1941  unsigned size = avio_rb32(pb);
1942  unsigned type = avio_rl32(pb);
1943  avio_seek(pb, -8, SEEK_CUR);
1944  if (type == MKTAG('f','i','e','l') && size == atom.size)
1945  return mov_read_default(c, pb, atom);
1946  }
1947  if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
1948  av_log(c->fc, AV_LOG_WARNING, "ignoring multiple glbl\n");
1949  return 0;
1950  }
1951  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1952  if (ret < 0)
1953  return ret;
1954  if (atom.type == MKTAG('h','v','c','C') && st->codecpar->codec_tag == MKTAG('d','v','h','1'))
1955  /* HEVC-based Dolby Vision derived from hvc1.
1956  Happens to match with an identifier
1957  previously utilized for DV. Thus, if we have
1958  the hvcC extradata box available as specified,
1959  set codec to HEVC */
1961 
1962  return 0;
1963 }
1964 
1966 {
1967  AVStream *st;
1968  uint8_t profile_level;
1969  int ret;
1970 
1971  if (c->fc->nb_streams < 1)
1972  return 0;
1973  st = c->fc->streams[c->fc->nb_streams-1];
1974 
1975  if (atom.size >= (1<<28) || atom.size < 7)
1976  return AVERROR_INVALIDDATA;
1977 
1978  profile_level = avio_r8(pb);
1979  if ((profile_level & 0xf0) != 0xc0)
1980  return 0;
1981 
1982  avio_seek(pb, 6, SEEK_CUR);
1983  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 7);
1984  if (ret < 0)
1985  return ret;
1986 
1987  return 0;
1988 }
1989 
1990 /**
1991  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
1992  * but can have extradata appended at the end after the 40 bytes belonging
1993  * to the struct.
1994  */
1996 {
1997  AVStream *st;
1998  int ret;
1999 
2000  if (c->fc->nb_streams < 1)
2001  return 0;
2002  if (atom.size <= 40)
2003  return 0;
2004  st = c->fc->streams[c->fc->nb_streams-1];
2005 
2006  if ((uint64_t)atom.size > (1<<30))
2007  return AVERROR_INVALIDDATA;
2008 
2009  avio_skip(pb, 40);
2010  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 40);
2011  if (ret < 0)
2012  return ret;
2013 
2014  return 0;
2015 }
2016 
2018 {
2019  AVStream *st;
2020  MOVStreamContext *sc;
2021  unsigned int i, entries;
2022 
2023  if (c->trak_index < 0) {
2024  av_log(c->fc, AV_LOG_WARNING, "STCO outside TRAK\n");
2025  return 0;
2026  }
2027  if (c->fc->nb_streams < 1)
2028  return 0;
2029  st = c->fc->streams[c->fc->nb_streams-1];
2030  sc = st->priv_data;
2031 
2032  avio_r8(pb); /* version */
2033  avio_rb24(pb); /* flags */
2034 
2035  entries = avio_rb32(pb);
2036 
2037  if (!entries)
2038  return 0;
2039 
2040  if (sc->chunk_offsets) {
2041  av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicated STCO atom\n");
2042  return 0;
2043  }
2044  av_free(sc->chunk_offsets);
2045  sc->chunk_count = 0;
2046  sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2047  if (!sc->chunk_offsets)
2048  return AVERROR(ENOMEM);
2049  sc->chunk_count = entries;
2050 
2051  if (atom.type == MKTAG('s','t','c','o'))
2052  for (i = 0; i < entries && !pb->eof_reached; i++)
2053  sc->chunk_offsets[i] = avio_rb32(pb);
2054  else if (atom.type == MKTAG('c','o','6','4'))
2055  for (i = 0; i < entries && !pb->eof_reached; i++)
2056  sc->chunk_offsets[i] = avio_rb64(pb);
2057  else
2058  return AVERROR_INVALIDDATA;
2059 
2060  sc->chunk_count = i;
2061 
2062  if (pb->eof_reached) {
2063  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STCO atom\n");
2064  return AVERROR_EOF;
2065  }
2066 
2067  return 0;
2068 }
2069 
2070 static int mov_codec_id(AVStream *st, uint32_t format)
2071 {
2073 
2074  if (id <= 0 &&
2075  ((format & 0xFFFF) == 'm' + ('s' << 8) ||
2076  (format & 0xFFFF) == 'T' + ('S' << 8)))
2078 
2079  if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
2081  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
2082  /* skip old ASF MPEG-4 tag */
2083  format && format != MKTAG('m','p','4','s')) {
2085  if (id <= 0)
2087  if (id > 0)
2089  else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
2091  st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
2093  if (id > 0)
2095  else
2097  }
2098  }
2099 
2100  st->codecpar->codec_tag = format;
2101 
2102  return id;
2103 }
2104 
2106  AVStream *st, MOVStreamContext *sc)
2107 {
2108  uint8_t codec_name[32] = { 0 };
2109  int64_t stsd_start;
2110  unsigned int len;
2111  uint32_t id = 0;
2112 
2113  /* The first 16 bytes of the video sample description are already
2114  * read in ff_mov_read_stsd_entries() */
2115  stsd_start = avio_tell(pb) - 16;
2116 
2117  avio_rb16(pb); /* version */
2118  avio_rb16(pb); /* revision level */
2119  id = avio_rl32(pb); /* vendor */
2120  av_dict_set(&st->metadata, "vendor_id", av_fourcc2str(id), 0);
2121  avio_rb32(pb); /* temporal quality */
2122  avio_rb32(pb); /* spatial quality */
2123 
2124  st->codecpar->width = avio_rb16(pb); /* width */
2125  st->codecpar->height = avio_rb16(pb); /* height */
2126 
2127  avio_rb32(pb); /* horiz resolution */
2128  avio_rb32(pb); /* vert resolution */
2129  avio_rb32(pb); /* data size, always 0 */
2130  avio_rb16(pb); /* frames per samples */
2131 
2132  len = avio_r8(pb); /* codec name, pascal string */
2133  if (len > 31)
2134  len = 31;
2135  mov_read_mac_string(c, pb, len, codec_name, sizeof(codec_name));
2136  if (len < 31)
2137  avio_skip(pb, 31 - len);
2138 
2139  if (codec_name[0])
2140  av_dict_set(&st->metadata, "encoder", codec_name, 0);
2141 
2142  /* codec_tag YV12 triggers an UV swap in rawdec.c */
2143  if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
2144  st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
2145  st->codecpar->width &= ~1;
2146  st->codecpar->height &= ~1;
2147  }
2148  /* Flash Media Server uses tag H.263 with Sorenson Spark */
2149  if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
2150  !strncmp(codec_name, "Sorenson H263", 13))
2152 
2153  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
2154 
2155  avio_seek(pb, stsd_start, SEEK_SET);
2156 
2157  if (ff_get_qtpalette(st->codecpar->codec_id, pb, sc->palette)) {
2158  st->codecpar->bits_per_coded_sample &= 0x1F;
2159  sc->has_palette = 1;
2160  }
2161 }
2162 
2164  AVStream *st, MOVStreamContext *sc)
2165 {
2166  int bits_per_sample, flags;
2167  uint16_t version = avio_rb16(pb);
2168  uint32_t id = 0;
2169  AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
2170 
2171  avio_rb16(pb); /* revision level */
2172  id = avio_rl32(pb); /* vendor */
2173  av_dict_set(&st->metadata, "vendor_id", av_fourcc2str(id), 0);
2174 
2175  st->codecpar->channels = avio_rb16(pb); /* channel count */
2176  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* sample size */
2177  av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codecpar->channels);
2178 
2179  sc->audio_cid = avio_rb16(pb);
2180  avio_rb16(pb); /* packet size = 0 */
2181 
2182  st->codecpar->sample_rate = ((avio_rb32(pb) >> 16));
2183 
2184  // Read QT version 1 fields. In version 0 these do not exist.
2185  av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom);
2186  if (!c->isom ||
2187  (compatible_brands && strstr(compatible_brands->value, "qt ")) ||
2188  (sc->stsd_version == 0 && version > 0)) {
2189  if (version == 1) {
2190  sc->samples_per_frame = avio_rb32(pb);
2191  avio_rb32(pb); /* bytes per packet */
2192  sc->bytes_per_frame = avio_rb32(pb);
2193  avio_rb32(pb); /* bytes per sample */
2194  } else if (version == 2) {
2195  avio_rb32(pb); /* sizeof struct only */
2197  st->codecpar->channels = avio_rb32(pb);
2198  avio_rb32(pb); /* always 0x7F000000 */
2200 
2201  flags = avio_rb32(pb); /* lpcm format specific flag */
2202  sc->bytes_per_frame = avio_rb32(pb);
2203  sc->samples_per_frame = avio_rb32(pb);
2204  if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
2205  st->codecpar->codec_id =
2207  flags);
2208  }
2209  if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
2210  /* can't correctly handle variable sized packet as audio unit */
2211  switch (st->codecpar->codec_id) {
2212  case AV_CODEC_ID_MP2:
2213  case AV_CODEC_ID_MP3:
2215  break;
2216  }
2217  }
2218  }
2219 
2220  if (sc->format == 0) {
2221  if (st->codecpar->bits_per_coded_sample == 8)
2222  st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
2223  else if (st->codecpar->bits_per_coded_sample == 16)
2224  st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
2225  }
2226 
2227  switch (st->codecpar->codec_id) {
2228  case AV_CODEC_ID_PCM_S8:
2229  case AV_CODEC_ID_PCM_U8:
2230  if (st->codecpar->bits_per_coded_sample == 16)
2232  break;
2233  case AV_CODEC_ID_PCM_S16LE:
2234  case AV_CODEC_ID_PCM_S16BE:
2235  if (st->codecpar->bits_per_coded_sample == 8)
2237  else if (st->codecpar->bits_per_coded_sample == 24)
2238  st->codecpar->codec_id =
2241  else if (st->codecpar->bits_per_coded_sample == 32)
2242  st->codecpar->codec_id =
2245  break;
2246  /* set values for old format before stsd version 1 appeared */
2247  case AV_CODEC_ID_MACE3:
2248  sc->samples_per_frame = 6;
2249  sc->bytes_per_frame = 2 * st->codecpar->channels;
2250  break;
2251  case AV_CODEC_ID_MACE6:
2252  sc->samples_per_frame = 6;
2253  sc->bytes_per_frame = 1 * st->codecpar->channels;
2254  break;
2256  sc->samples_per_frame = 64;
2257  sc->bytes_per_frame = 34 * st->codecpar->channels;
2258  break;
2259  case AV_CODEC_ID_GSM:
2260  sc->samples_per_frame = 160;
2261  sc->bytes_per_frame = 33;
2262  break;
2263  default:
2264  break;
2265  }
2266 
2267  bits_per_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2268  if (bits_per_sample && (bits_per_sample >> 3) * (uint64_t)st->codecpar->channels <= INT_MAX) {
2269  st->codecpar->bits_per_coded_sample = bits_per_sample;
2270  sc->sample_size = (bits_per_sample >> 3) * st->codecpar->channels;
2271  }
2272 }
2273 
2275  AVStream *st, MOVStreamContext *sc,
2276  int64_t size)
2277 {
2278  // ttxt stsd contains display flags, justification, background
2279  // color, fonts, and default styles, so fake an atom to read it
2280  MOVAtom fake_atom = { .size = size };
2281  // mp4s contains a regular esds atom
2282  if (st->codecpar->codec_tag != AV_RL32("mp4s"))
2283  mov_read_glbl(c, pb, fake_atom);
2284  st->codecpar->width = sc->width;
2285  st->codecpar->height = sc->height;
2286 }
2287 
2288 static uint32_t yuv_to_rgba(uint32_t ycbcr)
2289 {
2290  uint8_t r, g, b;
2291  int y, cb, cr;
2292 
2293  y = (ycbcr >> 16) & 0xFF;
2294  cr = (ycbcr >> 8) & 0xFF;
2295  cb = ycbcr & 0xFF;
2296 
2297  b = av_clip_uint8((1164 * (y - 16) + 2018 * (cb - 128)) / 1000);
2298  g = av_clip_uint8((1164 * (y - 16) - 813 * (cr - 128) - 391 * (cb - 128)) / 1000);
2299  r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128) ) / 1000);
2300 
2301  return (r << 16) | (g << 8) | b;
2302 }
2303 
2305 {
2306  char buf[256] = {0};
2307  uint8_t *src = st->codecpar->extradata;
2308  int i, ret;
2309 
2310  if (st->codecpar->extradata_size != 64)
2311  return 0;
2312 
2313  if (st->codecpar->width > 0 && st->codecpar->height > 0)
2314  snprintf(buf, sizeof(buf), "size: %dx%d\n",
2315  st->codecpar->width, st->codecpar->height);
2316  av_strlcat(buf, "palette: ", sizeof(buf));
2317 
2318  for (i = 0; i < 16; i++) {
2319  uint32_t yuv = AV_RB32(src + i * 4);
2320  uint32_t rgba = yuv_to_rgba(yuv);
2321 
2322  av_strlcatf(buf, sizeof(buf), "%06"PRIx32"%s", rgba, i != 15 ? ", " : "");
2323  }
2324 
2325  if (av_strlcat(buf, "\n", sizeof(buf)) >= sizeof(buf))
2326  return 0;
2327 
2328  ret = ff_alloc_extradata(st->codecpar, strlen(buf));
2329  if (ret < 0)
2330  return ret;
2331  memcpy(st->codecpar->extradata, buf, st->codecpar->extradata_size);
2332 
2333  return 0;
2334 }
2335 
2337  AVStream *st, MOVStreamContext *sc,
2338  int64_t size)
2339 {
2340  int ret;
2341 
2342  if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
2343  if ((int)size != size)
2344  return AVERROR(ENOMEM);
2345 
2346  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
2347  if (ret < 0)
2348  return ret;
2349  if (size > 16) {
2350  MOVStreamContext *tmcd_ctx = st->priv_data;
2351  int val;
2352  val = AV_RB32(st->codecpar->extradata + 4);
2353  tmcd_ctx->tmcd_flags = val;
2354  st->avg_frame_rate.num = AV_RB32(st->codecpar->extradata + 8); /* timescale */
2355  st->avg_frame_rate.den = AV_RB32(st->codecpar->extradata + 12); /* frameDuration */
2356 #if FF_API_LAVF_AVCTX
2358  st->codec->time_base = av_inv_q(st->avg_frame_rate);
2360 #endif
2361  if (size > 30) {
2362  uint32_t len = AV_RB32(st->codecpar->extradata + 18); /* name atom length */
2363  uint32_t format = AV_RB32(st->codecpar->extradata + 22);
2364  if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
2365  uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
2366  if (str_size > 0 && size >= (int)str_size + 30 &&
2367  st->codecpar->extradata[30] /* Don't add empty string */) {
2368  char *reel_name = av_malloc(str_size + 1);
2369  if (!reel_name)
2370  return AVERROR(ENOMEM);
2371  memcpy(reel_name, st->codecpar->extradata + 30, str_size);
2372  reel_name[str_size] = 0; /* Add null terminator */
2373  av_dict_set(&st->metadata, "reel_name", reel_name,
2375  }
2376  }
2377  }
2378  }
2379  } else {
2380  /* other codec type, just skip (rtp, mp4s ...) */
2381  avio_skip(pb, size);
2382  }
2383  return 0;
2384 }
2385 
2387  AVStream *st, MOVStreamContext *sc)
2388 {
2389  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2390  !st->codecpar->sample_rate && sc->time_scale > 1)
2391  st->codecpar->sample_rate = sc->time_scale;
2392 
2393  /* special codec parameters handling */
2394  switch (st->codecpar->codec_id) {
2395 #if CONFIG_DV_DEMUXER
2396  case AV_CODEC_ID_DVAUDIO:
2397  c->dv_fctx = avformat_alloc_context();
2398  if (!c->dv_fctx) {
2399  av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
2400  return AVERROR(ENOMEM);
2401  }
2402  c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
2403  if (!c->dv_demux) {
2404  av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
2405  return AVERROR(ENOMEM);
2406  }
2407  sc->dv_audio_container = 1;
2409  break;
2410 #endif
2411  /* no ifdef since parameters are always those */
2412  case AV_CODEC_ID_QCELP:
2413  st->codecpar->channels = 1;
2414  // force sample rate for qcelp when not stored in mov
2415  if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
2416  st->codecpar->sample_rate = 8000;
2417  // FIXME: Why is the following needed for some files?
2418  sc->samples_per_frame = 160;
2419  if (!sc->bytes_per_frame)
2420  sc->bytes_per_frame = 35;
2421  break;
2422  case AV_CODEC_ID_AMR_NB:
2423  st->codecpar->channels = 1;
2424  /* force sample rate for amr, stsd in 3gp does not store sample rate */
2425  st->codecpar->sample_rate = 8000;
2426  break;
2427  case AV_CODEC_ID_AMR_WB:
2428  st->codecpar->channels = 1;
2429  st->codecpar->sample_rate = 16000;
2430  break;
2431  case AV_CODEC_ID_MP2:
2432  case AV_CODEC_ID_MP3:
2433  /* force type after stsd for m1a hdlr */
2435  break;
2436  case AV_CODEC_ID_GSM:
2437  case AV_CODEC_ID_ADPCM_MS:
2439  case AV_CODEC_ID_ILBC:
2440  case AV_CODEC_ID_MACE3:
2441  case AV_CODEC_ID_MACE6:
2442  case AV_CODEC_ID_QDM2:
2444  break;
2445  case AV_CODEC_ID_ALAC:
2446  if (st->codecpar->extradata_size == 36) {
2447  st->codecpar->channels = AV_RB8 (st->codecpar->extradata + 21);
2448  st->codecpar->sample_rate = AV_RB32(st->codecpar->extradata + 32);
2449  }
2450  break;
2451  case AV_CODEC_ID_AC3:
2452  case AV_CODEC_ID_EAC3:
2454  case AV_CODEC_ID_VC1:
2455  case AV_CODEC_ID_VP8:
2456  case AV_CODEC_ID_VP9:
2458  break;
2459  case AV_CODEC_ID_AV1:
2461  break;
2462  default:
2463  break;
2464  }
2465  return 0;
2466 }
2467 
2469  int codec_tag, int format,
2470  int64_t size)
2471 {
2472  int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2473 
2474  if (codec_tag &&
2475  (codec_tag != format &&
2476  // AVID 1:1 samples with differing data format and codec tag exist
2477  (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
2478  // prores is allowed to have differing data format and codec tag
2479  codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
2480  // so is dv (sigh)
2481  codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
2482  (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
2483  : codec_tag != MKTAG('j','p','e','g')))) {
2484  /* Multiple fourcc, we skip JPEG. This is not correct, we should
2485  * export it as a separate AVStream but this needs a few changes
2486  * in the MOV demuxer, patch welcome. */
2487 
2488  av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
2489  avio_skip(pb, size);
2490  return 1;
2491  }
2492 
2493  return 0;
2494 }
2495 
2497 {
2498  AVStream *st;
2499  MOVStreamContext *sc;
2500  int pseudo_stream_id;
2501 
2502  av_assert0 (c->fc->nb_streams >= 1);
2503  st = c->fc->streams[c->fc->nb_streams-1];
2504  sc = st->priv_data;
2505 
2506  for (pseudo_stream_id = 0;
2507  pseudo_stream_id < entries && !pb->eof_reached;
2508  pseudo_stream_id++) {
2509  //Parsing Sample description table
2510  enum AVCodecID id;
2511  int ret, dref_id = 1;
2512  MOVAtom a = { AV_RL32("stsd") };
2513  int64_t start_pos = avio_tell(pb);
2514  int64_t size = avio_rb32(pb); /* size */
2515  uint32_t format = avio_rl32(pb); /* data format */
2516 
2517  if (size >= 16) {
2518  avio_rb32(pb); /* reserved */
2519  avio_rb16(pb); /* reserved */
2520  dref_id = avio_rb16(pb);
2521  } else if (size <= 7) {
2522  av_log(c->fc, AV_LOG_ERROR,
2523  "invalid size %"PRId64" in stsd\n", size);
2524  return AVERROR_INVALIDDATA;
2525  }
2526 
2528  size - (avio_tell(pb) - start_pos))) {
2529  sc->stsd_count++;
2530  continue;
2531  }
2532 
2533  sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
2534  sc->dref_id= dref_id;
2535  sc->format = format;
2536 
2537  id = mov_codec_id(st, format);
2538 
2539  av_log(c->fc, AV_LOG_TRACE,
2540  "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
2542 
2543  st->codecpar->codec_id = id;
2545  mov_parse_stsd_video(c, pb, st, sc);
2546  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
2547  mov_parse_stsd_audio(c, pb, st, sc);
2548  if (st->codecpar->sample_rate < 0) {
2549  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
2550  return AVERROR_INVALIDDATA;
2551  }
2552  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
2553  mov_parse_stsd_subtitle(c, pb, st, sc,
2554  size - (avio_tell(pb) - start_pos));
2555  } else {
2556  ret = mov_parse_stsd_data(c, pb, st, sc,
2557  size - (avio_tell(pb) - start_pos));
2558  if (ret < 0)
2559  return ret;
2560  }
2561  /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
2562  a.size = size - (avio_tell(pb) - start_pos);
2563  if (a.size > 8) {
2564  if ((ret = mov_read_default(c, pb, a)) < 0)
2565  return ret;
2566  } else if (a.size > 0)
2567  avio_skip(pb, a.size);
2568 
2569  if (sc->extradata && st->codecpar->extradata) {
2570  int extra_size = st->codecpar->extradata_size;
2571 
2572  /* Move the current stream extradata to the stream context one. */
2573  sc->extradata_size[pseudo_stream_id] = extra_size;
2574  sc->extradata[pseudo_stream_id] = st->codecpar->extradata;
2575  st->codecpar->extradata = NULL;
2576  st->codecpar->extradata_size = 0;
2577  }
2578  sc->stsd_count++;
2579  }
2580 
2581  if (pb->eof_reached) {
2582  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSD atom\n");
2583  return AVERROR_EOF;
2584  }
2585 
2586  return 0;
2587 }
2588 
2590 {
2591  AVStream *st;
2592  MOVStreamContext *sc;
2593  int ret, entries;
2594 
2595  if (c->fc->nb_streams < 1)
2596  return 0;
2597  st = c->fc->streams[c->fc->nb_streams - 1];
2598  sc = st->priv_data;
2599 
2600  sc->stsd_version = avio_r8(pb);
2601  avio_rb24(pb); /* flags */
2602  entries = avio_rb32(pb);
2603 
2604  /* Each entry contains a size (4 bytes) and format (4 bytes). */
2605  if (entries <= 0 || entries > atom.size / 8 || entries > 1024) {
2606  av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2607  return AVERROR_INVALIDDATA;
2608  }
2609 
2610  if (sc->extradata) {
2611  av_log(c->fc, AV_LOG_ERROR,
2612  "Duplicate stsd found in this track.\n");
2613  return AVERROR_INVALIDDATA;
2614  }
2615 
2616  /* Prepare space for hosting multiple extradata. */
2617  sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
2618  if (!sc->extradata)
2619  return AVERROR(ENOMEM);
2620 
2621  sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
2622  if (!sc->extradata_size) {
2623  ret = AVERROR(ENOMEM);
2624  goto fail;
2625  }
2626 
2627  ret = ff_mov_read_stsd_entries(c, pb, entries);
2628  if (ret < 0)
2629  goto fail;
2630 
2631  /* Restore back the primary extradata. */
2632  av_freep(&st->codecpar->extradata);
2633  st->codecpar->extradata_size = sc->extradata_size[0];
2634  if (sc->extradata_size[0]) {
2636  if (!st->codecpar->extradata)
2637  return AVERROR(ENOMEM);
2638  memcpy(st->codecpar->extradata, sc->extradata[0], sc->extradata_size[0]);
2639  }
2640 
2641  return mov_finalize_stsd_codec(c, pb, st, sc);
2642 fail:
2643  if (sc->extradata) {
2644  int j;
2645  for (j = 0; j < sc->stsd_count; j++)
2646  av_freep(&sc->extradata[j]);
2647  }
2648 
2649  av_freep(&sc->extradata);
2650  av_freep(&sc->extradata_size);
2651  return ret;
2652 }
2653 
2655 {
2656  AVStream *st;
2657  MOVStreamContext *sc;
2658  unsigned int i, entries;
2659 
2660  if (c->fc->nb_streams < 1)
2661  return 0;
2662  st = c->fc->streams[c->fc->nb_streams-1];
2663  sc = st->priv_data;
2664 
2665  avio_r8(pb); /* version */
2666  avio_rb24(pb); /* flags */
2667 
2668  entries = avio_rb32(pb);
2669  if ((uint64_t)entries * 12 + 4 > atom.size)
2670  return AVERROR_INVALIDDATA;
2671 
2672  av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2673 
2674  if (!entries)
2675  return 0;
2676  if (sc->stsc_data) {
2677  av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicated STSC atom\n");
2678  return 0;
2679  }
2680  av_free(sc->stsc_data);
2681  sc->stsc_count = 0;
2682  sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2683  if (!sc->stsc_data)
2684  return AVERROR(ENOMEM);
2685 
2686  for (i = 0; i < entries && !pb->eof_reached; i++) {
2687  sc->stsc_data[i].first = avio_rb32(pb);
2688  sc->stsc_data[i].count = avio_rb32(pb);
2689  sc->stsc_data[i].id = avio_rb32(pb);
2690  }
2691 
2692  sc->stsc_count = i;
2693  for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
2694  int64_t first_min = i + 1;
2695  if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
2696  (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
2697  sc->stsc_data[i].first < first_min ||
2698  sc->stsc_data[i].count < 1 ||
2699  sc->stsc_data[i].id < 1) {
2700  av_log(c->fc, AV_LOG_WARNING, "STSC entry %d is invalid (first=%d count=%d id=%d)\n", i, sc->stsc_data[i].first, sc->stsc_data[i].count, sc->stsc_data[i].id);
2701  if (i+1 >= sc->stsc_count) {
2702  if (sc->stsc_data[i].count == 0 && i > 0) {
2703  sc->stsc_count --;
2704  continue;
2705  }
2706  sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
2707  if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
2708  sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
2709  sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
2710  sc->stsc_data[i].id = FFMAX(sc->stsc_data[i].id, 1);
2711  continue;
2712  }
2713  av_assert0(sc->stsc_data[i+1].first >= 2);
2714  // We replace this entry by the next valid
2715  sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
2716  sc->stsc_data[i].count = sc->stsc_data[i+1].count;
2717  sc->stsc_data[i].id = sc->stsc_data[i+1].id;
2718  }
2719  }
2720 
2721  if (pb->eof_reached) {
2722  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSC atom\n");
2723  return AVERROR_EOF;
2724  }
2725 
2726  return 0;
2727 }
2728 
2729 static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
2730 {
2731  return index < count - 1;
2732 }
2733 
2734 /* Compute the samples value for the stsc entry at the given index. */
2735 static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
2736 {
2737  int chunk_count;
2738 
2740  chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
2741  else {
2742  // Validation for stsc / stco happens earlier in mov_read_stsc + mov_read_trak.
2744  chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
2745  }
2746 
2747  return sc->stsc_data[index].count * (int64_t)chunk_count;
2748 }
2749 
2751 {
2752  AVStream *st;
2753  MOVStreamContext *sc;
2754  unsigned i, entries;
2755 
2756  if (c->fc->nb_streams < 1)
2757  return 0;
2758  st = c->fc->streams[c->fc->nb_streams-1];
2759  sc = st->priv_data;
2760 
2761  avio_rb32(pb); // version + flags
2762 
2763  entries = avio_rb32(pb);
2764  if (sc->stps_data)
2765  av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
2766  av_free(sc->stps_data);
2767  sc->stps_count = 0;
2768  sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2769  if (!sc->stps_data)
2770  return AVERROR(ENOMEM);
2771 
2772  for (i = 0; i < entries && !pb->eof_reached; i++) {
2773  sc->stps_data[i] = avio_rb32(pb);
2774  }
2775 
2776  sc->stps_count = i;
2777 
2778  if (pb->eof_reached) {
2779  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STPS atom\n");
2780  return AVERROR_EOF;
2781  }
2782 
2783  return 0;
2784 }
2785 
2787 {
2788  AVStream *st;
2789  MOVStreamContext *sc;
2790  unsigned int i, entries;
2791 
2792  if (c->fc->nb_streams < 1)
2793  return 0;
2794  st = c->fc->streams[c->fc->nb_streams-1];
2795  sc = st->priv_data;
2796 
2797  avio_r8(pb); /* version */
2798  avio_rb24(pb); /* flags */
2799 
2800  entries = avio_rb32(pb);
2801 
2802  av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
2803 
2804  if (!entries) {
2805  sc->keyframe_absent = 1;
2806  if (!st->need_parsing && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2808  return 0;
2809  }
2810  if (sc->keyframes)
2811  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
2812  if (entries >= UINT_MAX / sizeof(int))
2813  return AVERROR_INVALIDDATA;
2814  av_freep(&sc->keyframes);
2815  sc->keyframe_count = 0;
2816  sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
2817  if (!sc->keyframes)
2818  return AVERROR(ENOMEM);
2819 
2820  for (i = 0; i < entries && !pb->eof_reached; i++) {
2821  sc->keyframes[i] = avio_rb32(pb);
2822  }
2823 
2824  sc->keyframe_count = i;
2825 
2826  if (pb->eof_reached) {
2827  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSS atom\n");
2828  return AVERROR_EOF;
2829  }
2830 
2831  return 0;
2832 }
2833 
2835 {
2836  AVStream *st;
2837  MOVStreamContext *sc;
2838  unsigned int i, entries, sample_size, field_size, num_bytes;
2839  GetBitContext gb;
2840  unsigned char* buf;
2841  int ret;
2842 
2843  if (c->fc->nb_streams < 1)
2844  return 0;
2845  st = c->fc->streams[c->fc->nb_streams-1];
2846  sc = st->priv_data;
2847 
2848  avio_r8(pb); /* version */
2849  avio_rb24(pb); /* flags */
2850 
2851  if (atom.type == MKTAG('s','t','s','z')) {
2852  sample_size = avio_rb32(pb);
2853  if (!sc->sample_size) /* do not overwrite value computed in stsd */
2854  sc->sample_size = sample_size;
2855  sc->stsz_sample_size = sample_size;
2856  field_size = 32;
2857  } else {
2858  sample_size = 0;
2859  avio_rb24(pb); /* reserved */
2860  field_size = avio_r8(pb);
2861  }
2862  entries = avio_rb32(pb);
2863 
2864  av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
2865 
2866  sc->sample_count = entries;
2867  if (sample_size)
2868  return 0;
2869 
2870  if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2871  av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
2872  return AVERROR_INVALIDDATA;
2873  }
2874 
2875  if (!entries)
2876  return 0;
2877  if (entries >= (UINT_MAX - 4) / field_size)
2878  return AVERROR_INVALIDDATA;
2879  if (sc->sample_sizes)
2880  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
2881  av_free(sc->sample_sizes);
2882  sc->sample_count = 0;
2883  sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
2884  if (!sc->sample_sizes)
2885  return AVERROR(ENOMEM);
2886 
2887  num_bytes = (entries*field_size+4)>>3;
2888 
2889  buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
2890  if (!buf) {
2891  av_freep(&sc->sample_sizes);
2892  return AVERROR(ENOMEM);
2893  }
2894 
2895  ret = ffio_read_size(pb, buf, num_bytes);
2896  if (ret < 0) {
2897  av_freep(&sc->sample_sizes);
2898  av_free(buf);
2899  av_log(c->fc, AV_LOG_WARNING, "STSZ atom truncated\n");
2900  return 0;
2901  }
2902 
2903  init_get_bits(&gb, buf, 8*num_bytes);
2904 
2905  for (i = 0; i < entries && !pb->eof_reached; i++) {
2906  sc->sample_sizes[i] = get_bits_long(&gb, field_size);
2907  if (sc->sample_sizes[i] < 0) {
2908  av_free(buf);
2909  av_log(c->fc, AV_LOG_ERROR, "Invalid sample size %d\n", sc->sample_sizes[i]);
2910  return AVERROR_INVALIDDATA;
2911  }
2912  sc->data_size += sc->sample_sizes[i];
2913  }
2914 
2915  sc->sample_count = i;
2916 
2917  av_free(buf);
2918 
2919  if (pb->eof_reached) {
2920  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSZ atom\n");
2921  return AVERROR_EOF;
2922  }
2923 
2924  return 0;
2925 }
2926 
2928 {
2929  AVStream *st;
2930  MOVStreamContext *sc;
2931  unsigned int i, entries, alloc_size = 0;
2932  int64_t duration = 0;
2933  int64_t total_sample_count = 0;
2934 
2935  if (c->fc->nb_streams < 1)
2936  return 0;
2937  st = c->fc->streams[c->fc->nb_streams-1];
2938  sc = st->priv_data;
2939 
2940  avio_r8(pb); /* version */
2941  avio_rb24(pb); /* flags */
2942  entries = avio_rb32(pb);
2943 
2944  av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
2945  c->fc->nb_streams-1, entries);
2946 
2947  if (sc->stts_data)
2948  av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
2949  av_freep(&sc->stts_data);
2950  sc->stts_count = 0;
2951  if (entries >= INT_MAX / sizeof(*sc->stts_data))
2952  return AVERROR(ENOMEM);
2953 
2954  for (i = 0; i < entries && !pb->eof_reached; i++) {
2955  int sample_duration;
2956  unsigned int sample_count;
2957  unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
2958  MOVStts *stts_data = av_fast_realloc(sc->stts_data, &alloc_size,
2959  min_entries * sizeof(*sc->stts_data));
2960  if (!stts_data) {
2961  av_freep(&sc->stts_data);
2962  sc->stts_count = 0;
2963  return AVERROR(ENOMEM);
2964  }
2965  sc->stts_count = min_entries;
2966  sc->stts_data = stts_data;
2967 
2968  sample_count = avio_rb32(pb);
2969  sample_duration = avio_rb32(pb);
2970 
2971  sc->stts_data[i].count= sample_count;
2972  sc->stts_data[i].duration= sample_duration;
2973 
2974  av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n",
2975  sample_count, sample_duration);
2976 
2977  duration+=(int64_t)sample_duration*(uint64_t)sample_count;
2978  total_sample_count+=sample_count;
2979  }
2980 
2981  sc->stts_count = i;
2982 
2983  if (duration > 0 &&
2984  duration <= INT64_MAX - sc->duration_for_fps &&
2985  total_sample_count <= INT_MAX - sc->nb_frames_for_fps) {
2986  sc->duration_for_fps += duration;
2987  sc->nb_frames_for_fps += total_sample_count;
2988  }
2989 
2990  if (pb->eof_reached) {
2991  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STTS atom\n");
2992  return AVERROR_EOF;
2993  }
2994 
2995  st->nb_frames= total_sample_count;
2996  if (duration)
2997  st->duration= FFMIN(st->duration, duration);
2998  sc->track_end = duration;
2999  return 0;
3000 }
3001 
3003 {
3004  AVStream *st;
3005  MOVStreamContext *sc;
3006  int64_t i, entries;
3007 
3008  if (c->fc->nb_streams < 1)
3009  return 0;
3010  st = c->fc->streams[c->fc->nb_streams - 1];
3011  sc = st->priv_data;
3012 
3013  avio_r8(pb); /* version */
3014  avio_rb24(pb); /* flags */
3015  entries = atom.size - 4;
3016 
3017  av_log(c->fc, AV_LOG_TRACE, "track[%u].sdtp.entries = %" PRId64 "\n",
3018  c->fc->nb_streams - 1, entries);
3019 
3020  if (sc->sdtp_data)
3021  av_log(c->fc, AV_LOG_WARNING, "Duplicated SDTP atom\n");
3022  av_freep(&sc->sdtp_data);
3023  sc->sdtp_count = 0;
3024 
3025  sc->sdtp_data = av_malloc(entries);
3026  if (!sc->sdtp_data)
3027  return AVERROR(ENOMEM);
3028 
3029  for (i = 0; i < entries && !pb->eof_reached; i++)
3030  sc->sdtp_data[i] = avio_r8(pb);
3031  sc->sdtp_count = i;
3032 
3033  return 0;
3034 }
3035 
3036 static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logctx)
3037 {
3038  if (duration < 0) {
3039  if (duration == INT_MIN) {
3040  av_log(logctx, AV_LOG_WARNING, "mov_update_dts_shift(): dts_shift set to %d\n", INT_MAX);
3041  duration++;
3042  }
3043  sc->dts_shift = FFMAX(sc->dts_shift, -duration);
3044  }
3045 }
3046 
3048 {
3049  AVStream *st;
3050  MOVStreamContext *sc;
3051  unsigned int i, entries, ctts_count = 0;
3052 
3053  if (c->fc->nb_streams < 1)
3054  return 0;
3055  st = c->fc->streams[c->fc->nb_streams-1];
3056  sc = st->priv_data;
3057 
3058  avio_r8(pb); /* version */
3059  avio_rb24(pb); /* flags */
3060  entries = avio_rb32(pb);
3061 
3062  av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
3063 
3064  if (!entries)
3065  return 0;
3066  if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
3067  return AVERROR_INVALIDDATA;
3068  av_freep(&sc->ctts_data);
3069  sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
3070  if (!sc->ctts_data)
3071  return AVERROR(ENOMEM);
3072 
3073  for (i = 0; i < entries && !pb->eof_reached; i++) {
3074  int count = avio_rb32(pb);
3075  int duration = avio_rb32(pb);
3076 
3077  if (count <= 0) {
3078  av_log(c->fc, AV_LOG_TRACE,
3079  "ignoring CTTS entry with count=%d duration=%d\n",
3080  count, duration);
3081  continue;
3082  }
3083 
3084  add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
3085  count, duration);
3086 
3087  av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
3088  count, duration);
3089 
3090  if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3091  av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
3092  av_freep(&sc->ctts_data);
3093  sc->ctts_count = 0;
3094  return 0;
3095  }
3096 
3097  if (i+2<entries)
3098  mov_update_dts_shift(sc, duration, c->fc);
3099  }
3100 
3101  sc->ctts_count = ctts_count;
3102 
3103  if (pb->eof_reached) {
3104  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted CTTS atom\n");
3105  return AVERROR_EOF;
3106  }
3107 
3108  av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift);
3109 
3110  return 0;
3111 }
3112 
3114 {
3115  AVStream *st;
3116  MOVStreamContext *sc;
3117  unsigned int i, entries;
3118  uint8_t version;
3119  uint32_t grouping_type;
3120 
3121  if (c->fc->nb_streams < 1)
3122  return 0;
3123  st = c->fc->streams[c->fc->nb_streams-1];
3124  sc = st->priv_data;
3125 
3126  version = avio_r8(pb); /* version */
3127  avio_rb24(pb); /* flags */
3128  grouping_type = avio_rl32(pb);
3129  if (grouping_type != MKTAG( 'r','a','p',' '))
3130  return 0; /* only support 'rap ' grouping */
3131  if (version == 1)
3132  avio_rb32(pb); /* grouping_type_parameter */
3133 
3134  entries = avio_rb32(pb);
3135  if (!entries)
3136  return 0;
3137  if (sc->rap_group)
3138  av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
3139  av_free(sc->rap_group);
3140  sc->rap_group_count = 0;
3141  sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
3142  if (!sc->rap_group)
3143  return AVERROR(ENOMEM);
3144 
3145  for (i = 0; i < entries && !pb->eof_reached; i++) {
3146  sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
3147  sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
3148  }
3149 
3150  sc->rap_group_count = i;
3151 
3152  if (pb->eof_reached) {
3153  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted SBGP atom\n");
3154  return AVERROR_EOF;
3155  }
3156 
3157  return 0;
3158 }
3159 
3160 /**
3161  * Get ith edit list entry (media time, duration).
3162  */
3164  const MOVStreamContext *msc,
3165  unsigned int edit_list_index,
3166  int64_t *edit_list_media_time,
3167  int64_t *edit_list_duration,
3168  int64_t global_timescale)
3169 {
3170  if (edit_list_index == msc->elst_count) {
3171  return 0;
3172  }
3173  *edit_list_media_time = msc->elst_data[edit_list_index].time;
3174  *edit_list_duration = msc->elst_data[edit_list_index].duration;
3175 
3176  /* duration is in global timescale units;convert to msc timescale */
3177  if (global_timescale == 0) {
3178  avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
3179  return 0;
3180  }
3181  *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
3182  global_timescale);
3183  return 1;
3184 }
3185 
3186 /**
3187  * Find the closest previous frame to the timestamp_pts, in e_old index
3188  * entries. Searching for just any frame / just key frames can be controlled by
3189  * last argument 'flag'.
3190  * Note that if ctts_data is not NULL, we will always search for a key frame
3191  * irrespective of the value of 'flag'. If we don't find any keyframe, we will
3192  * return the first frame of the video.
3193  *
3194  * Here the timestamp_pts is considered to be a presentation timestamp and
3195  * the timestamp of index entries are considered to be decoding timestamps.
3196  *
3197  * Returns 0 if successful in finding a frame, else returns -1.
3198  * Places the found index corresponding output arg.
3199  *
3200  * If ctts_old is not NULL, then refines the searched entry by searching
3201  * backwards from the found timestamp, to find the frame with correct PTS.
3202  *
3203  * Places the found ctts_index and ctts_sample in corresponding output args.
3204  */
3206  AVIndexEntry *e_old,
3207  int nb_old,
3208  MOVStts* ctts_data,
3209  int64_t ctts_count,
3210  int64_t timestamp_pts,
3211  int flag,
3212  int64_t* index,
3213  int64_t* ctts_index,
3214  int64_t* ctts_sample)
3215 {
3216  MOVStreamContext *msc = st->priv_data;
3217  AVIndexEntry *e_keep = st->index_entries;
3218  int nb_keep = st->nb_index_entries;
3219  int64_t i = 0;
3220  int64_t index_ctts_count;
3221 
3222  av_assert0(index);
3223 
3224  // If dts_shift > 0, then all the index timestamps will have to be offset by
3225  // at least dts_shift amount to obtain PTS.
3226  // Hence we decrement the searched timestamp_pts by dts_shift to find the closest index element.
3227  if (msc->dts_shift > 0) {
3228  timestamp_pts -= msc->dts_shift;
3229  }
3230 
3231  st->index_entries = e_old;
3232  st->nb_index_entries = nb_old;
3233  *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
3234 
3235  // Keep going backwards in the index entries until the timestamp is the same.
3236  if (*index >= 0) {
3237  for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
3238  i--) {
3239  if ((flag & AVSEEK_FLAG_ANY) ||
3240  (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
3241  *index = i - 1;
3242  }
3243  }
3244  }
3245 
3246  // If we have CTTS then refine the search, by searching backwards over PTS
3247  // computed by adding corresponding CTTS durations to index timestamps.
3248  if (ctts_data && *index >= 0) {
3249  av_assert0(ctts_index);
3250  av_assert0(ctts_sample);
3251  // Find out the ctts_index for the found frame.
3252  *ctts_index = 0;
3253  *ctts_sample = 0;
3254  for (index_ctts_count = 0; index_ctts_count < *index; index_ctts_count++) {
3255  if (*ctts_index < ctts_count) {
3256  (*ctts_sample)++;
3257  if (ctts_data[*ctts_index].count == *ctts_sample) {
3258  (*ctts_index)++;
3259  *ctts_sample = 0;
3260  }
3261  }
3262  }
3263 
3264  while (*index >= 0 && (*ctts_index) >= 0 && (*ctts_index) < ctts_count) {
3265  // Find a "key frame" with PTS <= timestamp_pts (So that we can decode B-frames correctly).
3266  // No need to add dts_shift to the timestamp here becase timestamp_pts has already been
3267  // compensated by dts_shift above.
3268  if ((e_old[*index].timestamp + ctts_data[*ctts_index].duration) <= timestamp_pts &&
3269  (e_old[*index].flags & AVINDEX_KEYFRAME)) {
3270  break;
3271  }
3272 
3273  (*index)--;
3274  if (*ctts_sample == 0) {
3275  (*ctts_index)--;
3276  if (*ctts_index >= 0)
3277  *ctts_sample = ctts_data[*ctts_index].count - 1;
3278  } else {
3279  (*ctts_sample)--;
3280  }
3281  }
3282  }
3283 
3284  /* restore AVStream state*/
3285  st->index_entries = e_keep;
3286  st->nb_index_entries = nb_keep;
3287  return *index >= 0 ? 0 : -1;
3288 }
3289 
3290 /**
3291  * Add index entry with the given values, to the end of st->index_entries.
3292  * Returns the new size st->index_entries if successful, else returns -1.
3293  *
3294  * This function is similar to ff_add_index_entry in libavformat/utils.c
3295  * except that here we are always unconditionally adding an index entry to
3296  * the end, instead of searching the entries list and skipping the add if
3297  * there is an existing entry with the same timestamp.
3298  * This is needed because the mov_fix_index calls this func with the same
3299  * unincremented timestamp for successive discarded frames.
3300  */
3301 static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
3302  int size, int distance, int flags)
3303 {
3304  AVIndexEntry *entries, *ie;
3305  int64_t index = -1;
3306  const size_t min_size_needed = (st->nb_index_entries + 1) * sizeof(AVIndexEntry);
3307 
3308  // Double the allocation each time, to lower memory fragmentation.
3309  // Another difference from ff_add_index_entry function.
3310  const size_t requested_size =
3311  min_size_needed > st->index_entries_allocated_size ?
3312  FFMAX(min_size_needed, 2 * st->index_entries_allocated_size) :
3313  min_size_needed;
3314 
3315  if (st->nb_index_entries + 1U >= UINT_MAX / sizeof(AVIndexEntry))
3316  return -1;
3317 
3318  entries = av_fast_realloc(st->index_entries,
3320  requested_size);
3321  if (!entries)
3322  return -1;
3323 
3324  st->index_entries= entries;
3325 
3326  index= st->nb_index_entries++;
3327  ie= &entries[index];
3328 
3329  ie->pos = pos;
3330  ie->timestamp = timestamp;
3331  ie->min_distance= distance;
3332  ie->size= size;
3333  ie->flags = flags;
3334  return index;
3335 }
3336 
3337 /**
3338  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3339  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
3340  */
3341 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
3342  int64_t* frame_duration_buffer,
3343  int frame_duration_buffer_size) {
3344  int i = 0;
3345  av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
3346  for (i = 0; i < frame_duration_buffer_size; i++) {
3347  end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
3348  st->index_entries[end_index - 1 - i].timestamp = end_ts;
3349  }
3350 }
3351 
3352 /**
3353  * Append a new ctts entry to ctts_data.
3354  * Returns the new ctts_count if successful, else returns -1.
3355  */
3356 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
3357  int count, int duration)
3358 {
3359  MOVStts *ctts_buf_new;
3360  const size_t min_size_needed = (*ctts_count + 1) * sizeof(MOVStts);
3361  const size_t requested_size =
3362  min_size_needed > *allocated_size ?
3363  FFMAX(min_size_needed, 2 * (*allocated_size)) :
3364  min_size_needed;
3365 
3366  if ((unsigned)(*ctts_count) >= UINT_MAX / sizeof(MOVStts) - 1)
3367  return -1;
3368 
3369  ctts_buf_new = av_fast_realloc(*ctts_data, allocated_size, requested_size);
3370 
3371  if (!ctts_buf_new)
3372  return -1;
3373 
3374  *ctts_data = ctts_buf_new;
3375 
3376  ctts_buf_new[*ctts_count].count = count;
3377  ctts_buf_new[*ctts_count].duration = duration;
3378 
3379  *ctts_count = (*ctts_count) + 1;
3380  return *ctts_count;
3381 }
3382 
3383 #define MAX_REORDER_DELAY 16
3385 {
3386  MOVStreamContext *msc = st->priv_data;
3387  int ind;
3388  int ctts_ind = 0;
3389  int ctts_sample = 0;
3390  int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
3391  int buf_start = 0;
3392  int j, r, num_swaps;
3393 
3394  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
3395  pts_buf[j] = INT64_MIN;
3396 
3397  if (st->codecpar->video_delay <= 0 && msc->ctts_data &&
3399  st->codecpar->video_delay = 0;
3400  for (ind = 0; ind < st->nb_index_entries && ctts_ind < msc->ctts_count; ++ind) {
3401  // Point j to the last elem of the buffer and insert the current pts there.
3402  j = buf_start;
3403  buf_start = (buf_start + 1);
3404  if (buf_start == MAX_REORDER_DELAY + 1)
3405  buf_start = 0;
3406 
3407  pts_buf[j] = st->index_entries[ind].timestamp + msc->ctts_data[ctts_ind].duration;
3408 
3409  // The timestamps that are already in the sorted buffer, and are greater than the
3410  // current pts, are exactly the timestamps that need to be buffered to output PTS
3411  // in correct sorted order.
3412  // Hence the video delay (which is the buffer size used to sort DTS and output PTS),
3413  // can be computed as the maximum no. of swaps any particular timestamp needs to
3414  // go through, to keep this buffer in sorted order.
3415  num_swaps = 0;
3416  while (j != buf_start) {
3417  r = j - 1;
3418  if (r < 0) r = MAX_REORDER_DELAY;
3419  if (pts_buf[j] < pts_buf[r]) {
3420  FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
3421  ++num_swaps;
3422  } else {
3423  break;
3424  }
3425  j = r;
3426  }
3427  st->codecpar->video_delay = FFMAX(st->codecpar->video_delay, num_swaps);
3428 
3429  ctts_sample++;
3430  if (ctts_sample == msc->ctts_data[ctts_ind].count) {
3431  ctts_ind++;
3432  ctts_sample = 0;
3433  }
3434  }
3435  av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
3436  st->codecpar->video_delay, st->index);
3437  }
3438 }
3439 
3441 {
3442  sc->current_sample++;
3443  sc->current_index++;
3444  if (sc->index_ranges &&
3445  sc->current_index >= sc->current_index_range->end &&
3446  sc->current_index_range->end) {
3447  sc->current_index_range++;
3449  }
3450 }
3451 
3453 {
3454  sc->current_sample--;
3455  sc->current_index--;
3456  if (sc->index_ranges &&
3458  sc->current_index_range > sc->index_ranges) {
3459  sc->current_index_range--;
3460  sc->current_index = sc->current_index_range->end - 1;
3461  }
3462 }
3463 
3464 static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
3465 {
3466  int64_t range_size;
3467 
3468  sc->current_sample = current_sample;
3469  sc->current_index = current_sample;
3470  if (!sc->index_ranges) {
3471  return;
3472  }
3473 
3474  for (sc->current_index_range = sc->index_ranges;
3475  sc->current_index_range->end;
3476  sc->current_index_range++) {
3477  range_size = sc->current_index_range->end - sc->current_index_range->start;
3478  if (range_size > current_sample) {
3479  sc->current_index = sc->current_index_range->start + current_sample;
3480  break;
3481  }
3482  current_sample -= range_size;
3483  }
3484 }
3485 
3486 /**
3487  * Fix st->index_entries, so that it contains only the entries (and the entries
3488  * which are needed to decode them) that fall in the edit list time ranges.
3489  * Also fixes the timestamps of the index entries to match the timeline
3490  * specified the edit lists.
3491  */
3492 static void mov_fix_index(MOVContext *mov, AVStream *st)
3493 {
3494  MOVStreamContext *msc = st->priv_data;
3495  AVIndexEntry *e_old = st->index_entries;
3496  int nb_old = st->nb_index_entries;
3497  const AVIndexEntry *e_old_end = e_old + nb_old;
3498  const AVIndexEntry *current = NULL;
3499  MOVStts *ctts_data_old = msc->ctts_data;
3500  int64_t ctts_index_old = 0;
3501  int64_t ctts_sample_old = 0;
3502  int64_t ctts_count_old = msc->ctts_count;
3503  int64_t edit_list_media_time = 0;
3504  int64_t edit_list_duration = 0;
3505  int64_t frame_duration = 0;
3506  int64_t edit_list_dts_counter = 0;
3507  int64_t edit_list_dts_entry_end = 0;
3508  int64_t edit_list_start_ctts_sample = 0;
3509  int64_t curr_cts;
3510  int64_t curr_ctts = 0;
3511  int64_t empty_edits_sum_duration = 0;
3512  int64_t edit_list_index = 0;
3513  int64_t index;
3514  int flags;
3515  int64_t start_dts = 0;
3516  int64_t edit_list_start_encountered = 0;
3517  int64_t search_timestamp = 0;
3518  int64_t* frame_duration_buffer = NULL;
3519  int num_discarded_begin = 0;
3520  int first_non_zero_audio_edit = -1;
3521  int packet_skip_samples = 0;
3522  MOVIndexRange *current_index_range;
3523  int i;
3524  int found_keyframe_after_edit = 0;
3525  int found_non_empty_edit = 0;
3526 
3527  if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
3528  return;
3529  }
3530 
3531  // allocate the index ranges array
3532  msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
3533  if (!msc->index_ranges) {
3534  av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
3535  return;
3536  }
3537  msc->current_index_range = msc->index_ranges;
3538  current_index_range = msc->index_ranges - 1;
3539 
3540  // Clean AVStream from traces of old index
3541  st->index_entries = NULL;
3543  st->nb_index_entries = 0;
3544 
3545  // Clean ctts fields of MOVStreamContext
3546  msc->ctts_data = NULL;
3547  msc->ctts_count = 0;
3548  msc->ctts_index = 0;
3549  msc->ctts_sample = 0;
3550  msc->ctts_allocated_size = 0;
3551 
3552  // Reinitialize min_corrected_pts so that it can be computed again.
3553  msc->min_corrected_pts = -1;
3554 
3555  // If the dts_shift is positive (in case of negative ctts values in mov),
3556  // then negate the DTS by dts_shift
3557  if (msc->dts_shift > 0) {
3558  edit_list_dts_entry_end -= msc->dts_shift;
3559  av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
3560  }
3561 
3562  start_dts = edit_list_dts_entry_end;
3563 
3564  while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
3565  &edit_list_duration, mov->time_scale)) {
3566  av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
3567  st->index, edit_list_index, edit_list_media_time, edit_list_duration);
3568  edit_list_index++;
3569  edit_list_dts_counter = edit_list_dts_entry_end;
3570  edit_list_dts_entry_end += edit_list_duration;
3571  num_discarded_begin = 0;
3572  if (!found_non_empty_edit && edit_list_media_time == -1) {
3573  empty_edits_sum_duration += edit_list_duration;
3574  continue;
3575  }
3576  found_non_empty_edit = 1;
3577 
3578  // If we encounter a non-negative edit list reset the skip_samples/start_pad fields and set them
3579  // according to the edit list below.
3580  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3581  if (first_non_zero_audio_edit < 0) {
3582  first_non_zero_audio_edit = 1;
3583  } else {
3584  first_non_zero_audio_edit = 0;
3585  }
3586 
3587  if (first_non_zero_audio_edit > 0)
3588  st->internal->skip_samples = msc->start_pad = 0;
3589  }
3590 
3591  // While reordering frame index according to edit list we must handle properly
3592  // the scenario when edit list entry starts from none key frame.
3593  // We find closest previous key frame and preserve it and consequent frames in index.
3594  // All frames which are outside edit list entry time boundaries will be dropped after decoding.
3595  search_timestamp = edit_list_media_time;
3596  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3597  // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
3598  // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
3599  // edit_list_media_time to cover the decoder delay.
3600  search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
3601  }
3602 
3603  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, 0,
3604  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3605  av_log(mov->fc, AV_LOG_WARNING,
3606  "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
3607  st->index, edit_list_index, search_timestamp);
3608  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
3609  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3610  av_log(mov->fc, AV_LOG_WARNING,
3611  "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
3612  st->index, edit_list_index, search_timestamp);
3613  index = 0;
3614  ctts_index_old = 0;
3615  ctts_sample_old = 0;
3616  }
3617  }
3618  current = e_old + index;
3619  edit_list_start_ctts_sample = ctts_sample_old;
3620 
3621  // Iterate over index and arrange it according to edit list
3622  edit_list_start_encountered = 0;
3623  found_keyframe_after_edit = 0;
3624  for (; current < e_old_end; current++, index++) {
3625  // check if frame outside edit list mark it for discard
3626  frame_duration = (current + 1 < e_old_end) ?
3627  ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
3628 
3629  flags = current->flags;
3630 
3631  // frames (pts) before or after edit list
3632  curr_cts = current->timestamp + msc->dts_shift;
3633  curr_ctts = 0;
3634 
3635  if (ctts_data_old && ctts_index_old < ctts_count_old) {
3636  curr_ctts = ctts_data_old[ctts_index_old].duration;
3637  av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
3638  curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
3639  curr_cts += curr_ctts;
3640  ctts_sample_old++;
3641  if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
3642  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3643  &msc->ctts_allocated_size,
3644  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3645  ctts_data_old[ctts_index_old].duration) == -1) {
3646  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3647  ctts_index_old,
3648  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3649  ctts_data_old[ctts_index_old].duration);
3650  break;
3651  }
3652  ctts_index_old++;
3653  ctts_sample_old = 0;
3654  edit_list_start_ctts_sample = 0;
3655  }
3656  }
3657 
3658  if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3660  curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3661  first_non_zero_audio_edit > 0) {
3662  packet_skip_samples = edit_list_media_time - curr_cts;
3663  st->internal->skip_samples += packet_skip_samples;
3664 
3665  // Shift the index entry timestamp by packet_skip_samples to be correct.
3666  edit_list_dts_counter -= packet_skip_samples;
3667  if (edit_list_start_encountered == 0) {
3668  edit_list_start_encountered = 1;
3669  // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
3670  // discarded packets.
3671  if (frame_duration_buffer) {
3672  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3673  frame_duration_buffer, num_discarded_begin);
3674  av_freep(&frame_duration_buffer);
3675  }
3676  }
3677 
3678  av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
3679  } else {
3681  av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
3682 
3683  if (edit_list_start_encountered == 0) {
3684  num_discarded_begin++;
3685  frame_duration_buffer = av_realloc(frame_duration_buffer,
3686  num_discarded_begin * sizeof(int64_t));
3687  if (!frame_duration_buffer) {
3688  av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
3689  break;
3690  }
3691  frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3692 
3693  // Increment skip_samples for the first non-zero audio edit list
3694  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3695  first_non_zero_audio_edit > 0 && st->codecpar->codec_id != AV_CODEC_ID_VORBIS) {
3696  st->internal->skip_samples += frame_duration;
3697  }
3698  }
3699  }
3700  } else {
3701  if (msc->min_corrected_pts < 0) {
3702  msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
3703  } else {
3704  msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
3705  }
3706  if (edit_list_start_encountered == 0) {
3707  edit_list_start_encountered = 1;
3708  // Make timestamps strictly monotonically increasing by rewriting timestamps for
3709  // discarded packets.
3710  if (frame_duration_buffer) {
3711  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3712  frame_duration_buffer, num_discarded_begin);
3713  av_freep(&frame_duration_buffer);
3714  }
3715  }
3716  }
3717 
3718  if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
3719  current->min_distance, flags) == -1) {
3720  av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
3721  break;
3722  }
3723 
3724  // Update the index ranges array
3725  if (current_index_range < msc->index_ranges || index != current_index_range->end) {
3726  current_index_range++;
3727  current_index_range->start = index;
3728  }
3729  current_index_range->end = index + 1;
3730 
3731  // Only start incrementing DTS in frame_duration amounts, when we encounter a frame in edit list.
3732  if (edit_list_start_encountered > 0) {
3733  edit_list_dts_counter = edit_list_dts_counter + frame_duration;
3734  }
3735 
3736  // Break when found first key frame after edit entry completion
3737  if ((curr_cts + frame_duration >= (edit_list_duration + edit_list_media_time)) &&
3739  if (ctts_data_old) {
3740  // If we have CTTS and this is the first keyframe after edit elist,
3741  // wait for one more, because there might be trailing B-frames after this I-frame
3742  // that do belong to the edit.
3743  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO && found_keyframe_after_edit == 0) {
3744  found_keyframe_after_edit = 1;
3745  continue;
3746  }
3747  if (ctts_sample_old != 0) {
3748  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3749  &msc->ctts_allocated_size,
3750  ctts_sample_old - edit_list_start_ctts_sample,
3751  ctts_data_old[ctts_index_old].duration) == -1) {
3752  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3753  ctts_index_old, ctts_sample_old - edit_list_start_ctts_sample,
3754  ctts_data_old[ctts_index_old].duration);
3755  break;
3756  }
3757  }
3758  }
3759  break;
3760  }
3761  }
3762  }
3763  // If there are empty edits, then msc->min_corrected_pts might be positive
3764  // intentionally. So we subtract the sum duration of emtpy edits here.
3765  msc->min_corrected_pts -= empty_edits_sum_duration;
3766 
3767  // If the minimum pts turns out to be greater than zero after fixing the index, then we subtract the
3768  // dts by that amount to make the first pts zero.
3769  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3770  if (msc->min_corrected_pts > 0) {
3771  av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by %"PRId64" to make first pts zero.\n", msc->min_corrected_pts);
3772  for (i = 0; i < st->nb_index_entries; ++i) {
3774  }
3775  }
3776  }
3777  // Start time should be equal to zero or the duration of any empty edits.
3778  st->start_time = empty_edits_sum_duration;
3779 
3780  // Update av stream length, if it ends up shorter than the track's media duration
3781  st->duration = FFMIN(st->duration, edit_list_dts_entry_end - start_dts);
3782  msc->start_pad = st->internal->skip_samples;
3783 
3784  // Free the old index and the old CTTS structures
3785  av_free(e_old);
3786  av_free(ctts_data_old);
3787  av_freep(&frame_duration_buffer);
3788 
3789  // Null terminate the index ranges array
3790  current_index_range++;
3791  current_index_range->start = 0;
3792  current_index_range->end = 0;
3793  msc->current_index = msc->index_ranges[0].start;
3794 }
3795 
3796 static void mov_build_index(MOVContext *mov, AVStream *st)
3797 {
3798  MOVStreamContext *sc = st->priv_data;
3799  int64_t current_offset;
3800  int64_t current_dts = 0;
3801  unsigned int stts_index = 0;
3802  unsigned int stsc_index = 0;
3803  unsigned int stss_index = 0;
3804  unsigned int stps_index = 0;
3805  unsigned int i, j;
3806  uint64_t stream_size = 0;
3807  MOVStts *ctts_data_old = sc->ctts_data;
3808  unsigned int ctts_count_old = sc->ctts_count;
3809 
3810  if (sc->elst_count) {
3811  int i, edit_start_index = 0, multiple_edits = 0;
3812  int64_t empty_duration = 0; // empty duration of the first edit list entry
3813  int64_t start_time = 0; // start time of the media
3814 
3815  for (i = 0; i < sc->elst_count; i++) {
3816  const MOVElst *e = &sc->elst_data[i];
3817  if (i == 0 && e->time == -1) {
3818  /* if empty, the first entry is the start time of the stream
3819  * relative to the presentation itself */
3820  empty_duration = e->duration;
3821  edit_start_index = 1;
3822  } else if (i == edit_start_index && e->time >= 0) {
3823  start_time = e->time;
3824  } else {
3825  multiple_edits = 1;
3826  }
3827  }
3828 
3829  if (multiple_edits && !mov->advanced_editlist)
3830  av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
3831  "Use -advanced_editlist to correctly decode otherwise "
3832  "a/v desync might occur\n");
3833 
3834  /* adjust first dts according to edit list */
3835  if ((empty_duration || start_time) && mov->time_scale > 0) {
3836  if (empty_duration)
3837  empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
3838  sc->time_offset = start_time - empty_duration;
3840  if (!mov->advanced_editlist)
3841  current_dts = -sc->time_offset;
3842  }
3843 
3844  if (!multiple_edits && !mov->advanced_editlist &&
3846  sc->start_pad = start_time;
3847  }
3848 
3849  /* only use old uncompressed audio chunk demuxing when stts specifies it */
3850  if (!(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3851  sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
3852  unsigned int current_sample = 0;
3853  unsigned int stts_sample = 0;
3854  unsigned int sample_size;
3855  unsigned int distance = 0;
3856  unsigned int rap_group_index = 0;
3857  unsigned int rap_group_sample = 0;
3858  int64_t last_dts = 0;
3859  int64_t dts_correction = 0;
3860  int rap_group_present = sc->rap_group_count && sc->rap_group;
3861  int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
3862 
3863  current_dts -= sc->dts_shift;
3864  last_dts = current_dts;
3865 
3866  if (!sc->sample_count || st->nb_index_entries)
3867  return;
3868  if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
3869  return;
3871  st->nb_index_entries + sc->sample_count,
3872  sizeof(*st->index_entries)) < 0) {
3873  st->nb_index_entries = 0;
3874  return;
3875  }
3877 
3878  if (ctts_data_old) {
3879  // Expand ctts entries such that we have a 1-1 mapping with samples
3880  if (sc->sample_count >= UINT_MAX / sizeof(*sc->ctts_data))
3881  return;
3882  sc->ctts_count = 0;
3883  sc->ctts_allocated_size = 0;
3885  sc->sample_count * sizeof(*sc->ctts_data));
3886  if (!sc->ctts_data) {
3887  av_free(ctts_data_old);
3888  return;
3889  }
3890 
3891  memset((uint8_t*)(sc->ctts_data), 0, sc->ctts_allocated_size);
3892 
3893  for (i = 0; i < ctts_count_old &&
3894  sc->ctts_count < sc->sample_count; i++)
3895  for (j = 0; j < ctts_data_old[i].count &&
3896  sc->ctts_count < sc->sample_count; j++)
3897  add_ctts_entry(&sc->ctts_data, &sc->ctts_count,
3898  &sc->ctts_allocated_size, 1,
3899  ctts_data_old[i].duration);
3900  av_free(ctts_data_old);
3901  }
3902 
3903  for (i = 0; i < sc->chunk_count; i++) {
3904  int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
3905  current_offset = sc->chunk_offsets[i];
3906  while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
3907  i + 1 == sc->stsc_data[stsc_index + 1].first)
3908  stsc_index++;
3909 
3910  if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
3911  sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
3912  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
3913  sc->stsz_sample_size = sc->sample_size;
3914  }
3915  if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
3916  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
3917  sc->stsz_sample_size = sc->sample_size;
3918  }
3919 
3920  for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
3921  int keyframe = 0;
3922  if (current_sample >= sc->sample_count) {
3923  av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
3924  return;
3925  }
3926 
3927  if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
3928  keyframe = 1;
3929  if (stss_index + 1 < sc->keyframe_count)
3930  stss_index++;
3931  } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
3932  keyframe = 1;
3933  if (stps_index + 1 < sc->stps_count)
3934  stps_index++;
3935  }
3936  if (rap_group_present && rap_group_index < sc->rap_group_count) {
3937  if (sc->rap_group[rap_group_index].index > 0)
3938  keyframe = 1;
3939  if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
3940  rap_group_sample = 0;
3941  rap_group_index++;
3942  }
3943  }
3944  if (sc->keyframe_absent
3945  && !sc->stps_count
3946  && !rap_group_present
3947  && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
3948  keyframe = 1;
3949  if (keyframe)
3950  distance = 0;
3951  sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
3952  if (sc->pseudo_stream_id == -1 ||
3953  sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
3954  AVIndexEntry *e;
3955  if (sample_size > 0x3FFFFFFF) {
3956  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", sample_size);
3957  return;
3958  }
3959  e = &st->index_entries[st->nb_index_entries++];
3960  e->pos = current_offset;
3961  e->timestamp = current_dts;
3962  e->size = sample_size;
3963  e->min_distance = distance;
3964  e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
3965  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
3966  "size %u, distance %u, keyframe %d\n", st->index, current_sample,
3967  current_offset, current_dts, sample_size, distance, keyframe);
3968  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
3969  ff_rfps_add_frame(mov->fc, st, current_dts);
3970  }
3971 
3972  current_offset += sample_size;
3973  stream_size += sample_size;
3974 
3975  /* A negative sample duration is invalid based on the spec,
3976  * but some samples need it to correct the DTS. */
3977  if (sc->stts_data[stts_index].duration < 0) {
3978  av_log(mov->fc, AV_LOG_WARNING,
3979  "Invalid SampleDelta %d in STTS, at %d st:%d\n",
3980  sc->stts_data[stts_index].duration, stts_index,
3981  st->index);
3982  dts_correction += sc->stts_data[stts_index].duration - 1;
3983  sc->stts_data[stts_index].duration = 1;
3984  }
3985  current_dts += sc->stts_data[stts_index].duration;
3986  if (!dts_correction || current_dts + dts_correction > last_dts) {
3987  current_dts += dts_correction;
3988  dts_correction = 0;
3989  } else {
3990  /* Avoid creating non-monotonous DTS */
3991  dts_correction += current_dts - last_dts - 1;
3992  current_dts = last_dts + 1;
3993  }
3994  last_dts = current_dts;
3995  distance++;
3996  stts_sample++;
3997  current_sample++;
3998  if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
3999  stts_sample = 0;
4000  stts_index++;
4001  }
4002  }
4003  }
4004  if (st->duration > 0)
4005  st->codecpar->bit_rate = stream_size*8*sc->time_scale/st->duration;
4006  } else {
4007  unsigned chunk_samples, total = 0;
4008 
4009  if (!sc->chunk_count)
4010  return;
4011 
4012  // compute total chunk count
4013  for (i = 0; i < sc->stsc_count; i++) {
4014  unsigned count, chunk_count;
4015 
4016  chunk_samples = sc->stsc_data[i].count;
4017  if (i != sc->stsc_count - 1 &&
4018  sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
4019  av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
4020  return;
4021  }
4022 
4023  if (sc->samples_per_frame >= 160) { // gsm
4024  count = chunk_samples / sc->samples_per_frame;
4025  } else if (sc->samples_per_frame > 1) {
4026  unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
4027  count = (chunk_samples+samples-1) / samples;
4028  } else {
4029  count = (chunk_samples+1023) / 1024;
4030  }
4031 
4032  if (mov_stsc_index_valid(i, sc->stsc_count))
4033  chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
4034  else
4035  chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
4036  total += chunk_count * count;
4037  }
4038 
4039  av_log(mov->fc, AV_LOG_TRACE, "chunk count %u\n", total);
4040  if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
4041  return;
4043  st->nb_index_entries + total,
4044  sizeof(*st->index_entries)) < 0) {
4045  st->nb_index_entries = 0;
4046  return;
4047  }
4048  st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
4049 
4050  // populate index
4051  for (i = 0; i < sc->chunk_count; i++) {
4052  current_offset = sc->chunk_offsets[i];
4053  if (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
4054  i + 1 == sc->stsc_data[stsc_index + 1].first)
4055  stsc_index++;
4056  chunk_samples = sc->stsc_data[stsc_index].count;
4057 
4058  while (chunk_samples > 0) {
4059  AVIndexEntry *e;
4060  unsigned size, samples;
4061 
4062  if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
4064  "Zero bytes per frame, but %d samples per frame",
4065  sc->samples_per_frame);
4066  return;
4067  }
4068 
4069  if (sc->samples_per_frame >= 160) { // gsm
4070  samples = sc->samples_per_frame;
4071  size = sc->bytes_per_frame;
4072  } else {
4073  if (sc->samples_per_frame > 1) {
4074  samples = FFMIN((1024 / sc->samples_per_frame)*
4075  sc->samples_per_frame, chunk_samples);
4076  size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
4077  } else {
4078  samples = FFMIN(1024, chunk_samples);
4079  size = samples * sc->sample_size;
4080  }
4081  }
4082 
4083  if (st->nb_index_entries >= total) {
4084  av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %u\n", total);
4085  return;
4086  }
4087  if (size > 0x3FFFFFFF) {
4088  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", size);
4089  return;
4090  }
4091  e = &st->index_entries[st->nb_index_entries++];
4092  e->pos = current_offset;
4093  e->timestamp = current_dts;
4094  e->size = size;
4095  e->min_distance = 0;
4096  e->flags = AVINDEX_KEYFRAME;
4097  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
4098  "size %u, duration %u\n", st->index, i, current_offset, current_dts,
4099  size, samples);
4100 
4101  current_offset += size;
4102  current_dts += samples;
4103  chunk_samples -= samples;
4104  }
4105  }
4106  }
4107 
4108  if (!mov->ignore_editlist && mov->advanced_editlist) {
4109  // Fix index according to edit lists.
4110  mov_fix_index(mov, st);
4111  }
4112 
4113  // Update start time of the stream.
4115  st->start_time = st->index_entries[0].timestamp + sc->dts_shift;
4116  if (sc->ctts_data) {
4117  st->start_time += sc->ctts_data[0].duration;
4118  }
4119  }
4120 
4121  mov_estimate_video_delay(mov, st);
4122 }
4123 
4124 static int test_same_origin(const char *src, const char *ref) {
4125  char src_proto[64];
4126  char ref_proto[64];
4127  char src_auth[256];
4128  char ref_auth[256];
4129  char src_host[256];
4130  char ref_host[256];
4131  int src_port=-1;
4132  int ref_port=-1;
4133 
4134  av_url_split(src_proto, sizeof(src_proto), src_auth, sizeof(src_auth), src_host, sizeof(src_host), &src_port, NULL, 0, src);
4135  av_url_split(ref_proto, sizeof(ref_proto), ref_auth, sizeof(ref_auth), ref_host, sizeof(ref_host), &ref_port, NULL, 0, ref);
4136 
4137  if (strlen(src) == 0) {
4138  return -1;
4139  } else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
4140  strlen(ref_auth) + 1 >= sizeof(ref_auth) ||
4141  strlen(src_host) + 1 >= sizeof(src_host) ||
4142  strlen(ref_host) + 1 >= sizeof(ref_host)) {
4143  return 0;
4144  } else if (strcmp(src_proto, ref_proto) ||
4145  strcmp(src_auth, ref_auth) ||
4146  strcmp(src_host, ref_host) ||
4147  src_port != ref_port) {
4148  return 0;
4149  } else
4150  return 1;
4151 }
4152 
4153 static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
4154 {
4155  /* try relative path, we do not try the absolute because it can leak information about our
4156  system to an attacker */
4157  if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
4158  char filename[1025];
4159  const char *src_path;
4160  int i, l;
4161 
4162  /* find a source dir */
4163  src_path = strrchr(src, '/');
4164  if (src_path)
4165  src_path++;
4166  else
4167  src_path = src;
4168 
4169  /* find a next level down to target */
4170  for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
4171  if (ref->path[l] == '/') {
4172  if (i == ref->nlvl_to - 1)
4173  break;
4174  else
4175  i++;
4176  }
4177 
4178  /* compose filename if next level down to target was found */
4179  if (i == ref->nlvl_to - 1 && src_path - src < sizeof(filename)) {
4180  memcpy(filename, src, src_path - src);
4181  filename[src_path - src] = 0;
4182 
4183  for (i = 1; i < ref->nlvl_from; i++)
4184  av_strlcat(filename, "../", sizeof(filename));
4185 
4186  av_strlcat(filename, ref->path + l + 1, sizeof(filename));
4187  if (!c->use_absolute_path) {
4188  int same_origin = test_same_origin(src, filename);
4189 
4190  if (!same_origin) {
4191  av_log(c->fc, AV_LOG_ERROR,
4192  "Reference with mismatching origin, %s not tried for security reasons, "
4193  "set demuxer option use_absolute_path to allow it anyway\n",
4194  ref->path);
4195  return AVERROR(ENOENT);
4196  }
4197 
4198  if (strstr(ref->path + l + 1, "..") ||
4199  strstr(ref->path + l + 1, ":") ||
4200  (ref->nlvl_from > 1 && same_origin < 0) ||
4201  (filename[0] == '/' && src_path == src))
4202  return AVERROR(ENOENT);
4203  }
4204 
4205  if (strlen(filename) + 1 == sizeof(filename))
4206  return AVERROR(ENOENT);
4207  if (!c->fc->io_open(c->fc, pb, filename, AVIO_FLAG_READ, NULL))
4208  return 0;
4209  }
4210  } else if (c->use_absolute_path) {
4211  av_log(c->fc, AV_LOG_WARNING, "Using absolute path on user request, "
4212  "this is a possible security issue\n");
4213  if (!c->fc->io_open(c->fc, pb, ref->path, AVIO_FLAG_READ, NULL))
4214  return 0;
4215  } else {
4216  av_log(c->fc, AV_LOG_ERROR,
4217  "Absolute path %s not tried for security reasons, "
4218  "set demuxer option use_absolute_path to allow absolute paths\n",
4219  ref->path);
4220  }
4221 
4222  return AVERROR(ENOENT);
4223 }
4224 
4226 {
4227  if (sc->time_scale <= 0) {
4228  av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
4229  sc->time_scale = c->time_scale;
4230  if (sc->time_scale <= 0)
4231  sc->time_scale = 1;
4232  }
4233 }
4234 
4236 {
4237  AVStream *st;
4238  MOVStreamContext *sc;
4239  int ret;
4240 
4241  st = avformat_new_stream(c->fc, NULL);
4242  if (!st) return AVERROR(ENOMEM);
4243  st->id = -1;
4244  sc = av_mallocz(sizeof(MOVStreamContext));
4245  if (!sc) return AVERROR(ENOMEM);
4246 
4247  st->priv_data = sc;
4249  sc->ffindex = st->index;
4250  c->trak_index = st->index;
4251 
4252  if ((ret = mov_read_default(c, pb, atom)) < 0)
4253  return ret;
4254 
4255  c->trak_index = -1;
4256 
4257  // Here stsc refers to a chunk not described in stco. This is technically invalid,
4258  // but we can overlook it (clearing stsc) whenever stts_count == 0 (indicating no samples).
4259  if (!sc->chunk_count && !sc->stts_count && sc->stsc_count) {
4260  sc->stsc_count = 0;
4261  av_freep(&sc->stsc_data);
4262  }
4263 
4264  /* sanity checks */
4265  if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
4266  (!sc->sample_size && !sc->sample_count))) ||
4267  (!sc->chunk_count && sc->sample_count)) {
4268  av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
4269  st->index);
4270  return 0;
4271  }
4272  if (sc->stsc_count && sc->stsc_data[ sc->stsc_count - 1 ].first > sc->chunk_count) {
4273  av_log(c->fc, AV_LOG_ERROR, "stream %d, contradictionary STSC and STCO\n",
4274  st->index);
4275  return AVERROR_INVALIDDATA;
4276  }
4277 
4278  fix_timescale(c, sc);
4279 
4280  avpriv_set_pts_info(st, 64, 1, sc->time_scale);
4281 
4282  mov_build_index(c, st);
4283 
4284  if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
4285  MOVDref *dref = &sc->drefs[sc->dref_id - 1];
4286  if (c->enable_drefs) {
4287  if (mov_open_dref(c, &sc->pb, c->fc->url, dref) < 0)
4288  av_log(c->fc, AV_LOG_ERROR,
4289  "stream %d, error opening alias: path='%s', dir='%s', "
4290  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
4291  st->index, dref->path, dref->dir, dref->filename,
4292  dref->volume, dref->nlvl_from, dref->nlvl_to);
4293  } else {
4294  av_log(c->fc, AV_LOG_WARNING,
4295  "Skipped opening external track: "
4296  "stream %d, alias: path='%s', dir='%s', "
4297  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
4298  "Set enable_drefs to allow this.\n",
4299  st->index, dref->path, dref->dir, dref->filename,
4300  dref->volume, dref->nlvl_from, dref->nlvl_to);
4301  }
4302  } else {
4303  sc->pb = c->fc->pb;
4304  sc->pb_is_copied = 1;
4305  }
4306 
4307  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
4308  if (!st->sample_aspect_ratio.num && st->codecpar->width && st->codecpar->height &&
4309  sc->height && sc->width &&
4310  (st->codecpar->width != sc->width || st->codecpar->height != sc->height)) {
4311  st->sample_aspect_ratio = av_d2q(((double)st->codecpar->height * sc->width) /
4312  ((double)st->codecpar->width * sc->height), INT_MAX);
4313  }
4314 
4315 #if FF_API_R_FRAME_RATE
4316  if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
4318  sc->time_scale, sc->stts_data[0].duration, INT_MAX);
4319 #endif
4320  }
4321 
4322  // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
4323  if (!st->codecpar->extradata_size && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
4324  TAG_IS_AVCI(st->codecpar->codec_tag)) {
4325  ret = ff_generate_avci_extradata(st);
4326  if (ret < 0)
4327  return ret;
4328  }
4329 
4330  switch (st->codecpar->codec_id) {
4331 #if CONFIG_H261_DECODER
4332  case AV_CODEC_ID_H261:
4333 #endif
4334 #if CONFIG_H263_DECODER
4335  case AV_CODEC_ID_H263:
4336 #endif
4337 #if CONFIG_MPEG4_DECODER
4338  case AV_CODEC_ID_MPEG4:
4339 #endif
4340  st->codecpar->width = 0; /* let decoder init width/height */
4341  st->codecpar->height= 0;
4342  break;
4343  }
4344 
4345  // If the duration of the mp3 packets is not constant, then they could need a parser
4346  if (st->codecpar->codec_id == AV_CODEC_ID_MP3
4347  && sc->stts_count > 3
4348  && sc->stts_count*10 > st->nb_frames
4349  && sc->time_scale == st->codecpar->sample_rate) {
4351  }
4352  /* Do not need those anymore. */
4353  av_freep(&sc->chunk_offsets);
4354  av_freep(&sc->sample_sizes);
4355  av_freep(&sc->keyframes);
4356  av_freep(&sc->stts_data);
4357  av_freep(&sc->stps_data);
4358  av_freep(&sc->elst_data);
4359  av_freep(&sc->rap_group);
4360 
4361  return 0;
4362 }
4363 
4365 {
4366  int ret;
4367  c->itunes_metadata = 1;
4368  ret = mov_read_default(c, pb, atom);
4369  c->itunes_metadata = 0;
4370  return ret;
4371 }
4372 
4374 {
4375  uint32_t count;
4376  uint32_t i;
4377 
4378  if (atom.size < 8)
4379  return 0;
4380 
4381  avio_skip(pb, 4);
4382  count = avio_rb32(pb);
4383  if (count > UINT_MAX / sizeof(*c->meta_keys) - 1) {
4384  av_log(c->fc, AV_LOG_ERROR,
4385  "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
4386  return AVERROR_INVALIDDATA;
4387  }
4388 
4389  c->meta_keys_count = count + 1;
4390  c->meta_keys = av_mallocz(c->meta_keys_count * sizeof(*c->meta_keys));
4391  if (!c->meta_keys)
4392  return AVERROR(ENOMEM);
4393 
4394  for (i = 1; i <= count; ++i) {
4395  uint32_t key_size = avio_rb32(pb);
4396  uint32_t type = avio_rl32(pb);
4397  if (key_size < 8) {
4398  av_log(c->fc, AV_LOG_ERROR,
4399  "The key# %"PRIu32" in meta has invalid size:"
4400  "%"PRIu32"\n", i, key_size);
4401  return AVERROR_INVALIDDATA;
4402  }
4403  key_size -= 8;
4404  if (type != MKTAG('m','d','t','a')) {
4405  avio_skip(pb, key_size);
4406  }
4407  c->meta_keys[i] = av_mallocz(key_size + 1);
4408  if (!c->meta_keys[i])
4409  return AVERROR(ENOMEM);
4410  avio_read(pb, c->meta_keys[i], key_size);
4411  }
4412 
4413  return 0;
4414 }
4415 
4417 {
4418  int64_t end = av_sat_add64(avio_tell(pb), atom.size);
4419  uint8_t *key = NULL, *val = NULL, *mean = NULL;
4420  int i;
4421  int ret = 0;
4422  AVStream *st;
4423  MOVStreamContext *sc;
4424 
4425  if (c->fc->nb_streams < 1)
4426  return 0;
4427  st = c->fc->streams[c->fc->nb_streams-1];
4428  sc = st->priv_data;
4429 
4430  for (i = 0; i < 3; i++) {
4431  uint8_t **p;
4432  uint32_t len, tag;
4433 
4434  if (end - avio_tell(pb) <= 12)
4435  break;
4436 
4437  len = avio_rb32(pb);
4438  tag = avio_rl32(pb);
4439  avio_skip(pb, 4); // flags
4440 
4441  if (len < 12 || len - 12 > end - avio_tell(pb))
4442  break;
4443  len -= 12;
4444 
4445  if (tag == MKTAG('m', 'e', 'a', 'n'))
4446  p = &mean;
4447  else if (tag == MKTAG('n', 'a', 'm', 'e'))
4448  p = &key;
4449  else if (tag == MKTAG('d', 'a', 't', 'a') && len > 4) {
4450  avio_skip(pb, 4);
4451  len -= 4;
4452  p = &val;
4453  } else
4454  break;
4455 
4456  if (*p)
4457  break;
4458 
4459  *p = av_malloc(len + 1);
4460  if (!*p) {
4461  ret = AVERROR(ENOMEM);
4462  break;
4463  }
4464  ret = ffio_read_size(pb, *p, len);
4465  if (ret < 0) {
4466  av_freep(p);
4467  break;
4468  }
4469  (*p)[len] = 0;
4470  }
4471 
4472  if (mean && key && val) {
4473  if (strcmp(key, "iTunSMPB") == 0) {
4474  int priming, remainder, samples;
4475  if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
4476  if(priming>0 && priming<16384)
4477  sc->start_pad = priming;
4478  }
4479  }
4480  if (strcmp(key, "cdec") != 0) {
4481  av_dict_set(&c->fc->metadata, key, val,
4483  key = val = NULL;
4484  }
4485  } else {
4486  av_log(c->fc, AV_LOG_VERBOSE,
4487  "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
4488  }
4489 
4490  avio_seek(pb, end, SEEK_SET);
4491  av_freep(&key);
4492  av_freep(&val);
4493  av_freep(&mean);
4494  return ret;
4495 }
4496 
4498 {
4499  while (atom.size > 8) {
4500  uint32_t tag;
4501  if (avio_feof(pb))
4502  return AVERROR_EOF;
4503  tag = avio_rl32(pb);
4504  atom.size -= 4;
4505  if (tag == MKTAG('h','d','l','r')) {
4506  avio_seek(pb, -8, SEEK_CUR);
4507  atom.size += 8;
4508  return mov_read_default(c, pb, atom);
4509  }
4510  }
4511  return 0;
4512 }
4513 
4514 // return 1 when matrix is identity, 0 otherwise
4515 #define IS_MATRIX_IDENT(matrix) \
4516  ( (matrix)[0][0] == (1 << 16) && \
4517  (matrix)[1][1] == (1 << 16) && \
4518  (matrix)[2][2] == (1 << 30) && \
4519  !(matrix)[0][1] && !(matrix)[0][2] && \
4520  !(matrix)[1][0] && !(matrix)[1][2] && \
4521  !(matrix)[2][0] && !(matrix)[2][1])
4522 
4524 {
4525  int i, j, e;
4526  int width;
4527  int height;
4528  int display_matrix[3][3];
4529  int res_display_matrix[3][3] = { { 0 } };
4530  AVStream *st;
4531  MOVStreamContext *sc;
4532  int version;
4533  int flags;
4534 
4535  if (c->fc->nb_streams < 1)
4536  return 0;
4537  st = c->fc->streams[c->fc->nb_streams-1];
4538  sc = st->priv_data;
4539 
4540  // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
4541  // avoids corrupting AVStreams mapped to an earlier tkhd.
4542  if (st->id != -1)
4543  return AVERROR_INVALIDDATA;
4544 
4545  version = avio_r8(pb);
4546  flags = avio_rb24(pb);
4548 
4549  if (version == 1) {
4550  avio_rb64(pb);
4551  avio_rb64(pb);
4552  } else {
4553  avio_rb32(pb); /* creation time */
4554  avio_rb32(pb); /* modification time */
4555  }
4556  st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
4557  avio_rb32(pb); /* reserved */
4558 
4559  /* highlevel (considering edits) duration in movie timebase */
4560  (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
4561  avio_rb32(pb); /* reserved */
4562  avio_rb32(pb); /* reserved */
4563 
4564  avio_rb16(pb); /* layer */
4565  avio_rb16(pb); /* alternate group */
4566  avio_rb16(pb); /* volume */
4567  avio_rb16(pb); /* reserved */
4568 
4569  //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
4570  // they're kept in fixed point format through all calculations
4571  // save u,v,z to store the whole matrix in the AV_PKT_DATA_DISPLAYMATRIX
4572  // side data, but the scale factor is not needed to calculate aspect ratio
4573  for (i = 0; i < 3; i++) {
4574  display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
4575  display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
4576  display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
4577  }
4578 
4579  width = avio_rb32(pb); // 16.16 fixed point track width
4580  height = avio_rb32(pb); // 16.16 fixed point track height
4581  sc->width = width >> 16;
4582  sc->height = height >> 16;
4583 
4584  // apply the moov display matrix (after the tkhd one)
4585  for (i = 0; i < 3; i++) {
4586  const int sh[3] = { 16, 16, 30 };
4587  for (j = 0; j < 3; j++) {
4588  for (e = 0; e < 3; e++) {
4589  res_display_matrix[i][j] +=
4590  ((int64_t) display_matrix[i][e] *
4591  c->movie_display_matrix[e][j]) >> sh[e];
4592  }
4593  }
4594  }
4595 
4596  // save the matrix when it is not the default identity
4597  if (!IS_MATRIX_IDENT(res_display_matrix)) {
4598  double rotate;
4599 
4600  av_freep(&sc->display_matrix);
4601  sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
4602  if (!sc->display_matrix)
4603  return AVERROR(ENOMEM);
4604 
4605  for (i = 0; i < 3; i++)
4606  for (j = 0; j < 3; j++)
4607  sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
4608 
4611  if (!isnan(rotate)) {
4612  char rotate_buf[64];
4613  rotate = -rotate;
4614  if (rotate < 0) // for backward compatibility
4615  rotate += 360;
4616  snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
4617  av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
4618  }
4619 #endif
4620  }
4621 
4622  // transform the display width/height according to the matrix
4623  // to keep the same scale, use [width height 1<<16]
4624  if (width && height && sc->display_matrix) {
4625  double disp_transform[2];
4626 
4627  for (i = 0; i < 2; i++)
4628  disp_transform[i] = hypot(sc->display_matrix[0 + i],
4629  sc->display_matrix[3 + i]);
4630 
4631  if (disp_transform[0] > 0 && disp_transform[1] > 0 &&
4632  disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4633  fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4635  disp_transform[0] / disp_transform[1],
4636  INT_MAX);
4637  }
4638  return 0;
4639 }
4640 
4642 {
4643  MOVFragment *frag = &c->fragment;
4644  MOVTrackExt *trex = NULL;
4645  int flags, track_id, i;
4646  MOVFragmentStreamInfo * frag_stream_info;
4647 
4648  avio_r8(pb); /* version */
4649  flags = avio_rb24(pb);
4650 
4651  track_id = avio_rb32(pb);
4652  if (!track_id)
4653  return AVERROR_INVALIDDATA;
4654  for (i = 0; i < c->trex_count; i++)
4655  if (c->trex_data[i].track_id == track_id) {
4656  trex = &c->trex_data[i];
4657  break;
4658  }
4659  if (!trex) {
4660  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding trex (id %u)\n", track_id);
4661  return 0;
4662  }
4663  c->fragment.found_tfhd = 1;
4664  frag->track_id = track_id;
4665  set_frag_stream(&c->frag_index, track_id);
4666 
4669  frag->moof_offset : frag->implicit_offset;
4670  frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
4671 
4673  avio_rb32(pb) : trex->duration;
4674  frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
4675  avio_rb32(pb) : trex->size;
4676  frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
4677  avio_rb32(pb) : trex->flags;
4678  av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
4679 
4680  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4681  if (frag_stream_info)
4682  frag_stream_info->next_trun_dts = AV_NOPTS_VALUE;
4683 
4684  return 0;
4685 }
4686 
4688 {
4689  unsigned i, num;
4690  void *new_tracks;
4691 
4692  num = atom.size / 4;
4693  if (!(new_tracks = av_malloc_array(num, sizeof(int))))
4694  return AVERROR(ENOMEM);
4695 
4696  av_free(c->chapter_tracks);
4697  c->chapter_tracks = new_tracks;
4698  c->nb_chapter_tracks = num;
4699 
4700  for (i = 0; i < num && !pb->eof_reached; i++)
4701  c->chapter_tracks[i] = avio_rb32(pb);
4702 
4703  return 0;
4704 }
4705 
4707 {
4708  MOVTrackExt *trex;
4709  int err;
4710 
4711  if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
4712  return AVERROR_INVALIDDATA;
4713  if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
4714  sizeof(*c->trex_data))) < 0) {
4715  c->trex_count = 0;
4716  return err;
4717  }
4718 
4719  c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
4720 
4721  trex = &c->trex_data[c->trex_count++];
4722  avio_r8(pb); /* version */
4723  avio_rb24(pb); /* flags */
4724  trex->track_id = avio_rb32(pb);
4725  trex->stsd_id = avio_rb32(pb);
4726  trex->duration = avio_rb32(pb);
4727  trex->size = avio_rb32(pb);
4728  trex->flags = avio_rb32(pb);
4729  return 0;
4730 }
4731 
4733 {
4734  MOVFragment *frag = &c->fragment;
4735  AVStream *st = NULL;
4736  MOVStreamContext *sc;
4737  int version, i;
4738  MOVFragmentStreamInfo * frag_stream_info;
4739  int64_t base_media_decode_time;
4740 
4741  for (i = 0; i < c->fc->nb_streams; i++) {
4742  if (c->fc->streams[i]->id == frag->track_id) {
4743  st = c->fc->streams[i];
4744  break;
4745  }
4746  }
4747  if (!st) {
4748  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4749  return 0;
4750  }
4751  sc = st->priv_data;
4752  if (sc->pseudo_stream_id + 1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4753  return 0;
4754  version = avio_r8(pb);
4755  avio_rb24(pb); /* flags */
4756  if (version) {
4757  base_media_decode_time = avio_rb64(pb);
4758  } else {
4759  base_media_decode_time = avio_rb32(pb);
4760  }
4761 
4762  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4763  if (frag_stream_info)
4764  frag_stream_info->tfdt_dts = base_media_decode_time;
4765  sc->track_end = base_media_decode_time;
4766 
4767  return 0;
4768 }
4769 
4771 {
4772  MOVFragment *frag = &c->fragment;
4773  AVStream *st = NULL;
4774  MOVStreamContext *sc;
4775  MOVStts *ctts_data;
4776  uint64_t offset;
4777  int64_t dts, pts = AV_NOPTS_VALUE;
4778  int data_offset = 0;
4779  unsigned entries, first_sample_flags = frag->flags;
4780  int flags, distance, i;
4781  int64_t prev_dts = AV_NOPTS_VALUE;
4782  int next_frag_index = -1, index_entry_pos;
4783  size_t requested_size;
4784  size_t old_ctts_allocated_size;
4785  AVIndexEntry *new_entries;
4786  MOVFragmentStreamInfo * frag_stream_info;
4787 
4788  if (!frag->found_tfhd) {
4789  av_log(c->fc, AV_LOG_ERROR, "trun track id unknown, no tfhd was found\n");
4790  return AVERROR_INVALIDDATA;
4791  }
4792 
4793  for (i = 0; i < c->fc->nb_streams; i++) {
4794  if (c->fc->streams[i]->id == frag->track_id) {
4795  st = c->fc->streams[i];
4796  break;
4797  }
4798  }
4799  if (!st) {
4800  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4801  return 0;
4802  }
4803  sc = st->priv_data;
4804  if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4805  return 0;
4806 
4807  // Find the next frag_index index that has a valid index_entry for
4808  // the current track_id.
4809  //
4810  // A valid index_entry means the trun for the fragment was read
4811  // and it's samples are in index_entries at the given position.
4812  // New index entries will be inserted before the index_entry found.
4813  index_entry_pos = st->nb_index_entries;
4814  for (i = c->frag_index.current + 1; i < c->frag_index.nb_items; i++) {
4815  frag_stream_info = get_frag_stream_info(&c->frag_index, i, frag->track_id);
4816  if (frag_stream_info && frag_stream_info->index_entry >= 0) {
4817  next_frag_index = i;
4818  index_entry_pos = frag_stream_info->index_entry;
4819  break;
4820  }
4821  }
4822  av_assert0(index_entry_pos <= st->nb_index_entries);
4823 
4824  avio_r8(pb); /* version */
4825  flags = avio_rb24(pb);
4826  entries = avio_rb32(pb);
4827  av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
4828 
4829  if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
4830  return AVERROR_INVALIDDATA;
4831  if (flags & MOV_TRUN_DATA_OFFSET) data_offset = avio_rb32(pb);
4832  if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
4833 
4834  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4835  if (frag_stream_info) {
4836  if (frag_stream_info->next_trun_dts != AV_NOPTS_VALUE) {
4837  dts = frag_stream_info->next_trun_dts - sc->time_offset;
4838  } else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
4839  c->use_mfra_for == FF_MOV_FLAG_MFRA_PTS) {
4840  pts = frag_stream_info->first_tfra_pts;
4841  av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
4842  ", using it for pts\n", pts);
4843  } else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
4844  c->use_mfra_for == FF_MOV_FLAG_MFRA_DTS) {
4845  dts = frag_stream_info->first_tfra_pts;
4846  av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
4847  ", using it for dts\n", pts);
4848  } else if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE) {
4849  // FIXME: sidx earliest_presentation_time is *PTS*, s.b.
4850  // pts = frag_stream_info->sidx_pts;
4851  dts = frag_stream_info->sidx_pts - sc->time_offset;
4852  av_log(c->fc, AV_LOG_DEBUG, "found sidx time %"PRId64
4853  ", using it for pts\n", pts);
4854  } else if (frag_stream_info->tfdt_dts != AV_NOPTS_VALUE) {
4855  dts = frag_stream_info->tfdt_dts - sc->time_offset;
4856  av_log(c->fc, AV_LOG_DEBUG, "found tfdt time %"PRId64
4857  ", using it for dts\n", dts);
4858  } else {
4859  dts = sc->track_end - sc->time_offset;
4860  av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4861  ", using it for dts\n", dts);
4862  }
4863  } else {
4864  dts = sc->track_end - sc->time_offset;
4865  av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4866  ", using it for dts\n", dts);
4867  }
4868  offset = frag->base_data_offset + data_offset;
4869  distance = 0;
4870  av_log(c->fc, AV_LOG_TRACE, "first sample flags 0x%x\n", first_sample_flags);
4871 
4872  // realloc space for new index entries
4873  if((uint64_t)st->nb_index_entries + entries >= UINT_MAX / sizeof(AVIndexEntry)) {
4874  entries = UINT_MAX / sizeof(AVIndexEntry) - st->nb_index_entries;
4875  av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n");
4876  }
4877  if (entries == 0)
4878  return 0;
4879 
4880  requested_size = (st->nb_index_entries + entries) * sizeof(AVIndexEntry);
4881  new_entries = av_fast_realloc(st->index_entries,
4883  requested_size);
4884  if (!new_entries)
4885  return AVERROR(ENOMEM);
4886  st->index_entries= new_entries;
4887 
4888  requested_size = (st->nb_index_entries + entries) * sizeof(*sc->ctts_data);
4889  old_ctts_allocated_size = sc->ctts_allocated_size;
4890  ctts_data = av_fast_realloc(sc->ctts_data, &sc->ctts_allocated_size,
4891  requested_size);
4892  if (!ctts_data)
4893  return AVERROR(ENOMEM);
4894  sc->ctts_data = ctts_data;
4895 
4896  // In case there were samples without ctts entries, ensure they get
4897  // zero valued entries. This ensures clips which mix boxes with and
4898  // without ctts entries don't pickup uninitialized data.
4899  memset((uint8_t*)(sc->ctts_data) + old_ctts_allocated_size, 0,
4900  sc->ctts_allocated_size - old_ctts_allocated_size);
4901 
4902  if (index_entry_pos < st->nb_index_entries) {
4903  // Make hole in index_entries and ctts_data for new samples
4904  memmove(st->index_entries + index_entry_pos + entries,
4905  st->index_entries + index_entry_pos,
4906  sizeof(*st->index_entries) *
4907  (st->nb_index_entries - index_entry_pos));
4908  memmove(sc->ctts_data + index_entry_pos + entries,
4909  sc->ctts_data + index_entry_pos,
4910  sizeof(*sc->ctts_data) * (sc->ctts_count - index_entry_pos));
4911  if (index_entry_pos < sc->current_sample) {
4912  sc->current_sample += entries;
4913  }
4914  }
4915 
4916  st->nb_index_entries += entries;
4917  sc->ctts_count = st->nb_index_entries;
4918 
4919  // Record the index_entry position in frag_index of this fragment
4920  if (frag_stream_info)
4921  frag_stream_info->index_entry = index_entry_pos;
4922 
4923  if (index_entry_pos > 0)
4924  prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4925 
4926  for (i = 0; i < entries && !pb->eof_reached; i++) {
4927  unsigned sample_size = frag->size;
4928  int sample_flags = i ? frag->flags : first_sample_flags;
4929  unsigned sample_duration = frag->duration;
4930  unsigned ctts_duration = 0;
4931  int keyframe = 0;
4932  int index_entry_flags = 0;
4933 
4934  if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
4935  if (flags & MOV_TRUN_SAMPLE_SIZE) sample_size = avio_rb32(pb);
4936  if (flags & MOV_TRUN_SAMPLE_FLAGS) sample_flags = avio_rb32(pb);
4937  if (flags & MOV_TRUN_SAMPLE_CTS) ctts_duration = avio_rb32(pb);
4938 
4939  mov_update_dts_shift(sc, ctts_duration, c->fc);
4940  if (pts != AV_NOPTS_VALUE) {
4941  dts = pts - sc->dts_shift;
4942  if (flags & MOV_TRUN_SAMPLE_CTS) {
4943  dts -= ctts_duration;
4944  } else {
4945  dts -= sc->time_offset;
4946  }
4947  av_log(c->fc, AV_LOG_DEBUG,
4948  "pts %"PRId64" calculated dts %"PRId64
4949  " sc->dts_shift %d ctts.duration %d"
4950  " sc->time_offset %"PRId64
4951  " flags & MOV_TRUN_SAMPLE_CTS %d\n",
4952  pts, dts,
4953  sc->dts_shift, ctts_duration,
4955  pts = AV_NOPTS_VALUE;
4956  }
4957 
4959  keyframe = 1;
4960  else
4961  keyframe =
4962  !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
4964  if (keyframe) {
4965  distance = 0;
4966  index_entry_flags |= AVINDEX_KEYFRAME;
4967  }
4968  // Fragments can overlap in time. Discard overlapping frames after
4969  // decoding.
4970  if (prev_dts >= dts)
4971  index_entry_flags |= AVINDEX_DISCARD_FRAME;
4972 
4973  st->index_entries[index_entry_pos].pos = offset;
4974  st->index_entries[index_entry_pos].timestamp = dts;
4975  st->index_entries[index_entry_pos].size= sample_size;
4976  st->index_entries[index_entry_pos].min_distance= distance;
4977  st->index_entries[index_entry_pos].flags = index_entry_flags;
4978 
4979  sc->ctts_data[index_entry_pos].count = 1;
4980  sc->ctts_data[index_entry_pos].duration = ctts_duration;
4981  index_entry_pos++;
4982 
4983  av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
4984  "size %u, distance %d, keyframe %d\n", st->index,
4985  index_entry_pos, offset, dts, sample_size, distance, keyframe);
4986  distance++;
4987  dts += sample_duration;
4988  offset += sample_size;
4989  sc->data_size += sample_size;
4990 
4991  if (sample_duration <= INT64_MAX - sc->duration_for_fps &&
4992  1 <= INT_MAX - sc->nb_frames_for_fps
4993  ) {
4994  sc->duration_for_fps += sample_duration;
4995  sc->nb_frames_for_fps ++;
4996  }
4997  }
4998  if (frag_stream_info)
4999  frag_stream_info->next_trun_dts = dts + sc->time_offset;
5000  if (i < entries) {
5001  // EOF found before reading all entries. Fix the hole this would
5002  // leave in index_entries and ctts_data
5003  int gap = entries - i;
5004  memmove(st->index_entries + index_entry_pos,
5005  st->index_entries + index_entry_pos + gap,
5006  sizeof(*st->index_entries) *
5007  (st->nb_index_entries - (index_entry_pos + gap)));
5008  memmove(sc->ctts_data + index_entry_pos,
5009  sc->ctts_data + index_entry_pos + gap,
5010  sizeof(*sc->ctts_data) *
5011  (sc->ctts_count - (index_entry_pos + gap)));
5012 
5013  st->nb_index_entries -= gap;
5014  sc->ctts_count -= gap;
5015  if (index_entry_pos < sc->current_sample) {
5016  sc->current_sample -= gap;
5017  }
5018  entries = i;
5019  }
5020 
5021  // The end of this new fragment may overlap in time with the start
5022  // of the next fragment in index_entries. Mark the samples in the next
5023  // fragment that overlap with AVINDEX_DISCARD_FRAME
5024  prev_dts = AV_NOPTS_VALUE;
5025  if (index_entry_pos > 0)
5026  prev_dts = st->index_entries[index_entry_pos-1].timestamp;
5027  for (i = index_entry_pos; i < st->nb_index_entries; i++) {
5028  if (prev_dts < st->index_entries[i].timestamp)
5029  break;
5031  }
5032 
5033  // If a hole was created to insert the new index_entries into,
5034  // the index_entry recorded for all subsequent moof must
5035  // be incremented by the number of entries inserted.
5036  fix_frag_index_entries(&c->frag_index, next_frag_index,
5037  frag->track_id, entries);
5038 
5039  if (pb->eof_reached) {
5040  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted TRUN atom\n");
5041  return AVERROR_EOF;
5042  }
5043 
5044  frag->implicit_offset = offset;
5045 
5046  sc->track_end = dts + sc->time_offset;
5047  if (st->duration < sc->track_end)
5048  st->duration = sc->track_end;
5049 
5050  return 0;
5051 }
5052 
5054 {
5055  int64_t stream_size = avio_size(pb);
5056  int64_t offset = av_sat_add64(avio_tell(pb), atom.size), pts, timestamp;
5057  uint8_t version, is_complete;
5058  int64_t offadd;
5059  unsigned i, j, track_id, item_count;
5060  AVStream *st = NULL;
5061  AVStream *ref_st = NULL;
5062  MOVStreamContext *sc, *ref_sc = NULL;
5063  AVRational timescale;
5064 
5065  version = avio_r8(pb);
5066  if (version > 1) {
5067  avpriv_request_sample(c->fc, "sidx version %u", version);
5068  return 0;
5069  }
5070 
5071  avio_rb24(pb); // flags
5072 
5073  track_id = avio_rb32(pb); // Reference ID
5074  for (i = 0; i < c->fc->nb_streams; i++) {
5075  if (c->fc->streams[i]->id == track_id) {
5076  st = c->fc->streams[i];
5077  break;
5078  }
5079  }
5080  if (!st) {
5081  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %d\n", track_id);
5082  return 0;
5083  }
5084 
5085  sc = st->priv_data;
5086 
5087  timescale = av_make_q(1, avio_rb32(pb));
5088 
5089  if (timescale.den <= 0) {
5090  av_log(c->fc, AV_LOG_ERROR, "Invalid sidx timescale 1/%d\n", timescale.den);
5091  return AVERROR_INVALIDDATA;
5092  }
5093 
5094  if (version == 0) {
5095  pts = avio_rb32(pb);
5096  offadd= avio_rb32(pb);
5097  } else {
5098  pts = avio_rb64(pb);
5099  offadd= avio_rb64(pb);
5100  }
5101  if (av_sat_add64(offset, offadd) != offset + (uint64_t)offadd)
5102  return AVERROR_INVALIDDATA;
5103 
5104  offset += (uint64_t)offadd;
5105 
5106  avio_rb16(pb); // reserved
5107 
5108  item_count = avio_rb16(pb);
5109 
5110  for (i = 0; i < item_count; i++) {
5111  int index;
5112  MOVFragmentStreamInfo * frag_stream_info;
5113  uint32_t size = avio_rb32(pb);
5114  uint32_t duration = avio_rb32(pb);
5115  if (size & 0x80000000) {
5116  avpriv_request_sample(c->fc, "sidx reference_type 1");
5117  return AVERROR_PATCHWELCOME;
5118  }
5119  avio_rb32(pb); // sap_flags
5120  timestamp = av_rescale_q(pts, timescale, st->time_base);
5121 
5123  frag_stream_info = get_frag_stream_info(&c->frag_index, index, track_id);
5124  if (frag_stream_info)
5125  frag_stream_info->sidx_pts = timestamp;
5126 
5127  if (av_sat_add64(offset, size) != offset + size)
5128  return AVERROR_INVALIDDATA;
5129  offset += size;
5130  pts += duration;
5131  }
5132 
5133  st->duration = sc->track_end = pts;
5134 
5135  sc->has_sidx = 1;
5136 
5137  // See if the remaining bytes are just an mfra which we can ignore.
5138  is_complete = offset == stream_size;
5139  if (!is_complete && (pb->seekable & AVIO_SEEKABLE_NORMAL)) {
5140  int64_t ret;
5141  int64_t original_pos = avio_tell(pb);
5142  if (!c->have_read_mfra_size) {
5143  if ((ret = avio_seek(pb, stream_size - 4, SEEK_SET)) < 0)
5144  return ret;
5145  c->mfra_size = avio_rb32(pb);
5146  c->have_read_mfra_size = 1;
5147  if ((ret = avio_seek(pb, original_pos, SEEK_SET)) < 0)
5148  return ret;
5149  }
5150  if (offset + c->mfra_size == stream_size)
5151  is_complete = 1;
5152  }
5153 
5154  if (is_complete) {
5155  // Find first entry in fragment index that came from an sidx.
5156  // This will pretty much always be the first entry.
5157  for (i = 0; i < c->frag_index.nb_items; i++) {
5158  MOVFragmentIndexItem * item = &c->frag_index.item[i];
5159  for (j = 0; ref_st == NULL && j < item->nb_stream_info; j++) {
5160  MOVFragmentStreamInfo * si;
5161  si = &item->stream_info[j];
5162  if (si->sidx_pts != AV_NOPTS_VALUE) {
5163  ref_st = c->fc->streams[j];
5164  ref_sc = ref_st->priv_data;
5165  break;
5166  }
5167  }
5168  }
5169  if (ref_st) for (i = 0; i < c->fc->nb_streams; i++) {
5170  st = c->fc->streams[i];
5171  sc = st->priv_data;
5172  if (!sc->has_sidx) {
5173  st->duration = sc->track_end = av_rescale(ref_st->duration, sc->time_scale, ref_sc->time_scale);
5174  }
5175  }
5176 
5177  c->frag_index.complete = 1;
5178  }
5179 
5180  return 0;
5181 }
5182 
5183 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
5184 /* like the files created with Adobe Premiere 5.0, for samples see */
5185 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
5187 {
5188  int err;
5189 
5190  if (atom.size < 8)
5191  return 0; /* continue */
5192  if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
5193  avio_skip(pb, atom.size - 4);
5194  return 0;
5195  }
5196  atom.type = avio_rl32(pb);
5197  atom.size -= 8;
5198  if (atom.type != MKTAG('m','d','a','t')) {
5199  avio_skip(pb, atom.size);
5200  return 0;
5201  }
5202  err = mov_read_mdat(c, pb, atom);
5203  return err;
5204 }
5205 
5207 {
5208 #if CONFIG_ZLIB
5209  AVIOContext ctx;
5210  uint8_t *cmov_data;
5211  uint8_t *moov_data; /* uncompressed data */
5212  long cmov_len, moov_len;
5213  int ret = -1;
5214 
5215  avio_rb32(pb); /* dcom atom */
5216  if (avio_rl32(pb) != MKTAG('d','c','o','m'))
5217  return AVERROR_INVALIDDATA;
5218  if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
5219  av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
5220  return AVERROR_INVALIDDATA;
5221  }
5222  avio_rb32(pb); /* cmvd atom */
5223  if (avio_rl32(pb) != MKTAG('c','m','v','d'))
5224  return AVERROR_INVALIDDATA;
5225  moov_len = avio_rb32(pb); /* uncompressed size */
5226  cmov_len = atom.size - 6 * 4;
5227 
5228  cmov_data = av_malloc(cmov_len);
5229  if (!cmov_data)
5230  return AVERROR(ENOMEM);
5231  moov_data = av_malloc(moov_len);
5232  if (!moov_data) {
5233  av_free(cmov_data);
5234  return AVERROR(ENOMEM);
5235  }
5236  ret = ffio_read_size(pb, cmov_data, cmov_len);
5237  if (ret < 0)
5238  goto free_and_return;
5239 
5240  ret = AVERROR_INVALIDDATA;
5241  if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
5242  goto free_and_return;
5243  if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
5244  goto free_and_return;
5245  ctx.seekable = AVIO_SEEKABLE_NORMAL;
5246  atom.type = MKTAG('m','o','o','v');
5247  atom.size = moov_len;
5248  ret = mov_read_default(c, &ctx, atom);
5249 free_and_return:
5250  av_free(moov_data);
5251  av_free(cmov_data);
5252  return ret;
5253 #else
5254  av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
5255  return AVERROR(ENOSYS);
5256 #endif
5257 }
5258 
5259 /* edit list atom */
5261 {
5262  MOVStreamContext *sc;
5263  int i, edit_count, version;
5264  int64_t elst_entry_size;
5265 
5266  if (c->fc->nb_streams < 1 || c->ignore_editlist)
5267  return 0;
5268  sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
5269 
5270  version = avio_r8(pb); /* version */
5271  avio_rb24(pb); /* flags */
5272  edit_count = avio_rb32(pb); /* entries */
5273  atom.size -= 8;
5274 
5275  elst_entry_size = version == 1 ? 20 : 12;
5276  if (atom.size != edit_count * elst_entry_size) {
5277  if (c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
5278  av_log(c->fc, AV_LOG_ERROR, "Invalid edit list entry_count: %d for elst atom of size: %"PRId64" bytes.\n",
5279  edit_count, atom.size + 8);
5280  return AVERROR_INVALIDDATA;
5281  } else {
5282  edit_count = atom.size / elst_entry_size;
5283  if (edit_count * elst_entry_size != atom.size) {
5284  av_log(c->fc, AV_LOG_WARNING, "ELST atom of %"PRId64" bytes, bigger than %d entries.\n", atom.size, edit_count);
5285  }
5286  }
5287  }
5288 
5289  if (!edit_count)
5290  return 0;
5291  if (sc->elst_data)
5292  av_log(c->fc, AV_LOG_WARNING, "Duplicated ELST atom\n");
5293  av_free(sc->elst_data);
5294  sc->elst_count = 0;
5295  sc->elst_data = av_malloc_array(edit_count, sizeof(*sc->elst_data));
5296  if (!sc->elst_data)
5297  return AVERROR(ENOMEM);
5298 
5299  av_log(c->fc, AV_LOG_TRACE, "track[%u].edit_count = %i\n", c->fc->nb_streams - 1, edit_count);
5300  for (i = 0; i < edit_count && atom.size > 0 && !pb->eof_reached; i++) {
5301  MOVElst *e = &sc->elst_data[i];
5302 
5303  if (version == 1) {
5304  e->duration = avio_rb64(pb);
5305  e->time = avio_rb64(pb);
5306  atom.size -= 16;
5307  } else {
5308  e->duration = avio_rb32(pb); /* segment duration */
5309  e->time = (int32_t)avio_rb32(pb); /* media time */
5310  atom.size -= 8;
5311  }
5312  e->rate = avio_rb32(pb) / 65536.0;
5313  atom.size -= 4;
5314  av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
5315  e->duration, e->time, e->rate);
5316 
5317  if (e->time < 0 && e->time != -1 &&
5318  c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
5319  av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list media time=%"PRId64"\n",
5320  c->fc->nb_streams-1, i, e->time);
5321  return AVERROR_INVALIDDATA;
5322  }
5323  }
5324  sc->elst_count = i;
5325 
5326  return 0;
5327 }
5328 
5330 {
5331  MOVStreamContext *sc;
5332 
5333  if (c->fc->nb_streams < 1)
5334  return AVERROR_INVALIDDATA;
5335  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5336  sc->timecode_track = avio_rb32(pb);
5337  return 0;
5338 }
5339 
5341 {
5342  AVStream *st;
5343  int ret;
5344 
5345  if (c->fc->nb_streams < 1)
5346  return 0;
5347  st = c->fc->streams[c->fc->nb_streams - 1];
5348 
5349  if (atom.size < 4) {
5350  av_log(c->fc, AV_LOG_ERROR, "Empty AV1 Codec Configuration Box\n");
5351  return AVERROR_INVALIDDATA;
5352  }
5353 
5354  /* For now, propagate only the OBUs, if any. Once libavcodec is
5355  updated to handle isobmff style extradata this can be removed. */
5356  avio_skip(pb, 4);
5357 
5358  if (atom.size == 4)
5359  return 0;
5360 
5361  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 4);
5362  if (ret < 0)
5363  return ret;
5364 
5365  return 0;
5366 }
5367 
5369 {
5370  AVStream *st;
5371  int version, color_range, color_primaries, color_trc, color_space;
5372 
5373  if (c->fc->nb_streams < 1)
5374  return 0;
5375  st = c->fc->streams[c->fc->nb_streams - 1];
5376 
5377  if (atom.size < 5) {
5378  av_log(c->fc, AV_LOG_ERROR, "Empty VP Codec Configuration box\n");
5379  return AVERROR_INVALIDDATA;
5380  }
5381 
5382  version = avio_r8(pb);
5383  if (version != 1) {
5384  av_log(c->fc, AV_LOG_WARNING, "Unsupported VP Codec Configuration box version %d\n", version);
5385  return 0;
5386  }
5387  avio_skip(pb, 3); /* flags */
5388 
5389  avio_skip(pb, 2); /* profile + level */
5390  color_range = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
5391  color_primaries = avio_r8(pb);
5392  color_trc = avio_r8(pb);
5393  color_space = avio_r8(pb);
5394  if (avio_rb16(pb)) /* codecIntializationDataSize */
5395  return AVERROR_INVALIDDATA;
5396 
5399  if (!av_color_transfer_name(color_trc))
5400  color_trc = AVCOL_TRC_UNSPECIFIED;
5401  if (!av_color_space_name(color_space))
5402  color_space = AVCOL_SPC_UNSPECIFIED;
5403 
5406  st->codecpar->color_trc = color_trc;
5407  st->codecpar->color_space = color_space;
5408 
5409  return 0;
5410 }
5411 
5413 {
5414  MOVStreamContext *sc;
5415  int i, version;
5416 
5417  if (c->fc->nb_streams < 1)
5418  return AVERROR_INVALIDDATA;
5419 
5420  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5421 
5422  if (atom.size < 5) {
5423  av_log(c->fc, AV_LOG_ERROR, "Empty Mastering Display Metadata box\n");
5424  return AVERROR_INVALIDDATA;
5425  }
5426 
5427  version = avio_r8(pb);
5428  if (version) {
5429  av_log(c->fc, AV_LOG_WARNING, "Unsupported Mastering Display Metadata box version %d\n", version);
5430  return 0;
5431  }
5432  avio_skip(pb, 3); /* flags */
5433 
5435  if (!sc->mastering)
5436  return AVERROR(ENOMEM);
5437 
5438  for (i = 0; i < 3; i++) {
5439  sc->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), 1 << 16);
5440  sc->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), 1 << 16);
5441  }
5442  sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), 1 << 16);
5443  sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), 1 << 16);
5444 
5445  sc->mastering->max_luminance = av_make_q(avio_rb32(pb), 1 << 8);
5446  sc->mastering->min_luminance = av_make_q(avio_rb32(pb), 1 << 14);
5447 
5448  sc->mastering->has_primaries = 1;
5449  sc->mastering->has_luminance = 1;
5450 
5451  return 0;
5452 }
5453 
5455 {
5456  MOVStreamContext *sc;
5457  const int mapping[3] = {1, 2, 0};
5458  const int chroma_den = 50000;
5459  const int luma_den = 10000;
5460  int i;
5461 
5462  if (c->fc->nb_streams < 1)
5463  return AVERROR_INVALIDDATA;
5464 
5465  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5466 
5467  if (atom.size < 24) {
5468  av_log(c->fc, AV_LOG_ERROR, "Invalid Mastering Display Color Volume box\n");
5469  return AVERROR_INVALIDDATA;
5470  }
5471 
5473  if (!sc->mastering)
5474  return AVERROR(ENOMEM);
5475 
5476  for (i = 0; i < 3; i++) {
5477  const int j = mapping[i];
5478  sc->mastering->display_primaries[j][0] = av_make_q(avio_rb16(pb), chroma_den);
5479  sc->mastering->display_primaries[j][1] = av_make_q(avio_rb16(pb), chroma_den);
5480  }
5481  sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), chroma_den);
5482  sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), chroma_den);
5483 
5484  sc->mastering->max_luminance = av_make_q(avio_rb32(pb), luma_den);
5485  sc->mastering->min_luminance = av_make_q(avio_rb32(pb), luma_den);
5486 
5487  sc->mastering->has_luminance = 1;
5488  sc->mastering->has_primaries = 1;
5489 
5490  return 0;
5491 }
5492 
5494 {
5495  MOVStreamContext *sc;
5496  int version;
5497 
5498  if (c->fc->nb_streams < 1)
5499  return AVERROR_INVALIDDATA;
5500 
5501  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5502 
5503  if (atom.size < 5) {
5504  av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level box\n");
5505  return AVERROR_INVALIDDATA;
5506  }
5507 
5508  version = avio_r8(pb);
5509  if (version) {
5510  av_log(c->fc, AV_LOG_WARNING, "Unsupported Content Light Level box version %d\n", version);
5511  return 0;
5512  }
5513  avio_skip(pb, 3); /* flags */
5514 
5516  if (!sc->coll)
5517  return AVERROR(ENOMEM);
5518 
5519  sc->coll->MaxCLL = avio_rb16(pb);
5520  sc->coll->MaxFALL = avio_rb16(pb);
5521 
5522  return 0;
5523 }
5524 
5526 {
5527  MOVStreamContext *sc;
5528 
5529  if (c->fc->nb_streams < 1)
5530  return AVERROR_INVALIDDATA;
5531 
5532  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5533 
5534  if (atom.size < 4) {
5535  av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level Info box\n");
5536  return AVERROR_INVALIDDATA;
5537  }
5538 
5540  if (!sc->coll)
5541  return AVERROR(ENOMEM);
5542 
5543  sc->coll->MaxCLL = avio_rb16(pb);
5544  sc->coll->MaxFALL = avio_rb16(pb);
5545 
5546  return 0;
5547 }
5548 
5550 {
5551  AVStream *st;
5552  MOVStreamContext *sc;
5553  enum AVStereo3DType type;
5554  int mode;
5555 
5556  if (c->fc->nb_streams < 1)
5557  return 0;
5558 
5559  st = c->fc->streams[c->fc->nb_streams - 1];
5560  sc = st->priv_data;
5561 
5562  if (atom.size < 5) {
5563  av_log(c->fc, AV_LOG_ERROR, "Empty stereoscopic video box\n");
5564  return AVERROR_INVALIDDATA;
5565  }
5566 
5567  if (sc->stereo3d)
5568  return AVERROR_INVALIDDATA;
5569 
5570  avio_skip(pb, 4); /* version + flags */
5571 
5572  mode = avio_r8(pb);
5573  switch (mode) {
5574  case 0:
5575  type = AV_STEREO3D_2D;
5576  break;
5577  case 1:
5579  break;
5580  case 2:
5582  break;
5583  default:
5584  av_log(c->fc, AV_LOG_WARNING, "Unknown st3d mode value %d\n", mode);
5585  return 0;
5586  }
5587 
5588  sc->stereo3d = av_stereo3d_alloc();
5589  if (!sc->stereo3d)
5590  return AVERROR(ENOMEM);
5591 
5592  sc->stereo3d->type = type;
5593  return 0;
5594 }
5595 
5597 {
5598  AVStream *st;
5599  MOVStreamContext *sc;
5600  int size, version, layout;
5601  int32_t yaw, pitch, roll;
5602  uint32_t l = 0, t = 0, r = 0, b = 0;
5603  uint32_t tag, padding = 0;
5604  enum AVSphericalProjection projection;
5605 
5606  if (c->fc->nb_streams < 1)
5607  return 0;
5608 
5609  st = c->fc->streams[c->fc->nb_streams - 1];
5610  sc = st->priv_data;
5611 
5612  if (atom.size < 8) {
5613  av_log(c->fc, AV_LOG_ERROR, "Empty spherical video box\n");
5614  return AVERROR_INVALIDDATA;
5615  }
5616 
5617  size = avio_rb32(pb);
5618  if (size <= 12 || size > atom.size)
5619  return AVERROR_INVALIDDATA;
5620 
5621  tag = avio_rl32(pb);
5622  if (tag != MKTAG('s','v','h','d')) {
5623  av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
5624  return 0;
5625  }
5626  version = avio_r8(pb);
5627  if (version != 0) {
5628  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5629  version);
5630  return 0;
5631  }
5632  avio_skip(pb, 3); /* flags */
5633  avio_skip(pb, size - 12); /* metadata_source */
5634 
5635  size = avio_rb32(pb);
5636  if (size > atom.size)
5637  return AVERROR_INVALIDDATA;
5638 
5639  tag = avio_rl32(pb);
5640  if (tag != MKTAG('p','r','o','j')) {
5641  av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
5642  return 0;
5643  }
5644 
5645  size = avio_rb32(pb);
5646  if (size > atom.size)
5647  return AVERROR_INVALIDDATA;
5648 
5649  tag = avio_rl32(pb);
5650  if (tag != MKTAG('p','r','h','d')) {
5651  av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
5652  return 0;
5653  }
5654  version = avio_r8(pb);
5655  if (version != 0) {
5656  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5657  version);
5658  return 0;
5659  }
5660  avio_skip(pb, 3); /* flags */
5661 
5662  /* 16.16 fixed point */
5663  yaw = avio_rb32(pb);
5664  pitch = avio_rb32(pb);
5665  roll = avio_rb32(pb);
5666 
5667  size = avio_rb32(pb);
5668  if (size > atom.size)
5669  return AVERROR_INVALIDDATA;
5670 
5671  tag = avio_rl32(pb);
5672  version = avio_r8(pb);
5673  if (version != 0) {
5674  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5675  version);
5676  return 0;
5677  }
5678  avio_skip(pb, 3); /* flags */
5679  switch (tag) {
5680  case MKTAG('c','b','m','p'):
5681  layout = avio_rb32(pb);
5682  if (layout) {
5683  av_log(c->fc, AV_LOG_WARNING,
5684  "Unsupported cubemap layout %d\n", layout);
5685  return 0;
5686  }
5687  projection = AV_SPHERICAL_CUBEMAP;
5688  padding = avio_rb32(pb);
5689  break;
5690  case MKTAG('e','q','u','i'):
5691  t = avio_rb32(pb);
5692  b = avio_rb32(pb);
5693  l = avio_rb32(pb);
5694  r = avio_rb32(pb);
5695 
5696  if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
5697  av_log(c->fc, AV_LOG_ERROR,
5698  "Invalid bounding rectangle coordinates "
5699  "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
5700  return AVERROR_INVALIDDATA;
5701  }
5702 
5703  if (l || t || r || b)
5704  projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
5705  else
5706  projection = AV_SPHERICAL_EQUIRECTANGULAR;
5707  break;
5708  default:
5709  av_log(c->fc, AV_LOG_ERROR, "Unknown projection type: %s\n", av_fourcc2str(tag));
5710  return 0;
5711  }
5712 
5714  if (!sc->spherical)
5715  return AVERROR(ENOMEM);
5716 
5717  sc->spherical->projection = projection;
5718 
5719  sc->spherical->yaw = yaw;
5720  sc->spherical->pitch = pitch;
5721  sc->spherical->roll = roll;
5722 
5723  sc->spherical->padding = padding;
5724 
5725  sc->spherical->bound_left = l;
5726  sc->spherical->bound_top = t;
5727  sc->spherical->bound_right = r;
5728  sc->spherical->bound_bottom = b;
5729 
5730  return 0;
5731 }
5732 
5734 {
5735  int ret = 0;
5736  uint8_t *buffer = av_malloc(len + 1);
5737  const char *val;
5738 
5739  if (!buffer)
5740  return AVERROR(ENOMEM);
5741  buffer[len] = '\0';
5742 
5743  ret = ffio_read_size(pb, buffer, len);
5744  if (ret < 0)
5745  goto out;
5746 
5747  /* Check for mandatory keys and values, try to support XML as best-effort */
5748  if (!sc->spherical &&
5749  av_stristr(buffer, "<GSpherical:StitchingSoftware>") &&
5750  (val = av_stristr(buffer, "<GSpherical:Spherical>")) &&
5751  av_stristr(val, "true") &&
5752  (val = av_stristr(buffer, "<GSpherical:Stitched>")) &&
5753  av_stristr(val, "true") &&
5754  (val = av_stristr(buffer, "<GSpherical:ProjectionType>")) &&
5755  av_stristr(val, "equirectangular")) {
5757  if (!sc->spherical)
5758  goto out;
5759 
5761 
5762  if (av_stristr(buffer, "<GSpherical:StereoMode>") && !sc->stereo3d) {
5763  enum AVStereo3DType mode;
5764 
5765  if (av_stristr(buffer, "left-right"))
5767  else if (av_stristr(buffer, "top-bottom"))
5769  else
5770  mode = AV_STEREO3D_2D;
5771 
5772  sc->stereo3d = av_stereo3d_alloc();
5773  if (!sc->stereo3d)
5774  goto out;
5775 
5776  sc->stereo3d->type = mode;
5777  }
5778 
5779  /* orientation */
5780  val = av_stristr(buffer, "<GSpherical:InitialViewHeadingDegrees>");
5781  if (val)
5782  sc->spherical->yaw = strtol(val, NULL, 10) * (1 << 16);
5783  val = av_stristr(buffer, "<GSpherical:InitialViewPitchDegrees>");
5784  if (val)
5785  sc->spherical->pitch = strtol(val, NULL, 10) * (1 << 16);
5786  val = av_stristr(buffer, "<GSpherical:InitialViewRollDegrees>");
5787  if (val)
5788  sc->spherical->roll = strtol(val, NULL, 10) * (1 << 16);
5789  }
5790 
5791 out:
5792  av_free(buffer);
5793  return ret;
5794 }
5795 
5797 {
5798  AVStream *st;
5799  MOVStreamContext *sc;
5800  int64_t ret;
5801  uint8_t uuid[16];
5802  static const uint8_t uuid_isml_manifest[] = {
5803  0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
5804  0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
5805  };
5806  static const uint8_t uuid_xmp[] = {
5807  0xbe, 0x7a, 0xcf, 0xcb, 0x97, 0xa9, 0x42, 0xe8,
5808  0x9c, 0x71, 0x99, 0x94, 0x91, 0xe3, 0xaf, 0xac
5809  };
5810  static const uint8_t uuid_spherical[] = {
5811  0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
5812  0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
5813  };
5814 
5815  if (atom.size < sizeof(uuid) || atom.size >= FFMIN(INT_MAX, SIZE_MAX))
5816  return AVERROR_INVALIDDATA;
5817 
5818  if (c->fc->nb_streams < 1)
5819  return 0;
5820  st = c->fc->streams[c->fc->nb_streams - 1];
5821  sc = st->priv_data;
5822 
5823  ret = ffio_read_size(pb, uuid, sizeof(uuid));
5824  if (ret < 0)
5825  return ret;
5826  if (!memcmp(uuid, uuid_isml_manifest, sizeof(uuid))) {
5827  uint8_t *buffer, *ptr;
5828  char *endptr;
5829  size_t len = atom.size - sizeof(uuid);
5830 
5831  if (len < 4) {
5832  return AVERROR_INVALIDDATA;
5833  }
5834  ret = avio_skip(pb, 4); // zeroes
5835  len -= 4;
5836 
5837  buffer = av_mallocz(len + 1);
5838  if (!buffer) {
5839  return AVERROR(ENOMEM);
5840  }
5841  ret = ffio_read_size(pb, buffer, len);
5842  if (ret < 0) {
5843  av_free(buffer);
5844  return ret;
5845  }
5846 
5847  ptr = buffer;
5848  while ((ptr = av_stristr(ptr, "systemBitrate=\""))) {
5849  ptr += sizeof("systemBitrate=\"") - 1;
5850  c->bitrates_count++;
5851  c->bitrates = av_realloc_f(c->bitrates, c->bitrates_count, sizeof(*c->bitrates));
5852  if (!c->bitrates) {
5853  c->bitrates_count = 0;
5854  av_free(buffer);
5855  return AVERROR(ENOMEM);
5856  }
5857  errno = 0;
5858  ret = strtol(ptr, &endptr, 10);
5859  if (ret < 0 || errno || *endptr != '"') {
5860  c->bitrates[c->bitrates_count - 1] = 0;
5861  } else {
5862  c->bitrates[c->bitrates_count - 1] = ret;
5863  }
5864  }
5865 
5866  av_free(buffer);
5867  } else if (!memcmp(uuid, uuid_xmp, sizeof(uuid))) {
5868  uint8_t *buffer;
5869  size_t len = atom.size - sizeof(uuid);
5870  if (c->export_xmp) {
5871  buffer = av_mallocz(len + 1);
5872  if (!buffer) {
5873  return AVERROR(ENOMEM);
5874  }
5875  ret = ffio_read_size(pb, buffer, len);
5876  if (ret < 0) {
5877  av_free(buffer);
5878  return ret;
5879  }
5880  buffer[len] = '\0';
5881  av_dict_set(&c->fc->metadata, "xmp",
5883  } else {
5884  // skip all uuid atom, which makes it fast for long uuid-xmp file
5885  ret = avio_skip(pb, len);
5886  if (ret < 0)
5887  return ret;
5888  }
5889  } else if (!memcmp(uuid, uuid_spherical, sizeof(uuid))) {
5890  size_t len = atom.size - sizeof(uuid);
5891  ret = mov_parse_uuid_spherical(sc, pb, len);
5892  if (ret < 0)
5893  return ret;
5894  if (!sc->spherical)
5895  av_log(c->fc, AV_LOG_WARNING, "Invalid spherical metadata found\n");
5896  }
5897 
5898  return 0;
5899 }
5900 
5902 {
5903  int ret;
5904  uint8_t content[16];
5905 
5906  if (atom.size < 8)
5907  return 0;
5908 
5909  ret = avio_read(pb, content, FFMIN(sizeof(content), atom.size));
5910  if (ret < 0)
5911  return ret;
5912 
5913  if ( !c->found_moov
5914  && !c->found_mdat
5915  && !memcmp(content, "Anevia\x1A\x1A", 8)
5916  && c->use_mfra_for == FF_MOV_FLAG_MFRA_AUTO) {
5917  c->use_mfra_for = FF_MOV_FLAG_MFRA_PTS;
5918  }
5919 
5920  return 0;
5921 }
5922 
5924 {
5925  uint32_t format = avio_rl32(pb);
5926  MOVStreamContext *sc;
5927  enum AVCodecID id;
5928  AVStream *st;
5929 
5930  if (c->fc->nb_streams < 1)
5931  return 0;
5932  st = c->fc->streams[c->fc->nb_streams - 1];
5933  sc = st->priv_data;
5934 
5935  switch (sc->format)
5936  {
5937  case MKTAG('e','n','c','v'): // encrypted video
5938  case MKTAG('e','n','c','a'): // encrypted audio
5939  id = mov_codec_id(st, format);
5940  if (st->codecpar->codec_id != AV_CODEC_ID_NONE &&
5941  st->codecpar->codec_id != id) {
5942  av_log(c->fc, AV_LOG_WARNING,
5943  "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
5944  (char*)&format, st->codecpar->codec_id);
5945  break;
5946  }
5947 
5948  st->codecpar->codec_id = id;
5949  sc->format = format;
5950  break;
5951 
5952  default:
5953  if (format != sc->format) {
5954  av_log(c->fc, AV_LOG_WARNING,
5955  "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
5956  (char*)&format, (char*)&sc->format);
5957  }
5958  break;
5959  }
5960 
5961  return 0;
5962 }
5963 
5964 /**
5965  * Gets the current encryption info and associated current stream context. If
5966  * we are parsing a track fragment, this will return the specific encryption
5967  * info for this fragment; otherwise this will return the global encryption
5968  * info for the current stream.
5969  */
5971 {
5972  MOVFragmentStreamInfo *frag_stream_info;
5973  AVStream *st;
5974  int i;
5975 
5976  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
5977  if (frag_stream_info) {
5978  for (i = 0; i < c->fc->nb_streams; i++) {
5979  if (c->fc->streams[i]->id == frag_stream_info->id) {
5980  st = c->fc->streams[i];
5981  break;
5982  }
5983  }
5984  if (i == c->fc->nb_streams)
5985  return 0;
5986  *sc = st->priv_data;
5987 
5988  if (!frag_stream_info->encryption_index) {
5989  // If this stream isn't encrypted, don't create the index.
5990  if (!(*sc)->cenc.default_encrypted_sample)
5991  return 0;
5992  frag_stream_info->encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5993  if (!frag_stream_info->encryption_index)
5994  return AVERROR(ENOMEM);
5995  }
5996  *encryption_index = frag_stream_info->encryption_index;
5997  return 1;
5998  } else {
5999  // No current track fragment, using stream level encryption info.
6000 
6001  if (c->fc->nb_streams < 1)
6002  return 0;
6003  st = c->fc->streams[c->fc->nb_streams - 1];
6004  *sc = st->priv_data;
6005 
6006  if (!(*sc)->cenc.encryption_index) {
6007  // If this stream isn't encrypted, don't create the index.
6008  if (!(*sc)->cenc.default_encrypted_sample)
6009  return 0;
6010  (*sc)->cenc.encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
6011  if (!(*sc)->cenc.encryption_index)
6012  return AVERROR(ENOMEM);
6013  }
6014 
6015  *encryption_index = (*sc)->cenc.encryption_index;
6016  return 1;
6017  }
6018 }
6019 
6021 {
6022  int i, ret;
6023  unsigned int subsample_count;
6024  AVSubsampleEncryptionInfo *subsamples;
6025 
6026  if (!sc->cenc.default_encrypted_sample) {
6027  av_log(c->fc, AV_LOG_ERROR, "Missing schm or tenc\n");
6028  return AVERROR_INVALIDDATA;
6029  }
6030 
6032  if (!*sample)
6033  return AVERROR(ENOMEM);
6034 
6035  if (sc->cenc.per_sample_iv_size != 0) {
6036  if ((ret = ffio_read_size(pb, (*sample)->iv, sc->cenc.per_sample_iv_size)) < 0) {
6037  av_log(c->fc, AV_LOG_ERROR, "failed to read the initialization vector\n");
6039  *sample = NULL;
6040  return ret;
6041  }
6042  }
6043 
6044  if (use_subsamples) {
6045  subsample_count = avio_rb16(pb);
6046  av_free((*sample)->subsamples);
6047  (*sample)->subsamples = av_mallocz_array(subsample_count, sizeof(*subsamples));
6048  if (!(*sample)->subsamples) {
6050  *sample = NULL;
6051  return AVERROR(ENOMEM);
6052  }
6053 
6054  for (i = 0; i < subsample_count && !pb->eof_reached; i++) {
6055  (*sample)->subsamples[i].bytes_of_clear_data = avio_rb16(pb);
6056  (*sample)->subsamples[i].bytes_of_protected_data = avio_rb32(pb);
6057  }
6058 
6059  if (pb->eof_reached) {
6060  av_log(c->fc, AV_LOG_ERROR, "hit EOF while reading sub-sample encryption info\n");
6062  *sample = NULL;
6063  return AVERROR_INVALIDDATA;
6064  }
6065  (*sample)->subsample_count = subsample_count;
6066  }
6067 
6068  return 0;
6069 }
6070 
6072 {
6073  AVEncryptionInfo **encrypted_samples;
6074  MOVEncryptionIndex *encryption_index;
6075  MOVStreamContext *sc;
6076  int use_subsamples, ret;
6077  unsigned int sample_count, i, alloc_size = 0;
6078 
6079  ret = get_current_encryption_info(c, &encryption_index, &sc);
6080  if (ret != 1)
6081  return ret;
6082 
6083  if (encryption_index->nb_encrypted_samples) {
6084  // This can happen if we have both saio/saiz and senc atoms.
6085  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in senc\n");
6086  return 0;
6087  }
6088 
6089  avio_r8(pb); /* version */
6090  use_subsamples = avio_rb24(pb) & 0x02; /* flags */
6091 
6092  sample_count = avio_rb32(pb);
6093  if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
6094  return AVERROR(ENOMEM);
6095 
6096  for (i = 0; i < sample_count; i++) {
6097  unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
6098  encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
6099  min_samples * sizeof(*encrypted_samples));
6100  if (encrypted_samples) {
6101  encryption_index->encrypted_samples = encrypted_samples;
6102 
6104  c, pb, sc, &encryption_index->encrypted_samples[i], use_subsamples);
6105  } else {
6106  ret = AVERROR(ENOMEM);
6107  }
6108  if (pb->eof_reached) {
6109  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading senc\n");
6110  ret = AVERROR_INVALIDDATA;
6111  }
6112 
6113  if (ret < 0) {
6114  for (; i > 0; i--)
6115  av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6116  av_freep(&encryption_index->encrypted_samples);
6117  return ret;
6118  }
6119  }
6120  encryption_index->nb_encrypted_samples = sample_count;
6121 
6122  return 0;
6123 }
6124 
6126 {
6127  AVEncryptionInfo **sample, **encrypted_samples;
6128  int64_t prev_pos;
6129  size_t sample_count, sample_info_size, i;
6130  int ret = 0;
6131  unsigned int alloc_size = 0;
6132 
6133  if (encryption_index->nb_encrypted_samples)
6134  return 0;
6135  sample_count = encryption_index->auxiliary_info_sample_count;
6136  if (encryption_index->auxiliary_offsets_count != 1) {
6137  av_log(c->fc, AV_LOG_ERROR, "Multiple auxiliary info chunks are not supported\n");
6138  return AVERROR_PATCHWELCOME;
6139  }
6140  if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
6141  return AVERROR(ENOMEM);
6142 
6143  prev_pos = avio_tell(pb);
6144  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
6145  avio_seek(pb, encryption_index->auxiliary_offsets[0], SEEK_SET) != encryption_index->auxiliary_offsets[0]) {
6146  av_log(c->fc, AV_LOG_INFO, "Failed to seek for auxiliary info, will only parse senc atoms for encryption info\n");
6147  goto finish;
6148  }
6149 
6150  for (i = 0; i < sample_count && !pb->eof_reached; i++) {
6151  unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
6152  encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
6153  min_samples * sizeof(*encrypted_samples));
6154  if (!encrypted_samples) {
6155  ret = AVERROR(ENOMEM);
6156  goto finish;
6157  }
6158  encryption_index->encrypted_samples = encrypted_samples;
6159 
6160  sample = &encryption_index->encrypted_samples[i];
6161  sample_info_size = encryption_index->auxiliary_info_default_size
6162  ? encryption_index->auxiliary_info_default_size
6163  : encryption_index->auxiliary_info_sizes[i];
6164 
6165  ret = mov_read_sample_encryption_info(c, pb, sc, sample, sample_info_size > sc->cenc.per_sample_iv_size);
6166  if (ret < 0)
6167  goto finish;
6168  }
6169  if (pb->eof_reached) {
6170  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading auxiliary info\n");
6171  ret = AVERROR_INVALIDDATA;
6172  } else {
6173  encryption_index->nb_encrypted_samples = sample_count;
6174  }
6175 
6176 finish:
6177  avio_seek(pb, prev_pos, SEEK_SET);
6178  if (ret < 0) {
6179  for (; i > 0; i--) {
6180  av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6181  }
6182  av_freep(&encryption_index->encrypted_samples);
6183  }
6184  return ret;
6185 }
6186 
6187 /**
6188  * Tries to read the given number of bytes from the stream and puts it in a
6189  * newly allocated buffer. This reads in small chunks to avoid allocating large
6190  * memory if the file contains an invalid/malicious size value.
6191  */
6192 static int mov_try_read_block(AVIOContext *pb, size_t size, uint8_t **data)
6193 {
6194  const unsigned int block_size = 1024 * 1024;
6195  uint8_t *buffer = NULL;
6196  unsigned int alloc_size = 0, offset = 0;
6197  while (offset < size) {
6198  unsigned int new_size =
6199  alloc_size >= INT_MAX - block_size ? INT_MAX : alloc_size + block_size;
6200  uint8_t *new_buffer = av_fast_realloc(buffer, &alloc_size, new_size);
6201  unsigned int to_read = FFMIN(size, alloc_size) - offset;
6202  if (!new_buffer) {
6203  av_free(buffer);
6204  return AVERROR(ENOMEM);
6205  }
6206  buffer = new_buffer;
6207 
6208  if (avio_read(pb, buffer + offset, to_read) != to_read) {
6209  av_free(buffer);
6210  return AVERROR_INVALIDDATA;
6211  }
6212  offset += to_read;
6213  }
6214 
6215  *data = buffer;
6216  return 0;
6217 }
6218 
6220 {
6221  MOVEncryptionIndex *encryption_index;
6222  MOVStreamContext *sc;
6223  int ret;
6224  unsigned int sample_count, aux_info_type, aux_info_param;
6225 
6226  ret = get_current_encryption_info(c, &encryption_index, &sc);
6227  if (ret != 1)
6228  return ret;
6229 
6230  if (encryption_index->nb_encrypted_samples) {
6231  // This can happen if we have both saio/saiz and senc atoms.
6232  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saiz\n");
6233  return 0;
6234  }
6235 
6236  if (encryption_index->auxiliary_info_sample_count) {
6237  av_log(c->fc, AV_LOG_ERROR, "Duplicate saiz atom\n");
6238  return AVERROR_INVALIDDATA;
6239  }
6240 
6241  avio_r8(pb); /* version */
6242  if (avio_rb24(pb) & 0x01) { /* flags */
6243  aux_info_type = avio_rb32(pb);
6244  aux_info_param = avio_rb32(pb);
6245  if (sc->cenc.default_encrypted_sample) {
6246  if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6247  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type\n");
6248  return 0;
6249  }
6250  if (aux_info_param != 0) {
6251  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type_parameter\n");
6252  return 0;
6253  }
6254  } else {
6255  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6256  if ((aux_info_type == MKBETAG('c','e','n','c') ||
6257  aux_info_type == MKBETAG('c','e','n','s') ||
6258  aux_info_type == MKBETAG('c','b','c','1') ||
6259  aux_info_type == MKBETAG('c','b','c','s')) &&
6260  aux_info_param == 0) {
6261  av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saiz without schm/tenc\n");
6262  return AVERROR_INVALIDDATA;
6263  } else {
6264  return 0;
6265  }
6266  }
6267  } else if (!sc->cenc.default_encrypted_sample) {
6268  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6269  return 0;
6270  }
6271 
6272  encryption_index->auxiliary_info_default_size = avio_r8(pb);
6273  sample_count = avio_rb32(pb);
6274  encryption_index->auxiliary_info_sample_count = sample_count;
6275 
6276  if (encryption_index->auxiliary_info_default_size == 0) {
6277  ret = mov_try_read_block(pb, sample_count, &encryption_index->auxiliary_info_sizes);
6278  if (ret < 0) {
6279  av_log(c->fc, AV_LOG_ERROR, "Failed to read the auxiliary info\n");
6280  return ret;
6281  }
6282  }
6283 
6284  if (encryption_index->auxiliary_offsets_count) {
6285  return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6286  }
6287 
6288  return 0;
6289 }
6290 
6292 {
6293  uint64_t *auxiliary_offsets;
6294  MOVEncryptionIndex *encryption_index;
6295  MOVStreamContext *sc;
6296  int i, ret;
6297  unsigned int version, entry_count, aux_info_type, aux_info_param;
6298  unsigned int alloc_size = 0;
6299 
6300  ret = get_current_encryption_info(c, &encryption_index, &sc);
6301  if (ret != 1)
6302  return ret;
6303 
6304  if (encryption_index->nb_encrypted_samples) {
6305  // This can happen if we have both saio/saiz and senc atoms.
6306  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saio\n");
6307  return 0;
6308  }
6309 
6310  if (encryption_index->auxiliary_offsets_count) {
6311  av_log(c->fc, AV_LOG_ERROR, "Duplicate saio atom\n");
6312  return AVERROR_INVALIDDATA;
6313  }
6314 
6315  version = avio_r8(pb); /* version */
6316  if (avio_rb24(pb) & 0x01) { /* flags */
6317  aux_info_type = avio_rb32(pb);
6318  aux_info_param = avio_rb32(pb);
6319  if (sc->cenc.default_encrypted_sample) {
6320  if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6321  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type\n");
6322  return 0;
6323  }
6324  if (aux_info_param != 0) {
6325  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type_parameter\n");
6326  return 0;
6327  }
6328  } else {
6329  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6330  if ((aux_info_type == MKBETAG('c','e','n','c') ||
6331  aux_info_type == MKBETAG('c','e','n','s') ||
6332  aux_info_type == MKBETAG('c','b','c','1') ||
6333  aux_info_type == MKBETAG('c','b','c','s')) &&
6334  aux_info_param == 0) {
6335  av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saio without schm/tenc\n");
6336  return AVERROR_INVALIDDATA;
6337  } else {
6338  return 0;
6339  }
6340  }
6341  } else if (!sc->cenc.default_encrypted_sample) {
6342  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6343  return 0;
6344  }
6345 
6346  entry_count = avio_rb32(pb);
6347  if (entry_count >= INT_MAX / sizeof(*auxiliary_offsets))
6348  return AVERROR(ENOMEM);
6349 
6350  for (i = 0; i < entry_count && !pb->eof_reached; i++) {
6351  unsigned int min_offsets = FFMIN(FFMAX(i + 1, 1024), entry_count);
6352  auxiliary_offsets = av_fast_realloc(
6353  encryption_index->auxiliary_offsets, &alloc_size,
6354  min_offsets * sizeof(*auxiliary_offsets));
6355  if (!auxiliary_offsets) {
6356  av_freep(&encryption_index->auxiliary_offsets);
6357  return AVERROR(ENOMEM);
6358  }
6359  encryption_index->auxiliary_offsets = auxiliary_offsets;
6360 
6361  if (version == 0) {
6362  encryption_index->auxiliary_offsets[i] = avio_rb32(pb);
6363  } else {
6364  encryption_index->auxiliary_offsets[i] = avio_rb64(pb);
6365  }
6366  if (c->frag_index.current >= 0) {
6367  encryption_index->auxiliary_offsets[i] += c->fragment.base_data_offset;
6368  }
6369  }
6370 
6371  if (pb->eof_reached) {
6372  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading saio\n");
6373  av_freep(&encryption_index->auxiliary_offsets);
6374  return AVERROR_INVALIDDATA;
6375  }
6376 
6377  encryption_index->auxiliary_offsets_count = entry_count;
6378 
6379  if (encryption_index->auxiliary_info_sample_count) {
6380  return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6381  }
6382 
6383  return 0;
6384 }
6385 
6387 {
6388  AVEncryptionInitInfo *info, *old_init_info;
6389  uint8_t **key_ids;
6390  AVStream *st;
6391  uint8_t *side_data, *extra_data, *old_side_data;
6392  size_t side_data_size;
6393  buffer_size_t old_side_data_size;
6394  int ret = 0;
6395  unsigned int version, kid_count, extra_data_size, alloc_size = 0;
6396 
6397  if (c->fc->nb_streams < 1)
6398  return 0;
6399  st = c->fc->streams[c->fc->nb_streams-1];
6400 
6401  version = avio_r8(pb); /* version */
6402  avio_rb24(pb); /* flags */
6403 
6404  info = av_encryption_init_info_alloc(/* system_id_size */ 16, /* num_key_ids */ 0,
6405  /* key_id_size */ 16, /* data_size */ 0);
6406  if (!info)
6407  return AVERROR(ENOMEM);
6408 
6409  if ((ret = ffio_read_size(pb, info->system_id, 16)) < 0) {
6410  av_log(c->fc, AV_LOG_ERROR, "Failed to read the system id\n");
6411  goto finish;
6412  }
6413 
6414  if (version > 0) {
6415  kid_count = avio_rb32(pb);
6416  if (kid_count >= INT_MAX / sizeof(*key_ids)) {
6417  ret = AVERROR(ENOMEM);
6418  goto finish;
6419  }
6420 
6421  for (unsigned int i = 0; i < kid_count && !pb->eof_reached; i++) {
6422  unsigned int min_kid_count = FFMIN(FFMAX(i + 1, 1024), kid_count);
6423  key_ids = av_fast_realloc(info->key_ids, &alloc_size,
6424  min_kid_count * sizeof(*key_ids));
6425  if (!key_ids) {
6426  ret = AVERROR(ENOMEM);
6427  goto finish;
6428  }
6429  info->key_ids = key_ids;
6430 
6431  info->key_ids[i] = av_mallocz(16);
6432  if (!info->key_ids[i]) {
6433  ret = AVERROR(ENOMEM);
6434  goto finish;
6435  }
6436  info->num_key_ids = i + 1;
6437 
6438  if ((ret = ffio_read_size(pb, info->key_ids[i], 16)) < 0) {
6439  av_log(c->fc, AV_LOG_ERROR, "Failed to read the key id\n");
6440  goto finish;
6441  }
6442  }
6443 
6444  if (pb->eof_reached) {
6445  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading pssh\n");
6446  ret = AVERROR_INVALIDDATA;
6447  goto finish;
6448  }
6449  }
6450 
6451  extra_data_size = avio_rb32(pb);
6452  ret = mov_try_read_block(pb, extra_data_size, &extra_data);
6453  if (ret < 0)
6454  goto finish;
6455 
6456  av_freep(&info->data); // malloc(0) may still allocate something.
6457  info->data = extra_data;
6458  info->data_size = extra_data_size;
6459 
6460  // If there is existing initialization data, append to the list.
6461  old_side_data = av_stream_get_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO, &old_side_data_size);
6462  if (old_side_data) {
6463  old_init_info = av_encryption_init_info_get_side_data(old_side_data, old_side_data_size);
6464  if (old_init_info) {
6465  // Append to the end of the list.
6466  for (AVEncryptionInitInfo *cur = old_init_info;; cur = cur->next) {
6467  if (!cur->next) {
6468  cur->next = info;
6469  break;
6470  }
6471  }
6472  info = old_init_info;
6473  } else {
6474  // Assume existing side-data will be valid, so the only error we could get is OOM.
6475  ret = AVERROR(ENOMEM);
6476  goto finish;
6477  }
6478  }
6479 
6480  side_data = av_encryption_init_info_add_side_data(info, &side_data_size);
6481  if (!side_data) {
6482  ret = AVERROR(ENOMEM);
6483  goto finish;
6484  }
6486  side_data, side_data_size);
6487  if (ret < 0)
6488  av_free(side_data);
6489 
6490 finish:
6492  return ret;
6493 }
6494 
6496 {
6497  AVStream *st;
6498  MOVStreamContext *sc;
6499 
6500  if (c->fc->nb_streams < 1)
6501  return 0;
6502  st = c->fc->streams[c->fc->nb_streams-1];
6503  sc = st->priv_data;
6504 
6505  if (sc->pseudo_stream_id != 0) {
6506  av_log(c->fc, AV_LOG_ERROR, "schm boxes are only supported in first sample descriptor\n");
6507  return AVERROR_PATCHWELCOME;
6508  }
6509 
6510  if (atom.size < 8)
6511  return AVERROR_INVALIDDATA;
6512 
6513  avio_rb32(pb); /* version and flags */
6514 
6515  if (!sc->cenc.default_encrypted_sample) {
6517  if (!sc->cenc.default_encrypted_sample) {
6518  return AVERROR(ENOMEM);
6519  }
6520  }
6521 
6523  return 0;
6524 }
6525 
6527 {
6528  AVStream *st;
6529  MOVStreamContext *sc;
6530  unsigned int version, pattern, is_protected, iv_size;
6531 
6532  if (c->fc->nb_streams < 1)
6533  return 0;
6534  st = c->fc->streams[c->fc->nb_streams-1];
6535  sc = st->priv_data;
6536 
6537  if (sc->pseudo_stream_id != 0) {
6538  av_log(c->fc, AV_LOG_ERROR, "tenc atom are only supported in first sample descriptor\n");
6539  return AVERROR_PATCHWELCOME;
6540  }
6541 
6542  if (!sc->cenc.default_encrypted_sample) {
6544  if (!sc->cenc.default_encrypted_sample) {
6545  return AVERROR(ENOMEM);
6546  }
6547  }
6548 
6549  if (atom.size < 20)
6550  return AVERROR_INVALIDDATA;
6551 
6552  version = avio_r8(pb); /* version */
6553  avio_rb24(pb); /* flags */
6554 
6555  avio_r8(pb); /* reserved */
6556  pattern = avio_r8(pb);
6557 
6558  if (version > 0) {
6559  sc->cenc.default_encrypted_sample->crypt_byte_block = pattern >> 4;
6560  sc->cenc.default_encrypted_sample->skip_byte_block = pattern & 0xf;
6561  }
6562 
6563  is_protected = avio_r8(pb);
6564  if (is_protected && !sc->cenc.encryption_index) {
6565  // The whole stream should be by-default encrypted.
6567  if (!sc->cenc.encryption_index)
6568  return AVERROR(ENOMEM);
6569  }
6570  sc->cenc.per_sample_iv_size = avio_r8(pb);
6571  if (sc->cenc.per_sample_iv_size != 0 && sc->cenc.per_sample_iv_size != 8 &&
6572  sc->cenc.per_sample_iv_size != 16) {
6573  av_log(c->fc, AV_LOG_ERROR, "invalid per-sample IV size value\n");
6574  return AVERROR_INVALIDDATA;
6575  }
6576  if (avio_read(pb, sc->cenc.default_encrypted_sample->key_id, 16) != 16) {
6577  av_log(c->fc, AV_LOG_ERROR, "failed to read the default key ID\n");
6578  return AVERROR_INVALIDDATA;
6579  }
6580 
6581  if (is_protected && !sc->cenc.per_sample_iv_size) {
6582  iv_size = avio_r8(pb);
6583  if (iv_size != 8 && iv_size != 16) {
6584  av_log(c->fc, AV_LOG_ERROR, "invalid default_constant_IV_size in tenc atom\n");
6585  return AVERROR_INVALIDDATA;
6586  }
6587 
6588  if (avio_read(pb, sc->cenc.default_encrypted_sample->iv, iv_size) != iv_size) {
6589  av_log(c->fc, AV_LOG_ERROR, "failed to read the default IV\n");
6590  return AVERROR_INVALIDDATA;
6591  }
6592  }
6593 
6594  return 0;
6595 }
6596 
6598 {
6599  AVStream *st;
6600  int last, type, size, ret;
6601  uint8_t buf[4];
6602 
6603  if (c->fc->nb_streams < 1)
6604  return 0;
6605  st = c->fc->streams[c->fc->nb_streams-1];
6606 
6607  if ((uint64_t)atom.size > (1<<30) || atom.size < 42)
6608  return AVERROR_INVALIDDATA;
6609 
6610  /* Check FlacSpecificBox version. */
6611  if (avio_r8(pb) != 0)
6612  return AVERROR_INVALIDDATA;
6613 
6614  avio_rb24(pb); /* Flags */
6615 
6616  avio_read(pb, buf, sizeof(buf));
6617  flac_parse_block_header(buf, &last, &type, &size);
6618 
6620  av_log(c->fc, AV_LOG_ERROR, "STREAMINFO must be first FLACMetadataBlock\n");
6621  return AVERROR_INVALIDDATA;
6622  }
6623 
6624  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
6625  if (ret < 0)
6626  return ret;
6627 
6628  if (!last)
6629  av_log(c->fc, AV_LOG_WARNING, "non-STREAMINFO FLACMetadataBlock(s) ignored\n");
6630 
6631  return 0;
6632 }
6633 
6635 {
6636  int i, ret;
6637 
6638  if (sample->scheme != MKBETAG('c','e','n','c') || sample->crypt_byte_block != 0 || sample->skip_byte_block != 0) {
6639  av_log(c->fc, AV_LOG_ERROR, "Only the 'cenc' encryption scheme is supported\n");
6640  return AVERROR_PATCHWELCOME;
6641  }
6642 
6643  if (!sc->cenc.aes_ctr) {
6644  /* initialize the cipher */
6645  sc->cenc.aes_ctr = av_aes_ctr_alloc();
6646  if (!sc->cenc.aes_ctr) {
6647  return AVERROR(ENOMEM);
6648  }
6649 
6650  ret = av_aes_ctr_init(sc->cenc.aes_ctr, c->decryption_key);
6651  if (ret < 0) {
6652  return ret;
6653  }
6654  }
6655 
6657 
6658  if (!sample->subsample_count) {
6659  /* decrypt the whole packet */
6660  av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, size);
6661  return 0;
6662  }
6663 
6664  for (i = 0; i < sample->subsample_count; i++) {
6665  if (sample->subsamples[i].bytes_of_clear_data + sample->subsamples[i].bytes_of_protected_data > size) {
6666  av_log(c->fc, AV_LOG_ERROR, "subsample size exceeds the packet size left\n");
6667  return AVERROR_INVALIDDATA;
6668  }
6669 
6670  /* skip the clear bytes */
6671  input += sample->subsamples[i].bytes_of_clear_data;
6672  size -= sample->subsamples[i].bytes_of_clear_data;
6673 
6674  /* decrypt the encrypted bytes */
6675  av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, sample->subsamples[i].bytes_of_protected_data);
6676  input += sample->subsamples[i].bytes_of_protected_data;
6677  size -= sample->subsamples[i].bytes_of_protected_data;
6678  }
6679 
6680  if (size > 0) {
6681  av_log(c->fc, AV_LOG_ERROR, "leftover packet bytes after subsample processing\n");
6682  return AVERROR_INVALIDDATA;
6683  }
6684 
6685  return 0;
6686 }
6687 
6688 static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
6689 {
6690  MOVFragmentStreamInfo *frag_stream_info;
6691  MOVEncryptionIndex *encryption_index;
6692  AVEncryptionInfo *encrypted_sample;
6693  int encrypted_index, ret;
6694 
6695  frag_stream_info = get_frag_stream_info(&mov->frag_index, mov->frag_index.current, st->id);
6696  encrypted_index = current_index;
6697  encryption_index = NULL;
6698  if (frag_stream_info) {
6699  // Note this only supports encryption info in the first sample descriptor.
6700  if (mov->fragment.stsd_id == 1) {
6701  if (frag_stream_info->encryption_index) {
6702  encrypted_index = current_index - frag_stream_info->index_entry;
6703  encryption_index = frag_stream_info->encryption_index;
6704  } else {
6705  encryption_index = sc->cenc.encryption_index;
6706  }
6707  }
6708  } else {
6709  encryption_index = sc->cenc.encryption_index;
6710  }
6711 
6712  if (encryption_index) {
6713  if (encryption_index->auxiliary_info_sample_count &&
6714  !encryption_index->nb_encrypted_samples) {
6715  av_log(mov->fc, AV_LOG_ERROR, "saiz atom found without saio\n");
6716  return AVERROR_INVALIDDATA;
6717  }
6718  if (encryption_index->auxiliary_offsets_count &&
6719  !encryption_index->nb_encrypted_samples) {
6720  av_log(mov->fc, AV_LOG_ERROR, "saio atom found without saiz\n");
6721  return AVERROR_INVALIDDATA;
6722  }
6723 
6724  if (!encryption_index->nb_encrypted_samples) {
6725  // Full-sample encryption with default settings.
6726  encrypted_sample = sc->cenc.default_encrypted_sample;
6727  } else if (encrypted_index >= 0 && encrypted_index < encryption_index->nb_encrypted_samples) {
6728  // Per-sample setting override.
6729  encrypted_sample = encryption_index->encrypted_samples[encrypted_index];
6730  } else {
6731  av_log(mov->fc, AV_LOG_ERROR, "Incorrect number of samples in encryption info\n");
6732  return AVERROR_INVALIDDATA;
6733  }
6734 
6735  if (mov->decryption_key) {
6736  return cenc_decrypt(mov, sc, encrypted_sample, pkt->data, pkt->size);
6737  } else {
6738  size_t size;
6739  uint8_t *side_data = av_encryption_info_add_side_data(encrypted_sample, &size);
6740  if (!side_data)
6741  return AVERROR(ENOMEM);
6743  if (ret < 0)
6744  av_free(side_data);
6745  return ret;
6746  }
6747  }
6748 
6749  return 0;
6750 }
6751 
6753 {
6754  const int OPUS_SEEK_PREROLL_MS = 80;
6755  int ret;
6756  AVStream *st;
6757  size_t size;
6758  uint16_t pre_skip;
6759 
6760  if (c->fc->nb_streams < 1)
6761  return 0;
6762  st = c->fc->streams[c->fc->nb_streams-1];
6763 
6764  if ((uint64_t)atom.size > (1<<30) || atom.size < 11)
6765  return AVERROR_INVALIDDATA;
6766 
6767  /* Check OpusSpecificBox version. */
6768  if (avio_r8(pb) != 0) {
6769  av_log(c->fc, AV_LOG_ERROR, "unsupported OpusSpecificBox version\n");
6770  return AVERROR_INVALIDDATA;
6771  }
6772 
6773  /* OpusSpecificBox size plus magic for Ogg OpusHead header. */
6774  size = atom.size + 8;
6775 
6776  if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
6777  return ret;
6778 
6779  AV_WL32(st->codecpar->extradata, MKTAG('O','p','u','s'));
6780  AV_WL32(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
6781  AV_WB8(st->codecpar->extradata + 8, 1); /* OpusHead version */
6782  avio_read(pb, st->codecpar->extradata + 9, size - 9);
6783 
6784  /* OpusSpecificBox is stored in big-endian, but OpusHead is
6785  little-endian; aside from the preceeding magic and version they're
6786  otherwise currently identical. Data after output gain at offset 16
6787  doesn't need to be bytewapped. */
6788  pre_skip = AV_RB16(st->codecpar->extradata + 10);
6789  AV_WL16(st->codecpar->extradata + 10, pre_skip);
6790  AV_WL32(st->codecpar->extradata + 12, AV_RB32(st->codecpar->extradata + 12));
6791  AV_WL16(st->codecpar->extradata + 16, AV_RB16(st->codecpar->extradata + 16));
6792 
6793  st->codecpar->initial_padding = pre_skip;
6795  (AVRational){1, 1000},
6796  (AVRational){1, 48000});
6797 
6798  return 0;
6799 }
6800 
6802 {
6803  AVStream *st;
6804  unsigned format_info;
6805  int channel_assignment, channel_assignment1, channel_assignment2;
6806  int ratebits;
6807 
6808  if (c->fc->nb_streams < 1)
6809  return 0;
6810  st = c->fc->streams[c->fc->nb_streams-1];
6811 
6812  if (atom.size < 10)
6813  return AVERROR_INVALIDDATA;
6814 
6815  format_info = avio_rb32(pb);
6816 
6817  ratebits = (format_info >> 28) & 0xF;
6818  channel_assignment1 = (format_info >> 15) & 0x1F;
6819  channel_assignment2 = format_info & 0x1FFF;
6820  if (channel_assignment2)
6821  channel_assignment = channel_assignment2;
6822  else
6823  channel_assignment = channel_assignment1;
6824 
6825  st->codecpar->frame_size = 40 << (ratebits & 0x7);
6826  st->codecpar->sample_rate = mlp_samplerate(ratebits);
6827  st->codecpar->channels = truehd_channels(channel_assignment);
6828  st->codecpar->channel_layout = truehd_layout(channel_assignment);
6829 
6830  return 0;
6831 }
6832 
6834 {
6835  AVStream *st;
6836  uint32_t buf;
6838  size_t dovi_size;
6839  int ret;
6840 
6841  if (c->fc->nb_streams < 1)
6842  return 0;
6843  st = c->fc->streams[c->fc->nb_streams-1];
6844 
6845  if ((uint64_t)atom.size > (1<<30) || atom.size < 4)
6846  return AVERROR_INVALIDDATA;
6847 
6848  dovi = av_dovi_alloc(&dovi_size);
6849  if (!dovi)
6850  return AVERROR(ENOMEM);
6851 
6852  dovi->dv_version_major = avio_r8(pb);
6853  dovi->dv_version_minor = avio_r8(pb);
6854 
6855  buf = avio_rb16(pb);
6856  dovi->dv_profile = (buf >> 9) & 0x7f; // 7 bits
6857  dovi->dv_level = (buf >> 3) & 0x3f; // 6 bits
6858  dovi->rpu_present_flag = (buf >> 2) & 0x01; // 1 bit
6859  dovi->el_present_flag = (buf >> 1) & 0x01; // 1 bit
6860  dovi->bl_present_flag = buf & 0x01; // 1 bit
6861  if (atom.size >= 24) { // 4 + 4 + 4 * 4
6862  buf = avio_r8(pb);
6863  dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits
6864  } else {
6865  // 0 stands for None
6866  // Dolby Vision V1.2.93 profiles and levels
6868  }
6869 
6871  (uint8_t *)dovi, dovi_size);
6872  if (ret < 0) {
6873  av_free(dovi);
6874  return ret;
6875  }
6876 
6877  av_log(c, AV_LOG_TRACE, "DOVI in dvcC/dvvC box, version: %d.%d, profile: %d, level: %d, "
6878  "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d\n",
6879  dovi->dv_version_major, dovi->dv_version_minor,
6880  dovi->dv_profile, dovi->dv_level,
6881  dovi->rpu_present_flag,
6882  dovi->el_present_flag,
6883  dovi->bl_present_flag,
6885  );
6886 
6887  return 0;
6888 }
6889 
6891 { MKTAG('A','C','L','R'), mov_read_aclr },
6892 { MKTAG('A','P','R','G'), mov_read_avid },
6893 { MKTAG('A','A','L','P'), mov_read_avid },
6894 { MKTAG('A','R','E','S'), mov_read_ares },
6895 { MKTAG('a','v','s','s'), mov_read_avss },
6896 { MKTAG('a','v','1','C'), mov_read_av1c },
6897 { MKTAG('c','h','p','l'), mov_read_chpl },
6898 { MKTAG('c','o','6','4'), mov_read_stco },
6899 { MKTAG('c','o','l','r'), mov_read_colr },
6900 { MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
6901 { MKTAG('d','i','n','f'), mov_read_default },
6902 { MKTAG('D','p','x','E'), mov_read_dpxe },
6903 { MKTAG('d','r','e','f'), mov_read_dref },
6904 { MKTAG('e','d','t','s'), mov_read_default },
6905 { MKTAG('e','l','s','t'), mov_read_elst },
6906 { MKTAG('e','n','d','a'), mov_read_enda },
6907 { MKTAG('f','i','e','l'), mov_read_fiel },
6908 { MKTAG('a','d','r','m'), mov_read_adrm },
6909 { MKTAG('f','t','y','p'), mov_read_ftyp },
6910 { MKTAG('g','l','b','l'), mov_read_glbl },
6911 { MKTAG('h','d','l','r'), mov_read_hdlr },
6912 { MKTAG('i','l','s','t'), mov_read_ilst },
6913 { MKTAG('j','p','2','h'), mov_read_jp2h },
6914 { MKTAG('m','d','a','t'), mov_read_mdat },
6915 { MKTAG('m','d','h','d'), mov_read_mdhd },
6916 { MKTAG('m','d','i','a'), mov_read_default },
6917 { MKTAG('m','e','t','a'), mov_read_meta },
6918 { MKTAG('m','i','n','f'), mov_read_default },
6919 { MKTAG('m','o','o','f'), mov_read_moof },
6920 { MKTAG('m','o','o','v'), mov_read_moov },
6921 { MKTAG('m','v','e','x'), mov_read_default },
6922 { MKTAG('m','v','h','d'), mov_read_mvhd },
6923 { MKTAG('S','M','I',' '), mov_read_svq3 },
6924 { MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */
6925 { MKTAG('a','v','c','C'), mov_read_glbl },
6926 { MKTAG('p','a','s','p'), mov_read_pasp },
6927 { MKTAG('s','i','d','x'), mov_read_sidx },
6928 { MKTAG('s','t','b','l'), mov_read_default },
6929 { MKTAG('s','t','c','o'), mov_read_stco },
6930 { MKTAG('s','t','p','s'), mov_read_stps },
6931 { MKTAG('s','t','r','f'), mov_read_strf },
6932 { MKTAG('s','t','s','c'), mov_read_stsc },
6933 { MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
6934 { MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
6935 { MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
6936 { MKTAG('s','t','t','s'), mov_read_stts },
6937 { MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
6938 { MKTAG('s','d','t','p'), mov_read_sdtp }, /* independent and disposable samples */
6939 { MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
6940 { MKTAG('t','f','d','t'), mov_read_tfdt },
6941 { MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
6942 { MKTAG('t','r','a','k'), mov_read_trak },
6943 { MKTAG('t','r','a','f'), mov_read_default },
6944 { MKTAG('t','r','e','f'), mov_read_default },
6945 { MKTAG('t','m','c','d'), mov_read_tmcd },
6946 { MKTAG('c','h','a','p'), mov_read_chap },
6947 { MKTAG('t','r','e','x'), mov_read_trex },
6948 { MKTAG('t','r','u','n'), mov_read_trun },
6949 { MKTAG('u','d','t','a'), mov_read_default },
6950 { MKTAG('w','a','v','e'), mov_read_wave },
6951 { MKTAG('e','s','d','s'), mov_read_esds },
6952 { MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */
6953 { MKTAG('d','e','c','3'), mov_read_dec3 }, /* EAC-3 info */
6954 { MKTAG('d','d','t','s'), mov_read_ddts }, /* DTS audio descriptor */
6955 { MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
6956 { MKTAG('w','f','e','x'), mov_read_wfex },
6957 { MKTAG('c','m','o','v'), mov_read_cmov },
6958 { MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */
6959 { MKTAG('d','v','c','1'), mov_read_dvc1 },
6960 { MKTAG('s','b','g','p'), mov_read_sbgp },
6961 { MKTAG('h','v','c','C'), mov_read_glbl },
6962 { MKTAG('u','u','i','d'), mov_read_uuid },
6963 { MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },
6964 { MKTAG('f','r','e','e'), mov_read_free },
6965 { MKTAG('-','-','-','-'), mov_read_custom },
6966 { MKTAG('s','i','n','f'), mov_read_default },
6967 { MKTAG('f','r','m','a'), mov_read_frma },
6968 { MKTAG('s','e','n','c'), mov_read_senc },
6969 { MKTAG('s','a','i','z'), mov_read_saiz },
6970 { MKTAG('s','a','i','o'), mov_read_saio },
6971 { MKTAG('p','s','s','h'), mov_read_pssh },
6972 { MKTAG('s','c','h','m'), mov_read_schm },
6973 { MKTAG('s','c','h','i'), mov_read_default },
6974 { MKTAG('t','e','n','c'), mov_read_tenc },
6975 { MKTAG('d','f','L','a'), mov_read_dfla },
6976 { MKTAG('s','t','3','d'), mov_read_st3d }, /* stereoscopic 3D video box */
6977 { MKTAG('s','v','3','d'), mov_read_sv3d }, /* spherical video box */
6978 { MKTAG('d','O','p','s'), mov_read_dops },
6979 { MKTAG('d','m','l','p'), mov_read_dmlp },
6980 { MKTAG('S','m','D','m'), mov_read_smdm },
6981 { MKTAG('C','o','L','L'), mov_read_coll },
6982 { MKTAG('v','p','c','C'), mov_read_vpcc },
6983 { MKTAG('m','d','c','v'), mov_read_mdcv },
6984 { MKTAG('c','l','l','i'), mov_read_clli },
6985 { MKTAG('d','v','c','C'), mov_read_dvcc_dvvc },
6986 { MKTAG('d','v','v','C'), mov_read_dvcc_dvvc },
6987 { 0, NULL }
6988 };
6989 
6991 {
6992  int64_t total_size = 0;
6993  MOVAtom a;
6994  int i;
6995 
6996  if (c->atom_depth > 10) {
6997  av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");
6998  return AVERROR_INVALIDDATA;
6999  }
7000  c->atom_depth ++;
7001 
7002  if (atom.size < 0)
7003  atom.size = INT64_MAX;
7004  while (total_size <= atom.size - 8 && !avio_feof(pb)) {
7006  a.size = atom.size;
7007  a.type=0;
7008  if (atom.size >= 8) {
7009  a.size = avio_rb32(pb);
7010  a.type = avio_rl32(pb);
7011  if (((a.type == MKTAG('f','r','e','e') && c->moov_retry) ||
7012  a.type == MKTAG('h','o','o','v')) &&
7013  a.size >= 8 &&
7014  c->fc->strict_std_compliance < FF_COMPLIANCE_STRICT) {
7015  uint32_t type;
7016  avio_skip(pb, 4);
7017  type = avio_rl32(pb);
7018  if (avio_feof(pb))
7019  break;
7020  avio_seek(pb, -8, SEEK_CUR);
7021  if (type == MKTAG('m','v','h','d') ||
7022  type == MKTAG('c','m','o','v')) {
7023  av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free or hoov atom.\n");
7024  a.type = MKTAG('m','o','o','v');
7025  }
7026  }
7027  if (atom.type != MKTAG('r','o','o','t') &&
7028  atom.type != MKTAG('m','o','o','v')) {
7029  if (a.type == MKTAG('t','r','a','k') ||
7030  a.type == MKTAG('m','d','a','t')) {
7031  av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
7032  avio_skip(pb, -8);
7033  c->atom_depth --;
7034  return 0;
7035  }
7036  }
7037  total_size += 8;
7038  if (a.size == 1 && total_size + 8 <= atom.size) { /* 64 bit extended size */
7039  a.size = avio_rb64(pb) - 8;
7040  total_size += 8;
7041  }
7042  }
7043  av_log(c->fc, AV_LOG_TRACE, "type:'%s' parent:'%s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
7044  av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
7045  if (a.size == 0) {
7046  a.size = atom.size - total_size + 8;
7047  }
7048  a.size -= 8;
7049  if (a.size < 0)
7050  break;
7051  a.size = FFMIN(a.size, atom.size - total_size);
7052 
7053  for (i = 0; mov_default_parse_table[i].type; i++)
7054  if (mov_default_parse_table[i].type == a.type) {
7056  break;
7057  }
7058 
7059  // container is user data
7060  if (!parse && (atom.type == MKTAG('u','d','t','a') ||
7061  atom.type == MKTAG('i','l','s','t')))
7063 
7064  // Supports parsing the QuickTime Metadata Keys.
7065  // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
7066  if (!parse && c->found_hdlr_mdta &&
7067  atom.type == MKTAG('m','e','t','a') &&
7068  a.type == MKTAG('k','e','y','s') &&
7069  c->meta_keys_count == 0) {
7070  parse = mov_read_keys;
7071  }
7072 
7073  if (!parse) { /* skip leaf atoms data */
7074  avio_skip(pb, a.size);
7075  } else {
7076  int64_t start_pos = avio_tell(pb);
7077  int64_t left;
7078  int err = parse(c, pb, a);
7079  if (err < 0) {
7080  c->atom_depth --;
7081  return err;
7082  }
7083  if (c->found_moov && c->found_mdat && a.size <= INT64_MAX - start_pos &&
7084  ((!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->frag_index.complete) ||
7085  start_pos + a.size == avio_size(pb))) {
7086  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->frag_index.complete)
7087  c->next_root_atom = start_pos + a.size;
7088  c->atom_depth --;
7089  return 0;
7090  }
7091  left = a.size - avio_tell(pb) + start_pos;
7092  if (left > 0) /* skip garbage at atom end */
7093  avio_skip(pb, left);
7094  else if (left < 0) {
7095  av_log(c->fc, AV_LOG_WARNING,
7096  "overread end of atom '%s' by %"PRId64" bytes\n",
7097  av_fourcc2str(a.type), -left);
7098  avio_seek(pb, left, SEEK_CUR);
7099  }
7100  }
7101 
7102  total_size += a.size;
7103  }
7104 
7105  if (total_size < atom.size && atom.size < 0x7ffff)
7106  avio_skip(pb, atom.size - total_size);
7107 
7108  c->atom_depth --;
7109  return 0;
7110 }
7111 
7112 static int mov_probe(const AVProbeData *p)
7113 {
7114  int64_t offset;
7115  uint32_t tag;
7116  int score = 0;
7117  int moov_offset = -1;
7118 
7119  /* check file header */
7120  offset = 0;
7121  for (;;) {
7122  int64_t size;
7123  int minsize = 8;
7124  /* ignore invalid offset */
7125  if ((offset + 8ULL) > (unsigned int)p->buf_size)
7126  break;
7127  size = AV_RB32(p->buf + offset);
7128  if (size == 1 && offset + 16 <= (unsigned int)p->buf_size) {
7129  size = AV_RB64(p->buf+offset + 8);
7130  minsize = 16;
7131  } else if (size == 0) {
7132  size = p->buf_size - offset;
7133  }
7134  if (size < minsize) {
7135  offset += 4;
7136  continue;
7137  }
7138  tag = AV_RL32(p->buf + offset + 4);
7139  switch(tag) {
7140  /* check for obvious tags */
7141  case MKTAG('m','o','o','v'):
7142  moov_offset = offset + 4;
7143  case MKTAG('m','d','a','t'):
7144  case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
7145  case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
7146  case MKTAG('f','t','y','p'):
7147  if (tag == MKTAG('f','t','y','p') &&
7148  ( AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')
7149  || AV_RL32(p->buf + offset + 8) == MKTAG('j','p','x',' ')
7150  )) {
7151  score = FFMAX(score, 5);
7152  } else {
7153  score = AVPROBE_SCORE_MAX;
7154  }
7155  break;
7156  /* those are more common words, so rate then a bit less */
7157  case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
7158  case MKTAG('w','i','d','e'):
7159  case MKTAG('f','r','e','e'):
7160  case MKTAG('j','u','n','k'):
7161  case MKTAG('p','i','c','t'):
7162  score = FFMAX(score, AVPROBE_SCORE_MAX - 5);
7163  break;
7164  case MKTAG(0x82,0x82,0x7f,0x7d):
7165  case MKTAG('s','k','i','p'):
7166  case MKTAG('u','u','i','d'):
7167  case MKTAG('p','r','f','l'):
7168  /* if we only find those cause probedata is too small at least rate them */
7169  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
7170  break;
7171  }
7172  if (size > INT64_MAX - offset)
7173  break;
7174  offset += size;
7175  }
7176  if (score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
7177  /* moov atom in the header - we should make sure that this is not a
7178  * MOV-packed MPEG-PS */
7179  offset = moov_offset;
7180 
7181  while (offset < (p->buf_size - 16)) { /* Sufficient space */
7182  /* We found an actual hdlr atom */
7183  if (AV_RL32(p->buf + offset ) == MKTAG('h','d','l','r') &&
7184  AV_RL32(p->buf + offset + 8) == MKTAG('m','h','l','r') &&
7185  AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')) {
7186  av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
7187  /* We found a media handler reference atom describing an
7188  * MPEG-PS-in-MOV, return a
7189  * low score to force expanding the probe window until
7190  * mpegps_probe finds what it needs */
7191  return 5;
7192  } else {
7193  /* Keep looking */
7194  offset += 2;
7195  }
7196  }
7197  }
7198 
7199  return score;
7200 }
7201 
7202 // must be done after parsing all trak because there's no order requirement
7204 {
7205  MOVContext *mov = s->priv_data;
7206  AVStream *st;
7207  MOVStreamContext *sc;
7208  int64_t cur_pos;
7209  int i, j;
7210  int chapter_track;
7211 
7212  for (j = 0; j < mov->nb_chapter_tracks; j++) {
7213  chapter_track = mov->chapter_tracks[j];
7214  st = NULL;
7215  for (i = 0; i < s->nb_streams; i++)
7216  if (s->streams[i]->id == chapter_track) {
7217  st = s->streams[i];
7218  break;
7219  }
7220  if (!st) {
7221  av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
7222  continue;
7223  }
7224 
7225  sc = st->priv_data;
7226  cur_pos = avio_tell(sc->pb);
7227 
7228  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
7230  if (st->nb_index_entries) {
7231  // Retrieve the first frame, if possible
7232  AVIndexEntry *sample = &st->index_entries[0];
7233  if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7234  av_log(s, AV_LOG_ERROR, "Failed to retrieve first frame\n");
7235  goto finish;
7236  }
7237 
7238  if (av_get_packet(sc->pb, &st->attached_pic, sample->size) < 0)
7239  goto finish;
7240 
7241  st->attached_pic.stream_index = st->index;
7243  }
7244  } else {
7247  st->discard = AVDISCARD_ALL;
7248  for (i = 0; i < st->nb_index_entries; i++) {
7250  int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
7251  uint8_t *title;
7252  uint16_t ch;
7253  int len, title_len;
7254 
7255  if (end < sample->timestamp) {
7256  av_log(s, AV_LOG_WARNING, "ignoring stream duration which is shorter than chapters\n");
7257  end = AV_NOPTS_VALUE;
7258  }
7259 
7260  if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7261  av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
7262  goto finish;
7263  }
7264 
7265  // the first two bytes are the length of the title
7266  len = avio_rb16(sc->pb);
7267  if (len > sample->size-2)
7268  continue;
7269  title_len = 2*len + 1;
7270  if (!(title = av_mallocz(title_len)))
7271  goto finish;
7272 
7273  // The samples could theoretically be in any encoding if there's an encd
7274  // atom following, but in practice are only utf-8 or utf-16, distinguished
7275  // instead by the presence of a BOM
7276  if (!len) {
7277  title[0] = 0;
7278  } else {
7279  ch = avio_rb16(sc->pb);
7280  if (ch == 0xfeff)
7281  avio_get_str16be(sc->pb, len, title, title_len);
7282  else if (ch == 0xfffe)
7283  avio_get_str16le(sc->pb, len, title, title_len);
7284  else {
7285  AV_WB16(title, ch);
7286  if (len == 1 || len == 2)
7287  title[len] = 0;
7288  else
7289  avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
7290  }
7291  }
7292 
7293  avpriv_new_chapter(s, i, st->time_base, sample->timestamp, end, title);
7294  av_freep(&title);
7295  }
7296  }
7297 finish:
7298  avio_seek(sc->pb, cur_pos, SEEK_SET);
7299  }
7300 }
7301 
7303  uint32_t value, int flags)
7304 {
7305  AVTimecode tc;
7306  char buf[AV_TIMECODE_STR_SIZE];
7307  AVRational rate = st->avg_frame_rate;
7308  int ret = av_timecode_init(&tc, rate, flags, 0, s);
7309  if (ret < 0)
7310  return ret;
7311  av_dict_set(&st->metadata, "timecode",
7312  av_timecode_make_string(&tc, buf, value), 0);
7313  return 0;
7314 }
7315 
7317 {
7318  MOVStreamContext *sc = st->priv_data;
7319  char buf[AV_TIMECODE_STR_SIZE];
7320  int64_t cur_pos = avio_tell(sc->pb);
7321  int hh, mm, ss, ff, drop;
7322 
7323  if (!st->nb_index_entries)
7324  return -1;
7325 
7326  avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7327  avio_skip(s->pb, 13);
7328  hh = avio_r8(s->pb);
7329  mm = avio_r8(s->pb);
7330  ss = avio_r8(s->pb);
7331  drop = avio_r8(s->pb);
7332  ff = avio_r8(s->pb);
7333  snprintf(buf, AV_TIMECODE_STR_SIZE, "%02d:%02d:%02d%c%02d",
7334  hh, mm, ss, drop ? ';' : ':', ff);
7335  av_dict_set(&st->metadata, "timecode", buf, 0);
7336 
7337  avio_seek(sc->pb, cur_pos, SEEK_SET);
7338  return 0;
7339 }
7340 
7342 {
7343  MOVStreamContext *sc = st->priv_data;
7344  int flags = 0;
7345  int64_t cur_pos = avio_tell(sc->pb);
7346  uint32_t value;
7347 
7348  if (!st->nb_index_entries)
7349  return -1;
7350 
7351  avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7352  value = avio_rb32(s->pb);
7353 
7354  if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
7355  if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
7356  if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
7357 
7358  /* Assume Counter flag is set to 1 in tmcd track (even though it is likely
7359  * not the case) and thus assume "frame number format" instead of QT one.
7360  * No sample with tmcd track can be found with a QT timecode at the moment,
7361  * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
7362  * format). */
7364 
7365  avio_seek(sc->pb, cur_pos, SEEK_SET);
7366  return 0;
7367 }
7368 
7370  int i;
7371  if (!index || !*index) return;
7372  for (i = 0; i < (*index)->nb_encrypted_samples; i++) {
7373  av_encryption_info_free((*index)->encrypted_samples[i]);
7374  }
7375  av_freep(&(*index)->encrypted_samples);
7376  av_freep(&(*index)->auxiliary_info_sizes);
7377  av_freep(&(*index)->auxiliary_offsets);
7378  av_freep(index);
7379 }
7380 
7382 {
7383  MOVContext *mov = s->priv_data;
7384  int i, j;
7385 
7386  for (i = 0; i < s->nb_streams; i++) {
7387  AVStream *st = s->streams[i];
7388  MOVStreamContext *sc = st->priv_data;
7389 
7390  if (!sc)
7391  continue;
7392 
7393  av_freep(&sc->ctts_data);
7394  for (j = 0; j < sc->drefs_count; j++) {
7395  av_freep(&sc->drefs[j].path);
7396  av_freep(&sc->drefs[j].dir);
7397  }
7398  av_freep(&sc->drefs);
7399 
7400  sc->drefs_count = 0;
7401 
7402  if (!sc->pb_is_copied)
7403  ff_format_io_close(s, &sc->pb);
7404 
7405  sc->pb = NULL;
7406  av_freep(&sc->chunk_offsets);
7407  av_freep(&sc->stsc_data);
7408  av_freep(&sc->sample_sizes);
7409  av_freep(&sc->keyframes);
7410  av_freep(&sc->stts_data);
7411  av_freep(&sc->sdtp_data);
7412  av_freep(&sc->stps_data);
7413  av_freep(&sc->elst_data);
7414  av_freep(&sc->rap_group);
7415  av_freep(&sc->display_matrix);
7416  av_freep(&sc->index_ranges);
7417 
7418  if (sc->extradata)
7419  for (j = 0; j < sc->stsd_count; j++)
7420  av_free(sc->extradata[j]);
7421  av_freep(&sc->extradata);
7422  av_freep(&sc->extradata_size);
7423 
7427 
7428  av_freep(&sc->stereo3d);
7429  av_freep(&sc->spherical);
7430  av_freep(&sc->mastering);
7431  av_freep(&sc->coll);
7432  }
7433 
7434  av_freep(&mov->dv_demux);
7436  mov->dv_fctx = NULL;
7437 
7438  if (mov->meta_keys) {
7439  for (i = 1; i < mov->meta_keys_count; i++) {
7440  av_freep(&mov->meta_keys[i]);
7441  }
7442  av_freep(&mov->meta_keys);
7443  }
7444 
7445  av_freep(&mov->trex_data);
7446  av_freep(&mov->bitrates);
7447 
7448  for (i = 0; i < mov->frag_index.nb_items; i++) {
7450  for (j = 0; j < mov->frag_index.item[i].nb_stream_info; j++) {
7451  mov_free_encryption_index(&frag[j].encryption_index);
7452  }
7454  }
7455  av_freep(&mov->frag_index.item);
7456 
7457  av_freep(&mov->aes_decrypt);
7458  av_freep(&mov->chapter_tracks);
7459 
7460  return 0;
7461 }
7462 
7463 static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
7464 {
7465  int i;
7466 
7467  for (i = 0; i < s->nb_streams; i++) {
7468  AVStream *st = s->streams[i];
7469  MOVStreamContext *sc = st->priv_data;
7470 
7471  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
7472  sc->timecode_track == tmcd_id)
7473  return 1;
7474  }
7475  return 0;
7476 }
7477 
7478 /* look for a tmcd track not referenced by any video track, and export it globally */
7480 {
7481  int i;
7482 
7483  for (i = 0; i < s->nb_streams; i++) {
7484  AVStream *st = s->streams[i];
7485 
7486  if (st->codecpar->codec_tag == MKTAG('t','m','c','d') &&
7487  !tmcd_is_referenced(s, i + 1)) {
7488  AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
7489  if (tcr) {
7490  av_dict_set(&s->metadata, "timecode", tcr->value, 0);
7491  break;
7492  }
7493  }
7494  }
7495 }
7496 
7497 static int read_tfra(MOVContext *mov, AVIOContext *f)
7498 {
7499  int version, fieldlength, i, j;
7500  int64_t pos = avio_tell(f);
7501  uint32_t size = avio_rb32(f);
7502  unsigned track_id, item_count;
7503 
7504  if (avio_rb32(f) != MKBETAG('t', 'f', 'r', 'a')) {
7505  return 1;
7506  }
7507  av_log(mov->fc, AV_LOG_VERBOSE, "found tfra\n");
7508 
7509  version = avio_r8(f);
7510  avio_rb24(f);
7511  track_id = avio_rb32(f);
7512  fieldlength = avio_rb32(f);
7513  item_count = avio_rb32(f);
7514  for (i = 0; i < item_count; i++) {
7515  int64_t time, offset;
7516  int index;
7517  MOVFragmentStreamInfo * frag_stream_info;
7518 
7519  if (avio_feof(f)) {
7520  return AVERROR_INVALIDDATA;
7521  }
7522 
7523  if (version == 1) {
7524  time = avio_rb64(f);
7525  offset = avio_rb64(f);
7526  } else {
7527  time = avio_rb32(f);
7528  offset = avio_rb32(f);
7529  }
7530 
7531  // The first sample of each stream in a fragment is always a random
7532  // access sample. So it's entry in the tfra can be used as the
7533  // initial PTS of the fragment.
7534  index = update_frag_index(mov, offset);
7535  frag_stream_info = get_frag_stream_info(&mov->frag_index, index, track_id);
7536  if (frag_stream_info &&
7537  frag_stream_info->first_tfra_pts == AV_NOPTS_VALUE)
7538  frag_stream_info->first_tfra_pts = time;
7539 
7540  for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
7541  avio_r8(f);
7542  for (j = 0; j < ((fieldlength >> 2) & 3) + 1; j++)
7543  avio_r8(f);
7544  for (j = 0; j < ((fieldlength >> 0) & 3) + 1; j++)
7545  avio_r8(f);
7546  }
7547 
7548  avio_seek(f, pos + size, SEEK_SET);
7549  return 0;
7550 }
7551 
7553 {
7554  int64_t stream_size = avio_size(f);
7555  int64_t original_pos = avio_tell(f);
7556  int64_t seek_ret;
7557  int ret = -1;
7558  if ((seek_ret = avio_seek(f, stream_size - 4, SEEK_SET)) < 0) {
7559  ret = seek_ret;
7560  goto fail;
7561  }
7562  c->mfra_size = avio_rb32(f);
7563  c->have_read_mfra_size = 1;
7564  if (!c->mfra_size || c->mfra_size > stream_size) {
7565  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (unreasonable size)\n");
7566  goto fail;
7567  }
7568  if ((seek_ret = avio_seek(f, -((int64_t) c->mfra_size), SEEK_CUR)) < 0) {
7569  ret = seek_ret;
7570  goto fail;
7571  }
7572  if (avio_rb32(f) != c->mfra_size) {
7573  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (size mismatch)\n");
7574  goto fail;
7575  }
7576  if (avio_rb32(f) != MKBETAG('m', 'f', 'r', 'a')) {
7577  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (tag mismatch)\n");
7578  goto fail;
7579  }
7580  av_log(c->fc, AV_LOG_VERBOSE, "stream has mfra\n");
7581  do {
7582  ret = read_tfra(c, f);
7583  if (ret < 0)
7584  goto fail;
7585  } while (!ret);
7586  ret = 0;
7587  c->frag_index.complete = 1;
7588 fail:
7589  seek_ret = avio_seek(f, original_pos, SEEK_SET);
7590  if (seek_ret < 0) {
7591  av_log(c->fc, AV_LOG_ERROR,
7592  "failed to seek back after looking for mfra\n");
7593  ret = seek_ret;
7594  }
7595  return ret;
7596 }
7597 
7599 {
7600  MOVContext *mov = s->priv_data;
7601  AVIOContext *pb = s->pb;
7602  int j, err;
7603  MOVAtom atom = { AV_RL32("root") };
7604  int i;
7605 
7606  if (mov->decryption_key_len != 0 && mov->decryption_key_len != AES_CTR_KEY_SIZE) {
7607  av_log(s, AV_LOG_ERROR, "Invalid decryption key len %d expected %d\n",
7609  return AVERROR(EINVAL);
7610  }
7611 
7612  mov->fc = s;
7613  mov->trak_index = -1;
7614  /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
7615  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
7616  atom.size = avio_size(pb);
7617  else
7618  atom.size = INT64_MAX;
7619 
7620  /* check MOV header */
7621  do {
7622  if (mov->moov_retry)
7623  avio_seek(pb, 0, SEEK_SET);
7624  if ((err = mov_read_default(mov, pb, atom)) < 0) {
7625  av_log(s, AV_LOG_ERROR, "error reading header\n");
7626  goto fail;
7627  }
7628  } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->moov_retry++);
7629  if (!mov->found_moov) {
7630  av_log(s, AV_LOG_ERROR, "moov atom not found\n");
7631  err = AVERROR_INVALIDDATA;
7632  goto fail;
7633  }
7634  av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
7635 
7636  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
7637  if (mov->nb_chapter_tracks > 0 && !mov->ignore_chapters)
7639  for (i = 0; i < s->nb_streams; i++)
7640  if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {
7641  mov_read_timecode_track(s, s->streams[i]);
7642  } else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
7643  mov_read_rtmd_track(s, s->streams[i]);
7644  }
7645  }
7646 
7647  /* copy timecode metadata from tmcd tracks to the related video streams */
7648  for (i = 0; i < s->nb_streams; i++) {
7649  AVStream *st = s->streams[i];
7650  MOVStreamContext *sc = st->priv_data;
7651  if (sc->timecode_track > 0) {
7652  AVDictionaryEntry *tcr;
7653  int tmcd_st_id = -1;
7654 
7655  for (j = 0; j < s->nb_streams; j++)
7656  if (s->streams[j]->id == sc->timecode_track)
7657  tmcd_st_id = j;
7658 
7659  if (tmcd_st_id < 0 || tmcd_st_id == i)
7660  continue;
7661  tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
7662  if (tcr)
7663  av_dict_set(&st->metadata, "timecode", tcr->value, 0);
7664  }
7665  }
7667 
7668  for (i = 0; i < s->nb_streams; i++) {
7669  AVStream *st = s->streams[i];
7670  MOVStreamContext *sc = st->priv_data;
7671  fix_timescale(mov, sc);
7672  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
7673  st->codecpar->codec_id == AV_CODEC_ID_AAC) {
7674  st->internal->skip_samples = sc->start_pad;
7675  }
7676  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)
7678  sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
7680  if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
7681  st->codecpar->width = sc->width;
7682  st->codecpar->height = sc->height;
7683  }
7685  if ((err = mov_rewrite_dvd_sub_extradata(st)) < 0)
7686  goto fail;
7687  }
7688  }
7689  if (mov->handbrake_version &&
7690  mov->handbrake_version <= 1000000*0 + 1000*10 + 2 && // 0.10.2
7691  st->codecpar->codec_id == AV_CODEC_ID_MP3) {
7692  av_log(s, AV_LOG_VERBOSE, "Forcing full parsing for mp3 stream\n");
7694  }
7695  }
7696 
7697  if (mov->trex_data) {
7698  for (i = 0; i < s->nb_streams; i++) {
7699  AVStream *st = s->streams[i];
7700  MOVStreamContext *sc = st->priv_data;
7701  if (st->duration > 0) {
7702  if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7703  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7704  sc->data_size, sc->time_scale);
7705  err = AVERROR_INVALIDDATA;
7706  goto fail;
7707  }
7708  st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
7709  }
7710  }
7711  }
7712 
7713  if (mov->use_mfra_for > 0) {
7714  for (i = 0; i < s->nb_streams; i++) {
7715  AVStream *st = s->streams[i];
7716  MOVStreamContext *sc = st->priv_data;
7717  if (sc->duration_for_fps > 0) {
7718  if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7719  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7720  sc->data_size, sc->time_scale);
7721  err = AVERROR_INVALIDDATA;
7722  goto fail;
7723  }
7724  st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale /
7725  sc->duration_for_fps;
7726  }
7727  }
7728  }
7729 
7730  for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {
7731  if (mov->bitrates[i]) {
7732  s->streams[i]->codecpar->bit_rate = mov->bitrates[i];
7733  }
7734  }
7735 
7737 
7738  for (i = 0; i < s->nb_streams; i++) {
7739  AVStream *st = s->streams[i];
7740  MOVStreamContext *sc = st->priv_data;
7741 
7742  switch (st->codecpar->codec_type) {
7743  case AVMEDIA_TYPE_AUDIO:
7744  err = ff_replaygain_export(st, s->metadata);
7745  if (err < 0)
7746  goto fail;
7747  break;
7748  case AVMEDIA_TYPE_VIDEO:
7749  if (sc->display_matrix) {
7751  sizeof(int32_t) * 9);
7752  if (err < 0)
7753  goto fail;
7754 
7755  sc->display_matrix = NULL;
7756  }
7757  if (sc->stereo3d) {
7759  (uint8_t *)sc->stereo3d,
7760  sizeof(*sc->stereo3d));
7761  if (err < 0)
7762  goto fail;
7763 
7764  sc->stereo3d = NULL;
7765  }
7766  if (sc->spherical) {
7768  (uint8_t *)sc->spherical,
7769  sc->spherical_size);
7770  if (err < 0)
7771  goto fail;
7772 
7773  sc->spherical = NULL;
7774  }
7775  if (sc->mastering) {
7777  (uint8_t *)sc->mastering,
7778  sizeof(*sc->mastering));
7779  if (err < 0)
7780  goto fail;
7781 
7782  sc->mastering = NULL;
7783  }
7784  if (sc->coll) {
7786  (uint8_t *)sc->coll,
7787  sc->coll_size);
7788  if (err < 0)
7789  goto fail;
7790 
7791  sc->coll = NULL;
7792  }
7793  break;
7794  }
7795  }
7797 
7798  for (i = 0; i < mov->frag_index.nb_items; i++)
7799  if (mov->frag_index.item[i].moof_offset <= mov->fragment.moof_offset)
7800  mov->frag_index.item[i].headers_read = 1;
7801 
7802  return 0;
7803 fail:
7804  mov_read_close(s);
7805  return err;
7806 }
7807 
7809 {
7811  int64_t best_dts = INT64_MAX;
7812  int i;
7813  for (i = 0; i < s->nb_streams; i++) {
7814  AVStream *avst = s->streams[i];
7815  MOVStreamContext *msc = avst->priv_data;
7816  if (msc->pb && msc->current_sample < avst->nb_index_entries) {
7817  AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
7818  int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
7819  av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
7820  if (!sample || (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && current_sample->pos < sample->pos) ||
7821  ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
7822  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && dts != AV_NOPTS_VALUE &&
7823  ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
7824  (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
7825  sample = current_sample;
7826  best_dts = dts;
7827  *st = avst;
7828  }
7829  }
7830  }
7831  return sample;
7832 }
7833 
7834 static int should_retry(AVIOContext *pb, int error_code) {
7835  if (error_code == AVERROR_EOF || avio_feof(pb))
7836  return 0;
7837 
7838  return 1;
7839 }
7840 
7841 static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
7842 {
7843  int ret;
7844  MOVContext *mov = s->priv_data;
7845 
7846  if (index >= 0 && index < mov->frag_index.nb_items)
7847  target = mov->frag_index.item[index].moof_offset;
7848  if (avio_seek(s->pb, target, SEEK_SET) != target) {
7849  av_log(mov->fc, AV_LOG_ERROR, "root atom offset 0x%"PRIx64": partial file\n", target);
7850  return AVERROR_INVALIDDATA;
7851  }
7852 
7853  mov->next_root_atom = 0;
7854  if (index < 0 || index >= mov->frag_index.nb_items)
7855  index = search_frag_moof_offset(&mov->frag_index, target);
7856  if (index < mov->frag_index.nb_items &&
7857  mov->frag_index.item[index].moof_offset == target) {
7858  if (index + 1 < mov->frag_index.nb_items)
7859  mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
7860  if (mov->frag_index.item[index].headers_read)
7861  return 0;
7862  mov->frag_index.item[index].headers_read = 1;
7863  }
7864 
7865  mov->found_mdat = 0;
7866 
7867  ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
7868  if (ret < 0)
7869  return ret;
7870  if (avio_feof(s->pb))
7871  return AVERROR_EOF;
7872  av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
7873 
7874  return 1;
7875 }
7876 
7878 {
7879  uint8_t *side, *extradata;
7880  int extradata_size;
7881 
7882  /* Save the current index. */
7883  sc->last_stsd_index = sc->stsc_data[sc->stsc_index].id - 1;
7884 
7885  /* Notify the decoder that extradata changed. */
7886  extradata_size = sc->extradata_size[sc->last_stsd_index];
7887  extradata = sc->extradata[sc->last_stsd_index];
7888  if (extradata_size > 0 && extradata) {
7891  extradata_size);
7892  if (!side)
7893  return AVERROR(ENOMEM);
7894  memcpy(side, extradata, extradata_size);
7895  }
7896 
7897  return 0;
7898 }
7899 
7901 {
7902  int new_size, ret;
7903 
7904  if (size <= 8)
7905  return AVERROR_INVALIDDATA;
7906  new_size = ((size - 8) / 2) * 3;
7907  ret = av_new_packet(pkt, new_size);
7908  if (ret < 0)
7909  return ret;
7910 
7911  avio_skip(pb, 8);
7912  for (int j = 0; j < new_size; j += 3) {
7913  pkt->data[j] = 0xFC;
7914  pkt->data[j+1] = avio_r8(pb);
7915  pkt->data[j+2] = avio_r8(pb);
7916  }
7917 
7918  return 0;
7919 }
7920 
7922 {
7923  MOVContext *mov = s->priv_data;
7924  MOVStreamContext *sc;
7926  AVStream *st = NULL;
7927  int64_t current_index;
7928  int ret;
7929  mov->fc = s;
7930  retry:
7931  sample = mov_find_next_sample(s, &st);
7932  if (!sample || (mov->next_root_atom && sample->pos > mov->next_root_atom)) {
7933  if (!mov->next_root_atom)
7934  return AVERROR_EOF;
7935  if ((ret = mov_switch_root(s, mov->next_root_atom, -1)) < 0)
7936  return ret;
7937  goto retry;
7938  }
7939  sc = st->priv_data;
7940  /* must be done just before reading, to avoid infinite loop on sample */
7941  current_index = sc->current_index;
7943 
7944  if (mov->next_root_atom) {
7945  sample->pos = FFMIN(sample->pos, mov->next_root_atom);
7946  sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));
7947  }
7948 
7949  if (st->discard != AVDISCARD_ALL) {
7950  int64_t ret64 = avio_seek(sc->pb, sample->pos, SEEK_SET);
7951  if (ret64 != sample->pos) {
7952  av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
7953  sc->ffindex, sample->pos);
7954  if (should_retry(sc->pb, ret64)) {
7956  }
7957  return AVERROR_INVALIDDATA;
7958  }
7959 
7960  if (st->discard == AVDISCARD_NONKEY && !(sample->flags & AVINDEX_KEYFRAME)) {
7961  av_log(mov->fc, AV_LOG_DEBUG, "Nonkey frame from stream %d discarded due to AVDISCARD_NONKEY\n", sc->ffindex);
7962  goto retry;
7963  }
7964 
7965  if (st->codecpar->codec_id == AV_CODEC_ID_EIA_608 && sample->size > 8)
7966  ret = get_eia608_packet(sc->pb, pkt, sample->size);
7967  else
7968  ret = av_get_packet(sc->pb, pkt, sample->size);
7969  if (ret < 0) {
7970  if (should_retry(sc->pb, ret)) {
7972  }
7973  return ret;
7974  }
7975 #if CONFIG_DV_DEMUXER
7976  if (mov->dv_demux && sc->dv_audio_container) {
7977  AVBufferRef *buf = pkt->buf;
7979  pkt->buf = buf;
7981  if (ret < 0)
7982  return ret;
7983  ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
7984  if (ret < 0)
7985  return ret;
7986  }
7987 #endif
7988  if (sc->has_palette) {
7989  uint8_t *pal;
7990 
7992  if (!pal) {
7993  av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
7994  } else {
7995  memcpy(pal, sc->palette, AVPALETTE_SIZE);
7996  sc->has_palette = 0;
7997  }
7998  }
7999  if (st->codecpar->codec_id == AV_CODEC_ID_MP3 && !st->need_parsing && pkt->size > 4) {
8000  if (ff_mpa_check_header(AV_RB32(pkt->data)) < 0)
8002  }
8003  }
8004 
8005  pkt->stream_index = sc->ffindex;
8006  pkt->dts = sample->timestamp;
8007  if (sample->flags & AVINDEX_DISCARD_FRAME) {
8009  }
8010  if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {
8011  pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
8012  /* update ctts context */
8013  sc->ctts_sample++;
8014  if (sc->ctts_index < sc->ctts_count &&
8015  sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
8016  sc->ctts_index++;
8017  sc->ctts_sample = 0;
8018  }
8019  } else {
8020  int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
8022 
8023  if (next_dts >= pkt->dts)
8024  pkt->duration = next_dts - pkt->dts;
8025  pkt->pts = pkt->dts;
8026  }
8027  if (st->discard == AVDISCARD_ALL)
8028  goto retry;
8029  if (sc->sdtp_data && sc->current_sample <= sc->sdtp_count) {
8030  uint8_t sample_flags = sc->sdtp_data[sc->current_sample - 1];
8031  uint8_t sample_is_depended_on = (sample_flags >> 2) & 0x3;
8032  pkt->flags |= sample_is_depended_on == MOV_SAMPLE_DEPENDENCY_NO ? AV_PKT_FLAG_DISPOSABLE : 0;
8033  }
8034  pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
8035  pkt->pos = sample->pos;
8036 
8037  /* Multiple stsd handling. */
8038  if (sc->stsc_data) {
8039  /* Keep track of the stsc index for the given sample, then check
8040  * if the stsd index is different from the last used one. */
8041  sc->stsc_sample++;
8042  if (mov_stsc_index_valid(sc->stsc_index, sc->stsc_count) &&
8043  mov_get_stsc_samples(sc, sc->stsc_index) == sc->stsc_sample) {
8044  sc->stsc_index++;
8045  sc->stsc_sample = 0;
8046  /* Do not check indexes after a switch. */
8047  } else if (sc->stsc_data[sc->stsc_index].id > 0 &&
8048  sc->stsc_data[sc->stsc_index].id - 1 < sc->stsd_count &&
8049  sc->stsc_data[sc->stsc_index].id - 1 != sc->last_stsd_index) {
8050  ret = mov_change_extradata(sc, pkt);
8051  if (ret < 0)
8052  return ret;
8053  }
8054  }
8055 
8056  if (mov->aax_mode)
8057  aax_filter(pkt->data, pkt->size, mov);
8058 
8059  ret = cenc_filter(mov, st, sc, pkt, current_index);
8060  if (ret < 0) {
8061  return ret;
8062  }
8063 
8064  return 0;
8065 }
8066 
8067 static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
8068 {
8069  MOVContext *mov = s->priv_data;
8070  int index;
8071 
8072  if (!mov->frag_index.complete)
8073  return 0;
8074 
8075  index = search_frag_timestamp(&mov->frag_index, st, timestamp);
8076  if (index < 0)
8077  index = 0;
8078  if (!mov->frag_index.item[index].headers_read)
8079  return mov_switch_root(s, -1, index);
8080  if (index + 1 < mov->frag_index.nb_items)
8081  mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
8082 
8083  return 0;
8084 }
8085 
8086 static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
8087 {
8088  MOVStreamContext *sc = st->priv_data;
8089  int sample, time_sample, ret;
8090  unsigned int i;
8091 
8092  // Here we consider timestamp to be PTS, hence try to offset it so that we
8093  // can search over the DTS timeline.
8094  timestamp -= (sc->min_corrected_pts + sc->dts_shift);
8095 
8096  ret = mov_seek_fragment(s, st, timestamp);
8097  if (ret < 0)
8098  return ret;
8099 
8100  sample = av_index_search_timestamp(st, timestamp, flags);
8101  av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
8102  if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
8103  sample = 0;
8104  if (sample < 0) /* not sure what to do */
8105  return AVERROR_INVALIDDATA;
8107  av_log(s, AV_LOG_TRACE, "stream %d, found sample %d\n", st->index, sc->current_sample);
8108  /* adjust ctts index */
8109  if (sc->ctts_data) {
8110  time_sample = 0;
8111  for (i = 0; i < sc->ctts_count; i++) {
8112  int next = time_sample + sc->ctts_data[i].count;
8113  if (next > sc->current_sample) {
8114  sc->ctts_index = i;
8115  sc->ctts_sample = sc->current_sample - time_sample;
8116  break;
8117  }
8118  time_sample = next;
8119  }
8120  }
8121 
8122  /* adjust stsd index */
8123  if (sc->chunk_count) {
8124  time_sample = 0;
8125  for (i = 0; i < sc->stsc_count; i++) {
8126  int64_t next = time_sample + mov_get_stsc_samples(sc, i);
8127  if (next > sc->current_sample) {
8128  sc->stsc_index = i;
8129  sc->stsc_sample = sc->current_sample - time_sample;
8130  break;
8131  }
8132  av_assert0(next == (int)next);
8133  time_sample = next;
8134  }
8135  }
8136 
8137  return sample;
8138 }
8139 
8140 static int64_t mov_get_skip_samples(AVStream *st, int sample)
8141 {
8142  MOVStreamContext *sc = st->priv_data;
8143  int64_t first_ts = st->index_entries[0].timestamp;
8144  int64_t ts = st->index_entries[sample].timestamp;
8145  int64_t off;
8146 
8148  return 0;
8149 
8150  /* compute skip samples according to stream start_pad, seek ts and first ts */
8151  off = av_rescale_q(ts - first_ts, st->time_base,
8152  (AVRational){1, st->codecpar->sample_rate});
8153  return FFMAX(sc->start_pad - off, 0);
8154 }
8155 
8156 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
8157 {
8158  MOVContext *mc = s->priv_data;
8159  AVStream *st;
8160  int sample;
8161  int i;
8162 
8163  if (stream_index >= s->nb_streams)
8164  return AVERROR_INVALIDDATA;
8165 
8166  st = s->streams[stream_index];
8167  sample = mov_seek_stream(s, st, sample_time, flags);
8168  if (sample < 0)
8169  return sample;
8170 
8171  if (mc->seek_individually) {
8172  /* adjust seek timestamp to found sample timestamp */
8173  int64_t seek_timestamp = st->index_entries[sample].timestamp;
8175 
8176  for (i = 0; i < s->nb_streams; i++) {
8177  int64_t timestamp;
8178  st = s->streams[i];
8179 
8180  if (stream_index == i)
8181  continue;
8182 
8183  timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
8184  sample = mov_seek_stream(s, st, timestamp, flags);
8185  if (sample >= 0)
8187  }
8188  } else {
8189  for (i = 0; i < s->nb_streams; i++) {
8190  MOVStreamContext *sc;
8191  st = s->streams[i];
8192  sc = st->priv_data;
8193  mov_current_sample_set(sc, 0);
8194  }
8195  while (1) {
8196  MOVStreamContext *sc;
8197  AVIndexEntry *entry = mov_find_next_sample(s, &st);
8198  if (!entry)
8199  return AVERROR_INVALIDDATA;
8200  sc = st->priv_data;
8201  if (sc->ffindex == stream_index && sc->current_sample == sample)
8202  break;
8204  }
8205  }
8206  return 0;
8207 }
8208 
8209 #define OFFSET(x) offsetof(MOVContext, x)
8210 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
8211 static const AVOption mov_options[] = {
8212  {"use_absolute_path",
8213  "allow using absolute path when opening alias, this is a possible security issue",
8214  OFFSET(use_absolute_path), AV_OPT_TYPE_BOOL, {.i64 = 0},
8215  0, 1, FLAGS},
8216  {"seek_streams_individually",
8217  "Seek each stream individually to the closest point",
8218  OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
8219  0, 1, FLAGS},
8220  {"ignore_editlist", "Ignore the edit list atom.", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
8221  0, 1, FLAGS},
8222  {"advanced_editlist",
8223  "Modify the AVIndex according to the editlists. Use this option to decode in the order specified by the edits.",
8224  OFFSET(advanced_editlist), AV_OPT_TYPE_BOOL, {.i64 = 1},
8225  0, 1, FLAGS},
8226  {"ignore_chapters", "", OFFSET(ignore_chapters), AV_OPT_TYPE_BOOL, {.i64 = 0},
8227  0, 1, FLAGS},
8228  {"use_mfra_for",
8229  "use mfra for fragment timestamps",
8230  OFFSET(use_mfra_for), AV_OPT_TYPE_INT, {.i64 = FF_MOV_FLAG_MFRA_AUTO},
8232  "use_mfra_for"},
8233  {"auto", "auto", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_AUTO}, 0, 0,
8234  FLAGS, "use_mfra_for" },
8235  {"dts", "dts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_DTS}, 0, 0,
8236  FLAGS, "use_mfra_for" },
8237  {"pts", "pts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_PTS}, 0, 0,
8238  FLAGS, "use_mfra_for" },
8239  { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
8240  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
8241  { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
8242  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
8243  { "activation_bytes", "Secret bytes for Audible AAX files", OFFSET(activation_bytes),
8245  { "audible_key", "AES-128 Key for Audible AAXC files", OFFSET(audible_key),
8247  { "audible_iv", "AES-128 IV for Audible AAXC files", OFFSET(audible_iv),
8249  { "audible_fixed_key", // extracted from libAAX_SDK.so and AAXSDKWin.dll files!
8250  "Fixed key used for handling Audible AAX files", OFFSET(audible_fixed_key),
8251  AV_OPT_TYPE_BINARY, {.str="77214d4b196a87cd520045fd20a51d67"},
8252  .flags = AV_OPT_FLAG_DECODING_PARAM },
8253  { "decryption_key", "The media decryption key (hex)", OFFSET(decryption_key), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
8254  { "enable_drefs", "Enable external track support.", OFFSET(enable_drefs), AV_OPT_TYPE_BOOL,
8255  {.i64 = 0}, 0, 1, FLAGS },
8256 
8257  { NULL },
8258 };
8259 
8260 static const AVClass mov_class = {
8261  .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
8262  .item_name = av_default_item_name,
8263  .option = mov_options,
8264  .version = LIBAVUTIL_VERSION_INT,
8265 };
8266 
8268  .name = "mov,mp4,m4a,3gp,3g2,mj2",
8269  .long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
8270  .priv_class = &mov_class,
8271  .priv_data_size = sizeof(MOVContext),
8272  .extensions = "mov,mp4,m4a,3gp,3g2,mj2,psp,m4b,ism,ismv,isma,f4v",
8273  .read_probe = mov_probe,
8279 };
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:89
int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key)
Initialize an AVAESCTR context.
Definition: aes_ctr.c:69
void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t *iv)
Forcefully change the "full" 16-byte iv, including the counter.
Definition: aes_ctr.c:48
struct AVAESCTR * av_aes_ctr_alloc(void)
Allocate an AVAESCTR context.
Definition: aes_ctr.c:36
void av_aes_ctr_free(struct AVAESCTR *a)
Release an AVAESCTR context.
Definition: aes_ctr.c:84
void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int count)
Process a buffer using a previously initialized context.
Definition: aes_ctr.c:111
#define AES_CTR_KEY_SIZE
Definition: aes_ctr.h:30
static double val(void *priv, double ch)
Definition: aeval.c:76
static const char *const format[]
Definition: af_aiir.c:456
Macro definitions for various function/variable attributes.
uint8_t
int32_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:1603
Main libavformat public API header.
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1562
#define AVINDEX_KEYFRAME
Definition: avformat.h:811
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1365
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:470
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2417
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:841
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:484
#define AVINDEX_DISCARD_FRAME
Definition: avformat.h:812
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2415
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:818
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers.
Definition: avformat.h:846
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:795
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:794
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:902
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:766
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:364
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:337
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:750
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:860
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:774
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:781
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:998
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:682
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:88
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
Definition: avpacket.c:343
#define AV_RB32
Definition: intreadwrite.h:130
#define AV_RB16
Definition: intreadwrite.h:53
#define AV_RL32
Definition: intreadwrite.h:146
#define AV_RB64
Definition: intreadwrite.h:164
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
#define av_bswap32
Definition: bswap.h:33
#define flag(name)
Definition: cbs_av1.c:553
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
#define s(width, name)
Definition: cbs_vp9.c:257
#define f(width, name)
Definition: cbs_vp9.c:255
uint64_t layout
audio channel layout utility functions
#define fail()
Definition: checkasm.h:133
AVFieldOrder
Definition: codec_par.h:36
@ AV_FIELD_TT
Definition: codec_par.h:39
@ AV_FIELD_BB
Definition: codec_par.h:40
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
@ AV_FIELD_BT
Definition: codec_par.h:42
@ AV_FIELD_TB
Definition: codec_par.h:41
#define FFSWAP(type, a, b)
Definition: common.h:108
#define FFMIN(a, b)
Definition: common.h:105
#define MKTAG(a, b, c, d)
Definition: common.h:478
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define FFNABS(a)
Negative Absolute value.
Definition: common.h:81
#define av_sat_add64
Definition: common.h:164
#define FFMAX(a, b)
Definition: common.h:103
#define av_clip_uint8
Definition: common.h:128
#define PUT_UTF8(val, tmp, PUT_BYTE)
Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
Definition: common.h:552
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define NULL
Definition: coverity.c:32
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:258
Public dictionary API.
Display matrix.
AVDOVIDecoderConfigurationRecord * av_dovi_alloc(size_t *size)
Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its fields to default values.
Definition: dovi_meta.c:24
DOVI configuration.
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
uint8_t * av_encryption_info_add_side_data(const AVEncryptionInfo *info, size_t *size)
Allocates and initializes side data that holds a copy of the given encryption info.
uint8_t * av_encryption_init_info_add_side_data(const AVEncryptionInitInfo *info, size_t *side_data_size)
Allocates and initializes side data that holds a copy of the given encryption init info.
AVEncryptionInfo * av_encryption_info_alloc(uint32_t subsample_count, uint32_t key_id_size, uint32_t iv_size)
Allocates an AVEncryptionInfo structure and sub-pointers to hold the given number of subsamples.
AVEncryptionInitInfo * av_encryption_init_info_alloc(uint32_t system_id_size, uint32_t num_key_ids, uint32_t key_id_size, uint32_t data_size)
Allocates an AVEncryptionInitInfo structure and sub-pointers to hold the given sizes.
AVEncryptionInfo * av_encryption_info_clone(const AVEncryptionInfo *info)
Allocates an AVEncryptionInfo structure with a copy of the given data.
void av_encryption_init_info_free(AVEncryptionInitInfo *info)
Frees the given encryption init info object.
AVEncryptionInitInfo * av_encryption_init_info_get_side_data(const uint8_t *side_data, size_t side_data_size)
Creates a copy of the AVEncryptionInitInfo that is contained in the given side data.
void av_encryption_info_free(AVEncryptionInfo *info)
Frees the given encryption info object.
double value
Definition: eval.c:98
enum AVCodecID id
int
static int64_t start_time
Definition: ffplay.c:332
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.h:145
@ FLAC_METADATA_TYPE_STREAMINFO
Definition: flac.h:48
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
#define sample
bitstream reader API header.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:231
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define AV_CH_SIDE_LEFT
#define AV_CH_FRONT_RIGHT
#define AV_CH_FRONT_CENTER
#define AV_CH_SIDE_RIGHT
#define AV_CH_LOW_FREQUENCY
#define AV_CH_FRONT_LEFT
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AVAudioServiceType
Definition: avcodec.h:239
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:334
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:326
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:429
@ AV_CODEC_ID_H261
Definition: codec_id.h:52
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:70
@ AV_CODEC_ID_PNG
Definition: codec_id.h:110
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:464
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:318
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
@ AV_CODEC_ID_GSM
as in Berlin toast format
Definition: codec_id.h:442
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:523
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:333
@ AV_CODEC_ID_SVQ3
Definition: codec_id.h:72
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
@ AV_CODEC_ID_AVS
Definition: codec_id.h:131
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:137
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:314
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:325
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:321
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:317
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:359
@ AV_CODEC_ID_VC1
Definition: codec_id.h:119
@ AV_CODEC_ID_VP8
Definition: codec_id.h:189
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:336
@ AV_CODEC_ID_ALAC
Definition: codec_id.h:440
@ AV_CODEC_ID_EIA_608
Definition: codec_id.h:534
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:406
@ AV_CODEC_ID_MP2
Definition: codec_id.h:424
@ AV_CODEC_ID_DVAUDIO
Definition: codec_id.h:430
@ AV_CODEC_ID_ADPCM_IMA_QT
Definition: codec_id.h:353
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
@ AV_CODEC_ID_BIN_DATA
Definition: codec_id.h:564
@ AV_CODEC_ID_AAC
Definition: codec_id.h:426
@ AV_CODEC_ID_BMP
Definition: codec_id.h:127
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:335
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
@ AV_CODEC_ID_QCELP
Definition: codec_id.h:448
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:407
@ AV_CODEC_ID_AC3
Definition: codec_id.h:427
@ AV_CODEC_ID_MACE3
Definition: codec_id.h:433
@ AV_CODEC_ID_MACE6
Definition: codec_id.h:434
@ AV_CODEC_ID_QDM2
Definition: codec_id.h:443
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:322
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:148
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition: codec_id.h:354
@ AV_CODEC_ID_R10K
Definition: codec_id.h:194
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:459
@ AV_CODEC_ID_AVUI
Definition: codec_id.h:253
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:483
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:425
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
@ AV_CODEC_ID_QDMC
Definition: codec_id.h:474
@ AV_CODEC_ID_TARGA_Y216
Definition: codec_id.h:255
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: avcodec.h:248
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition: avcodec.h:215
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:235
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:613
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:417
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
Definition: packet.h:429
FF_ENABLE_DEPRECATION_WARNINGS int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:309
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
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition: packet.h:274
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:120
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:46
@ AV_PKT_DATA_ENCRYPTION_INFO
This side data contains encryption info for how to decrypt the packet.
Definition: packet.h:255
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
@ AV_PKT_DATA_ENCRYPTION_INIT_INFO
This side data is encryption initialization data.
Definition: packet.h:249
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:114
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:235
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:283
uint8_t * av_stream_new_side_data(AVStream *stream, enum AVPacketSideDataType type, size_t size)
Allocate new information from stream.
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
Definition: utils.c:5518
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4432
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4505
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:4795
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2128
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
Definition: aes.c:195
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:31
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: aes.c:163
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:74
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
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:76
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
Definition: dict.h:72
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
Definition: dict.c:147
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:188
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
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
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:161
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:206
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
#define AV_FOURCC_MAX_STRING_SIZE
Definition: avutil.h:346
char * av_fourcc_make_string(char *buf, uint32_t fourcc)
Fill the provided buffer with a string containing a FourCC (four-character code) representation.
Definition: utils.c:121
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:45
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:315
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:345
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Definition: sha.c:273
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:93
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
Definition: avstring.c:56
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
AVSphericalProjection
Projection of the video surface(s) on a sphere.
Definition: spherical.h:51
AVSphericalMapping * av_spherical_alloc(size_t *size)
Allocate a AVSphericalVideo structure and initialize its fields to default values.
Definition: spherical.c:25
@ AV_SPHERICAL_EQUIRECTANGULAR
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:72
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
AVStereo3DType
List of possible 3D Types.
Definition: stereo3d.h:51
AVStereo3D * av_stereo3d_alloc(void)
Allocate an AVStereo3D structure and set its fields to default values.
Definition: stereo3d.c:28
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:79
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:67
int index
Definition: gxfenc.c:89
cl_device_type type
const char * key
const char *const ff_id3v1_genre_str[ID3v1_GENRE_MAX+1]
ID3v1 genres.
Definition: id3v1.c:27
#define ID3v1_GENRE_MAX
Definition: id3v1.h:29
int i
Definition: input.c:407
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define AV_RB8(x)
Definition: intreadwrite.h:395
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
#define AV_WB8(p, d)
Definition: intreadwrite.h:396
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
int ff_mov_lang_to_iso639(unsigned code, char to[4])
Definition: isom.c:260
const AVCodecTag ff_codec_movdata_tags[]
Definition: isom.c:82
const AVCodecTag ff_codec_movsubtitle_tags[]
Definition: isom.c:75
#define MOV_TRUN_SAMPLE_DURATION
Definition: isom.h:324
int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb)
Definition: mov_esds.c:23
#define FF_MOV_FLAG_MFRA_PTS
Definition: isom.h:373
#define MOV_TRUN_SAMPLE_CTS
Definition: isom.h:327
#define MOV_TKHD_FLAG_ENABLED
Definition: isom.h:339
#define MOV_TFHD_DEFAULT_BASE_IS_MOOF
Definition: isom.h:320
#define FF_MOV_FLAG_MFRA_DTS
Definition: isom.h:372
const AVCodecTag ff_codec_movaudio_tags[]
Definition: isom_tags.c:278
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES
Definition: isom.h:337
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
#define MOV_TFHD_DEFAULT_SIZE
Definition: isom.h:317
#define TAG_IS_AVCI(tag)
Definition: isom.h:349
#define MOV_TRUN_FIRST_SAMPLE_FLAGS
Definition: isom.h:323
#define MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC
Definition: isom.h:330
#define MOV_TFHD_STSD_ID
Definition: isom.h:315
#define MOV_TRUN_SAMPLE_FLAGS
Definition: isom.h:326
#define MOV_TFHD_DEFAULT_FLAGS
Definition: isom.h:318
#define MOV_TRUN_DATA_OFFSET
Definition: isom.h:322
#define MOV_TFHD_BASE_DATA_OFFSET
Definition: isom.h:314
static enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
Compute codec id for 'lpcm' tag.
Definition: isom.h:379
#define MOV_TRUN_SAMPLE_SIZE
Definition: isom.h:325
#define MOV_SAMPLE_DEPENDENCY_NO
Definition: isom.h:346
#define FF_MOV_FLAG_MFRA_AUTO
Definition: isom.h:371
#define MOV_TFHD_DEFAULT_DURATION
Definition: isom.h:316
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:371
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:338
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:354
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3406
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts)
add frame for rfps calculation.
Definition: utils.c:3346
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: utils.c:2063
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5366
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:4941
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3312
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5688
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4635
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:3330
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3129
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
#define FF_API_OLD_ROTATE_API
Definition: version.h:80
common internal API header
int buffer_size_t
Definition: internal.h:306
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
Stereoscopic video.
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
version
Definition: libkvazaar.c:320
#define isnan(x)
Definition: libm.h:340
static av_const double hypot(double x, double y)
Definition: libm.h:366
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc(void)
Copyright (c) 2016 Neil Birkbeck neil.birkbeck@gmail.com
static int truehd_channels(int chanmap)
Definition: mlp_parse.h:88
static int mlp_samplerate(int in)
Definition: mlp_parse.h:80
static uint64_t truehd_layout(int chanmap)
Definition: mlp_parse.h:98
static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4364
static int64_t mov_get_skip_samples(AVStream *st, int sample)
Definition: mov.c:8140
static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
Definition: mov.c:1239
static int update_frag_index(MOVContext *c, int64_t offset)
Definition: mov.c:1332
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mov.c:8156
static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2589
static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
Definition: mov.c:2105
static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6752
static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
Definition: mov.c:7841
static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1821
#define MAX_REORDER_DELAY
Definition: mov.c:3383
static int aax_filter(uint8_t *input, int size, MOVContext *c)
Definition: mov.c:1110
static void mov_current_sample_dec(MOVStreamContext *sc)
Definition: mov.c:3452
static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
Definition: mov.c:8086
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mov.c:7921
static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6990
AVInputFormat ff_mov_demuxer
Definition: mov.c:8267
static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2786
static int64_t get_stream_info_time(MOVFragmentStreamInfo *frag_stream_info)
Definition: mov.c:1263
static int mov_try_read_block(AVIOContext *pb, size_t size, uint8_t **data)
Tries to read the given number of bytes from the stream and puts it in a newly allocated buffer.
Definition: mov.c:6192
static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6291
static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb, int codec_tag, int format, int64_t size)
Definition: mov.c:2468
#define DRM_BLOB_SIZE
Definition: mov.c:984
static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1446
static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5329
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
Definition: mov.c:2496
static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:125
static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:575
static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time, void *logctx)
Definition: mov.c:1431
static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1753
static uint32_t yuv_to_rgba(uint32_t ycbcr)
Definition: mov.c:2288
static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1869
static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
Definition: mov.c:281
static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2834
static int64_t get_frag_time(MOVFragmentIndex *frag_index, int index, int track_id)
Definition: mov.c:1273
static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:536
static int mov_read_header(AVFormatContext *s)
Definition: mov.c:7598
static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6597
static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2017
static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5549
static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5260
static int test_same_origin(const char *src, const char *ref)
Definition: mov.c:4124
static int mov_read_av1c(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5340
static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
Definition: mov.c:3464
static int mov_aaxc_crypto(MOVContext *c)
Definition: mov.c:1085
static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5596
static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:864
static int mov_read_sdtp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:3002
static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2927
static int cenc_filter(MOVContext *mov, AVStream *st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
Definition: mov.c:6688
static const AVClass mov_class
Definition: mov.c:8260
static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVStreamContext *sc, AVEncryptionInfo **sample, int use_subsamples)
Definition: mov.c:6020
static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4497
static int mov_read_smdm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5412
static const uint32_t mac_to_unicode[128]
Definition: mov.c:141
static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5053
static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
An strf atom is a BITMAPINFOHEADER struct.
Definition: mov.c:1995
static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index, int id, int entries)
Definition: mov.c:1390
static int mov_read_rtmd_track(AVFormatContext *s, AVStream *st)
Definition: mov.c:7316
static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:824
static int mov_read_dmlp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6801
static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:102
static int mov_read_schm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6495
static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
Definition: mov.c:231
static int read_tfra(MOVContext *mov, AVIOContext *f)
Definition: mov.c:7497
static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
Definition: mov.c:8067
static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom, enum AVCodecID codec_id)
Definition: mov.c:1712
static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1546
static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
Definition: mov.c:182
static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:986
#define FLAGS
Definition: mov.c:8210
static int mov_stsc_index_valid(unsigned int index, unsigned int count)
Definition: mov.c:2729
static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:717
static int mov_read_dvcc_dvvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6833
static int should_retry(AVIOContext *pb, int error_code)
Definition: mov.c:7834
static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1495
static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4732
static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1166
static int mov_read_clli(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5525
static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4770
static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logctx)
Definition: mov.c:3036
static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:3113
static MOVFragmentStreamInfo * get_frag_stream_info(MOVFragmentIndex *frag_index, int index, int id)
Definition: mov.c:1184
static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:82
static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1780
static int mov_rewrite_dvd_sub_extradata(AVStream *st)
Definition: mov.c:2304
static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6386
static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
Definition: mov.c:2386
static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4523
static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1738
static int mov_read_mfra(MOVContext *c, AVIOContext *f)
Definition: mov.c:7552
#define MIN_DATA_ENTRY_BOX_SIZE
Definition: mov.c:574
static int mov_read_mdcv(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5454
static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
Definition: mov.c:7341
static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2750
static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1864
static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st, uint32_t value, int flags)
Definition: mov.c:7302
static int find_prev_closest_index(AVStream *st, AVIndexEntry *e_old, int nb_old, MOVStts *ctts_data, int64_t ctts_count, int64_t timestamp_pts, int flag, int64_t *index, int64_t *ctts_index, int64_t *ctts_sample)
Find the closest previous frame to the timestamp_pts, in e_old index entries.
Definition: mov.c:3205
static const MOVParseTableEntry mov_default_parse_table[]
Definition: mov.c:6890
static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1748
static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4706
static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6219
static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5901
static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2654
static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int64_t size)
Definition: mov.c:2336
static MOVFragmentStreamInfo * get_current_frag_stream_info(MOVFragmentIndex *frag_index)
Definition: mov.c:1223
static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:976
static AVIndexEntry * mov_find_next_sample(AVFormatContext *s, AVStream **st)
Definition: mov.c:7808
static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:116
static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1758
static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
Definition: mov.c:4225
static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4416
static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:788
static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encryption_index, MOVStreamContext **sc)
Gets the current encryption info and associated current stream context.
Definition: mov.c:5970
static int mov_read_close(AVFormatContext *s)
Definition: mov.c:7381
static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:952
static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
Definition: mov.c:4153
static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1743
static int mov_read_tenc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6526
static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5796
static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:918
static void mov_build_index(MOVContext *mov, AVStream *st)
Definition: mov.c:3796
static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:3047
static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4373
static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:937
static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
This function reads atom content and puts data in extradata without tag nor size unlike mov_read_extr...
Definition: mov.c:1926
static int get_eia608_packet(AVIOContext *pb, AVPacket *pkt, int size)
Definition: mov.c:7900
static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1124
#define IS_MATRIX_IDENT(matrix)
Definition: mov.c:4515
static int64_t add_ctts_entry(MOVStts **ctts_data, unsigned int *ctts_count, unsigned int *allocated_size, int count, int duration)
Append a new ctts entry to ctts_data.
Definition: mov.c:3356
static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOContext *pb, MOVEncryptionIndex *encryption_index)
Definition: mov.c:6125
static int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
Definition: mov.c:2735
static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5368
static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add index entry with the given values, to the end of st->index_entries.
Definition: mov.c:3301
static void mov_fix_index(MOVContext *mov, AVStream *st)
Fix st->index_entries, so that it contains only the entries (and the entries which are needed to deco...
Definition: mov.c:3492
#define DDTS_SIZE
static int cenc_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
Definition: mov.c:6634
static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6071
static void fix_index_entry_timestamps(AVStream *st, int end_index, int64_t end_ts, int64_t *frame_duration_buffer, int frame_duration_buffer_size)
Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size,...
Definition: mov.c:3341
static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4235
static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1578
static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int64_t size)
Definition: mov.c:2274
static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1965
static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom, AVCodecParameters *par, uint8_t *buf)
Definition: mov.c:1690
static void mov_free_encryption_index(MOVEncryptionIndex **index)
Definition: mov.c:7369
static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len, char *dst, int dstlen)
Definition: mov.c:160
#define OFFSET(x)
Definition: mov.c:8209
static int search_frag_timestamp(MOVFragmentIndex *frag_index, AVStream *st, int64_t timestamp)
Definition: mov.c:1298
static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4687
static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1405
static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
Definition: mov.c:1675
static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:300
static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5493
static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5923
static int mov_codec_id(AVStream *st, uint32_t format)
Definition: mov.c:2070
static void export_orphan_timecode(AVFormatContext *s)
Definition: mov.c:7479
static void mov_estimate_video_delay(MOVContext *c, AVStream *st)
Definition: mov.c:3384
static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4641
static int mov_probe(const AVProbeData *p)
Definition: mov.c:7112
static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
Definition: mov.c:5733
static void mov_current_sample_inc(MOVStreamContext *sc)
Definition: mov.c:3440
static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1641
static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1766
static int get_edit_list_entry(MOVContext *mov, const MOVStreamContext *msc, unsigned int edit_list_index, int64_t *edit_list_media_time, int64_t *edit_list_duration, int64_t global_timescale)
Get ith edit list entry (media time, duration).
Definition: mov.c:3163
static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
Definition: mov.c:2163
static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5186
static int mov_change_extradata(MOVStreamContext *sc, AVPacket *pkt)
Definition: mov.c:7877
static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:783
#define ALAC_EXTRADATA_SIZE
static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
Definition: mov.c:7463
static void mov_read_chapters(AVFormatContext *s)
Definition: mov.c:7203
static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5206
static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
Definition: mov.c:1203
static const AVOption mov_options[]
Definition: mov.c:8211
int ff_mov_read_chan(AVFormatContext *s, AVIOContext *pb, AVStream *st, int64_t size)
Read 'chan' tag from the input stream.
Definition: mov_chan.c:547
uint32_t tag
Definition: movenc.c:1600
MPEG Audio header decoder.
static int ff_mpa_check_header(uint32_t header)
const char data[16]
Definition: mxf.c:142
int cid
Definition: mxfenc.c:2039
static float distance(float x, float y, int band)
#define OPUS_SEEK_PREROLL_MS
Definition: oggparseopus.c:35
AVOptions.
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2940
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2961
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2919
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:569
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:461
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:486
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:515
int ff_get_qtpalette(int codec_id, AVIOContext *pb, uint32_t *palette)
Retrieve the palette (or "color table" in QuickTime terms), either from the video sample description,...
Definition: qtpalette.c:323
#define tc
Definition: regdef.h:69
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
Definition: replaygain.c:91
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:33
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:508
internal header for RIFF based (de)muxers do NOT include this in end user applications
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
static char buffer[20]
Definition: seek.c:32
Public header for SHA-1 & SHA-256 hash function implementations.
#define snprintf
Definition: snprintf.h:34
unsigned int pos
Definition: spdifenc.c:412
Spherical video.
A reference to a data buffer.
Definition: buffer.h:84
Describe the class of an AVClass context structure.
Definition: log.h:67
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
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1261
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
enum AVColorSpace color_space
Definition: codec_par.h:149
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int frame_size
Audio only.
Definition: codec_par.h:181
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int channels
Audio only.
Definition: codec_par.h:166
int width
Video only.
Definition: codec_par.h:126
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
int seek_preroll
Audio only.
Definition: codec_par.h:200
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
int block_align
Audio only.
Definition: codec_par.h:177
int video_delay
Video only.
Definition: codec_par.h:155
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
int sample_rate
Audio only.
Definition: codec_par.h:170
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
int initial_padding
Audio only.
Definition: codec_par.h:189
enum AVColorRange color_range
Video only.
Definition: codec_par.h:146
unsigned MaxFALL
Max average light level per frame (cd/m^2).
unsigned MaxCLL
Max content light level (cd/m^2).
char * value
Definition: dict.h:83
This describes encryption info for a packet.
uint32_t skip_byte_block
Only used for pattern encryption.
uint8_t * iv
The initialization vector.
uint32_t crypt_byte_block
Only used for pattern encryption.
uint8_t * key_id
The ID of the key used to encrypt the packet.
uint32_t scheme
The fourcc encryption scheme, in big-endian byte order.
This describes info used to initialize an encryption key system.
uint8_t * data
Key-system specific initialization data.
struct AVEncryptionInitInfo * next
An optional pointer to the next initialization info in the list.
uint8_t ** key_ids
An array of key IDs this initialization data is for.
uint8_t * system_id
A unique identifier for the key system this is for, can be NULL if it is not known.
uint32_t num_key_ids
The number of key IDs.
Format I/O context.
Definition: avformat.h:1232
Bytestream IO Context.
Definition: avio.h:161
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
int64_t pos
Definition: avformat.h:804
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
Definition: avformat.h:815
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:805
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:352
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
uint8_t * data
Definition: packet.h:369
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
hash context
Definition: sha.c:34
uint64_t count
number of bytes in buffer
Definition: sha.c:36
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:167
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:168
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:170
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:169
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet.
Definition: internal.h:258
Stream structure.
Definition: avformat.h:873
unsigned int index_entries_allocated_size
Definition: avformat.h:1093
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:935
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:924
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:928
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
AVDictionary * metadata
Definition: avformat.h:937
void * priv_data
Definition: avformat.h:888
int id
Format-specific stream ID.
Definition: avformat.h:880
int index
stream index in AVFormatContext
Definition: avformat.h:874
int nb_index_entries
Definition: avformat.h:1092
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:912
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:955
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:946
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:902
attribute_deprecated AVCodecContext * codec
Definition: avformat.h:886
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1090
enum AVStreamParseType need_parsing
Definition: avformat.h:1081
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1015
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1113
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:926
This file is part of FFmpeg.
Definition: isom.h:82
uint32_t type
Definition: isom.h:83
int64_t size
Definition: isom.h:84
int handbrake_version
Definition: isom.h:264
int * bitrates
bitrates read before streams creation
Definition: isom.h:275
int ignore_editlist
Definition: isom.h:268
unsigned meta_keys_count
Definition: isom.h:256
char ** meta_keys
Definition: isom.h:255
AVFormatContext * fc
Definition: isom.h:248
unsigned int aax_mode
'aax' file has been detected
Definition: isom.h:282
int found_mdat
'mdat' atom has been found
Definition: isom.h:252
int bitrates_count
Definition: isom.h:276
int * chapter_tracks
Definition: isom.h:265
int64_t next_root_atom
offset of the next root atom
Definition: isom.h:272
int ignore_chapters
Definition: isom.h:270
DVDemuxContext * dv_demux
Definition: isom.h:257
unsigned int nb_chapter_tracks
Definition: isom.h:266
uint8_t * decryption_key
Definition: isom.h:294
MOVFragmentIndex frag_index
Definition: isom.h:280
MOVTrackExt * trex_data
Definition: isom.h:261
struct AVAES * aes_decrypt
Definition: isom.h:293
int decryption_key_len
Definition: isom.h:295
MOVFragment fragment
current fragment in moof atom
Definition: isom.h:260
AVFormatContext * dv_fctx
Definition: isom.h:258
int moov_retry
Definition: isom.h:277
int time_scale
Definition: isom.h:249
int found_moov
'moov' atom has been found
Definition: isom.h:251
int advanced_editlist
Definition: isom.h:269
int trak_index
Index of the current 'trak'.
Definition: isom.h:254
int use_mfra_for
Definition: isom.h:278
Definition: isom.h:73
char volume[28]
Definition: isom.h:77
char * dir
Definition: isom.h:76
int16_t nlvl_to
Definition: isom.h:79
char * path
Definition: isom.h:75
uint32_t type
Definition: isom.h:74
int16_t nlvl_from
Definition: isom.h:79
char filename[64]
Definition: isom.h:78
Definition: isom.h:67
float rate
Definition: isom.h:70
int64_t duration
Definition: isom.h:68
int64_t time
Definition: isom.h:69
uint64_t * auxiliary_offsets
Absolute seek position.
Definition: isom.h:123
unsigned int nb_encrypted_samples
Definition: isom.h:117
size_t auxiliary_offsets_count
Definition: isom.h:124
size_t auxiliary_info_sample_count
Definition: isom.h:121
uint8_t auxiliary_info_default_size
Definition: isom.h:122
uint8_t * auxiliary_info_sizes
Definition: isom.h:120
AVEncryptionInfo ** encrypted_samples
Definition: isom.h:118
MOVFragmentStreamInfo * stream_info
Definition: isom.h:142
int64_t moof_offset
Definition: isom.h:138
MOVFragmentIndexItem * item
Definition: isom.h:150
int complete
Definition: isom.h:147
int nb_items
Definition: isom.h:149
MOVEncryptionIndex * encryption_index
Definition: isom.h:134
int64_t tfdt_dts
Definition: isom.h:131
int64_t next_trun_dts
Definition: isom.h:132
int64_t first_tfra_pts
Definition: isom.h:130
int64_t sidx_pts
Definition: isom.h:129
unsigned track_id
Definition: isom.h:91
unsigned flags
Definition: isom.h:98
unsigned duration
Definition: isom.h:96
int found_tfhd
Definition: isom.h:90
unsigned size
Definition: isom.h:97
unsigned stsd_id
Definition: isom.h:95
uint64_t base_data_offset
Definition: isom.h:92
uint64_t moof_offset
Definition: isom.h:93
uint64_t implicit_offset
Definition: isom.h:94
int64_t start
Definition: isom.h:154
int64_t end
Definition: isom.h:155
int(* parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:74
uint32_t type
Definition: mov.c:73
unsigned int index
Definition: isom.h:111
unsigned int count
Definition: isom.h:110
int64_t time_offset
time offset of the edit list entries
Definition: isom.h:190
int64_t duration_for_fps
Definition: isom.h:218
AVIOContext * pb
Definition: isom.h:159
size_t spherical_size
Definition: isom.h:230
uint8_t ** extradata
extradata array (and size) for multiple stsd
Definition: isom.h:221
MOVSbgp * rap_group
Definition: isom.h:215
MOVEncryptionIndex * encryption_index
Definition: isom.h:242
int64_t track_end
used for dts generation in fragmented movie files
Definition: isom.h:212
int pseudo_stream_id
-1 means demux all ids
Definition: isom.h:199
unsigned int rap_group_count
Definition: isom.h:214
int height
tkhd height
Definition: isom.h:206
int stsc_sample
Definition: isom.h:175
MOVDref * drefs
Definition: isom.h:202
MOVStts * ctts_data
Definition: isom.h:171
unsigned int ctts_allocated_size
Definition: isom.h:170
unsigned int per_sample_iv_size
Definition: isom.h:240
int * extradata_size
Definition: isom.h:222
struct MOVStreamContext::@261 cenc
size_t coll_size
Definition: isom.h:233
int dv_audio_container
Definition: isom.h:198
AVContentLightMetadata * coll
Definition: isom.h:232
int64_t * chunk_offsets
Definition: isom.h:164
MOVStsc * stsc_data
Definition: isom.h:173
AVStereo3D * stereo3d
Definition: isom.h:228
int32_t * display_matrix
Definition: isom.h:227
int current_sample
Definition: isom.h:192
unsigned int samples_per_frame
Definition: isom.h:197
int start_pad
amount of samples to skip due to enc-dec delay
Definition: isom.h:213
int nb_frames_for_fps
Definition: isom.h:217
uint32_t format
Definition: isom.h:235
int keyframe_absent
Definition: isom.h:186
MOVElst * elst_data
Definition: isom.h:178
int64_t current_index
Definition: isom.h:193
unsigned int stts_count
Definition: isom.h:165
uint8_t * sdtp_data
Definition: isom.h:168
unsigned int sample_size
may contain value calculated from stsd or value from stsz atom
Definition: isom.h:182
AVEncryptionInfo * default_encrypted_sample
Definition: isom.h:241
int timecode_track
Definition: isom.h:204
int16_t audio_cid
stsd audio compression id
Definition: isom.h:200
int ctts_sample
Definition: isom.h:181
struct AVAESCTR * aes_ctr
Definition: isom.h:239
MOVStts * stts_data
Definition: isom.h:166
int last_stsd_index
Definition: isom.h:223
int stsd_count
Definition: isom.h:224
unsigned int chunk_count
Definition: isom.h:163
int64_t data_size
Definition: isom.h:210
int pb_is_copied
Definition: isom.h:160
int * keyframes
Definition: isom.h:188
int has_sidx
Definition: isom.h:237
unsigned drefs_count
Definition: isom.h:201
MOVIndexRange * current_index_range
Definition: isom.h:195
AVMasteringDisplayMetadata * mastering
Definition: isom.h:231
int width
tkhd width
Definition: isom.h:205
unsigned int sdtp_count
Definition: isom.h:167
unsigned int sample_count
Definition: isom.h:184
int dts_shift
dts shift when ctts is negative
Definition: isom.h:207
int stsd_version
Definition: isom.h:225
int time_scale
Definition: isom.h:189
unsigned int stsc_index
Definition: isom.h:174
int64_t min_corrected_pts
minimum Composition time shown by the edits excluding empty edits.
Definition: isom.h:191
int has_palette
Definition: isom.h:209
int ctts_index
Definition: isom.h:180
uint32_t palette[256]
Definition: isom.h:208
int ffindex
AVStream index.
Definition: isom.h:161
int * sample_sizes
Definition: isom.h:185
AVSphericalMapping * spherical
Definition: isom.h:229
unsigned int keyframe_count
Definition: isom.h:187
unsigned int bytes_per_frame
Definition: isom.h:196
uint32_t tmcd_flags
tmcd track flags
Definition: isom.h:211
unsigned * stps_data
partial sync sample for mpeg-2 open gop
Definition: isom.h:177
MOVIndexRange * index_ranges
Definition: isom.h:194
unsigned int stsc_count
Definition: isom.h:172
unsigned int stsz_sample_size
always contains sample size from stsz atom
Definition: isom.h:183
unsigned int elst_count
Definition: isom.h:179
unsigned int ctts_count
Definition: isom.h:169
unsigned int stps_count
Definition: isom.h:176
int first
Definition: isom.h:62
int count
Definition: isom.h:63
int id
Definition: isom.h:64
Definition: isom.h:56
unsigned int count
Definition: isom.h:57
int duration
Definition: isom.h:58
unsigned flags
Definition: isom.h:106
unsigned duration
Definition: isom.h:104
unsigned size
Definition: isom.h:105
unsigned track_id
Definition: isom.h:102
unsigned stsd_id
Definition: isom.h:103
#define av_free(p)
#define av_malloc_array(a, b)
#define ff_dlog(a,...)
#define av_realloc_f(p, o, n)
#define avpriv_request_sample(...)
#define av_freep(p)
#define av_malloc(s)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
FILE * out
Definition: movenc.c:54
int64_t duration
Definition: movenc.c:64
AVPacket * pkt
Definition: movenc.c:59
AVFormatContext * ctx
Definition: movenc.c:48
static void finish(void)
Definition: movenc.c:342
#define height
#define width
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:102
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:219
Timecode helpers header.
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
@ AV_TIMECODE_FLAG_ALLOWNEGATIVE
negative time values are allowed
Definition: timecode.h:38
@ AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
Definition: timecode.h:36
@ AV_TIMECODE_FLAG_24HOURSMAX
timecode wraps after 24 hours
Definition: timecode.h:37
static int64_t pts
int size
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
#define mc
const char * b
Definition: vf_curves.c:118
const char * g
Definition: vf_curves.c:117
const char * r
Definition: vf_curves.c:116
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
if(ret< 0)
Definition: vf_mcdeint.c:282
static float mean(const float *input, int size)
Definition: vf_nnedi.c:864
color_range
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
static void rotate(const float rot_quaternion[2][4], float *vec)
Rotate vector with given rotation quaternion.
Definition: vf_v360.c:3919
int len
static int parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
Definition: vp3_parser.c:23
static double c[64]