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