FFmpeg
mov.c
Go to the documentation of this file.
1 /*
2  * MOV demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
5  *
6  * first version by Francois Revol <revol@free.fr>
7  * seek function by Gael Chardon <gael.dev@4now.net>
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include <inttypes.h>
27 #include <limits.h>
28 #include <stdint.h>
29 
30 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/intfloat.h"
35 #include "libavutil/mathematics.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/display.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/aes.h"
43 #include "libavutil/aes_ctr.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/sha.h"
46 #include "libavutil/spherical.h"
47 #include "libavutil/stereo3d.h"
48 #include "libavutil/timecode.h"
49 #include "libavutil/dovi_meta.h"
50 #include "libavcodec/ac3tab.h"
51 #include "libavcodec/flac.h"
53 #include "libavcodec/mlp_parse.h"
54 #include "avformat.h"
55 #include "internal.h"
56 #include "avio_internal.h"
57 #include "riff.h"
58 #include "isom.h"
59 #include "libavcodec/get_bits.h"
60 #include "id3v1.h"
61 #include "mov_chan.h"
62 #include "replaygain.h"
63 
64 #if CONFIG_ZLIB
65 #include <zlib.h>
66 #endif
67 
68 #include "qtpalette.h"
69 
70 /* those functions parse an atom */
71 /* links atom IDs to parse functions */
72 typedef struct MOVParseTableEntry {
73  uint32_t type;
76 
77 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
78 static int mov_read_mfra(MOVContext *c, AVIOContext *f);
79 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
80  int count, int duration);
81 
83  unsigned len, const char *key)
84 {
85  char buf[16];
86 
87  short current, total = 0;
88  avio_rb16(pb); // unknown
89  current = avio_rb16(pb);
90  if (len >= 6)
91  total = avio_rb16(pb);
92  if (!total)
93  snprintf(buf, sizeof(buf), "%d", current);
94  else
95  snprintf(buf, sizeof(buf), "%d/%d", current, total);
97  av_dict_set(&c->fc->metadata, key, buf, 0);
98 
99  return 0;
100 }
101 
103  unsigned len, const char *key)
104 {
105  /* bypass padding bytes */
106  avio_r8(pb);
107  avio_r8(pb);
108  avio_r8(pb);
109 
111  av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
112 
113  return 0;
114 }
115 
117  unsigned len, const char *key)
118 {
120  av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
121 
122  return 0;
123 }
124 
126  unsigned len, const char *key)
127 {
128  short genre;
129 
130  avio_r8(pb); // unknown
131 
132  genre = avio_r8(pb);
133  if (genre < 1 || genre > ID3v1_GENRE_MAX)
134  return 0;
136  av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
137 
138  return 0;
139 }
140 
141 static const uint32_t mac_to_unicode[128] = {
142  0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
143  0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
144  0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
145  0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
146  0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
147  0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
148  0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
149  0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
150  0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
151  0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
152  0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
153  0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
154  0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
155  0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
156  0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
157  0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
158 };
159 
161  char *dst, int dstlen)
162 {
163  char *p = dst;
164  char *end = dst+dstlen-1;
165  int i;
166 
167  for (i = 0; i < len; i++) {
168  uint8_t t, c = avio_r8(pb);
169 
170  if (p >= end)
171  continue;
172 
173  if (c < 0x80)
174  *p++ = c;
175  else if (p < end)
176  PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
177  }
178  *p = 0;
179  return p - dst;
180 }
181 
182 static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
183 {
184  AVStream *st;
185  MOVStreamContext *sc;
186  enum AVCodecID id;
187  int ret;
188 
189  switch (type) {
190  case 0xd: id = AV_CODEC_ID_MJPEG; break;
191  case 0xe: id = AV_CODEC_ID_PNG; break;
192  case 0x1b: id = AV_CODEC_ID_BMP; break;
193  default:
194  av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
195  avio_skip(pb, len);
196  return 0;
197  }
198 
199  st = avformat_new_stream(c->fc, NULL);
200  if (!st)
201  return AVERROR(ENOMEM);
202  sc = av_mallocz(sizeof(*sc));
203  if (!sc)
204  return AVERROR(ENOMEM);
205  st->priv_data = sc;
206 
207  ret = av_get_packet(pb, &st->attached_pic, len);
208  if (ret < 0)
209  return ret;
210 
211  if (st->attached_pic.size >= 8 && id != AV_CODEC_ID_BMP) {
212  if (AV_RB64(st->attached_pic.data) == 0x89504e470d0a1a0a) {
213  id = AV_CODEC_ID_PNG;
214  } else {
215  id = AV_CODEC_ID_MJPEG;
216  }
217  }
218 
220 
221  st->attached_pic.stream_index = st->index;
223 
225  st->codecpar->codec_id = id;
226 
227  return 0;
228 }
229 
230 // 3GPP TS 26.244
231 static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
232 {
233  char language[4] = { 0 };
234  char buf[200], place[100];
235  uint16_t langcode = 0;
236  double longitude, latitude, altitude;
237  const char *key = "location";
238 
239  if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4) {
240  av_log(c->fc, AV_LOG_ERROR, "loci too short\n");
241  return AVERROR_INVALIDDATA;
242  }
243 
244  avio_skip(pb, 4); // version+flags
245  langcode = avio_rb16(pb);
246  ff_mov_lang_to_iso639(langcode, language);
247  len -= 6;
248 
249  len -= avio_get_str(pb, len, place, sizeof(place));
250  if (len < 1) {
251  av_log(c->fc, AV_LOG_ERROR, "place name too long\n");
252  return AVERROR_INVALIDDATA;
253  }
254  avio_skip(pb, 1); // role
255  len -= 1;
256 
257  if (len < 12) {
258  av_log(c->fc, AV_LOG_ERROR,
259  "loci too short (%u bytes left, need at least %d)\n", len, 12);
260  return AVERROR_INVALIDDATA;
261  }
262  longitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
263  latitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
264  altitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
265 
266  // Try to output in the same format as the ?xyz field
267  snprintf(buf, sizeof(buf), "%+08.4f%+09.4f", latitude, longitude);
268  if (altitude)
269  av_strlcatf(buf, sizeof(buf), "%+f", altitude);
270  av_strlcatf(buf, sizeof(buf), "/%s", place);
271 
272  if (*language && strcmp(language, "und")) {
273  char key2[16];
274  snprintf(key2, sizeof(key2), "%s-%s", key, language);
275  av_dict_set(&c->fc->metadata, key2, buf, 0);
276  }
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[AV_FOURCC_MAX_STRING_SIZE] = {0};
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  key = av_fourcc_make_string(tmp_key, atom.type);
448  }
449 
450  if (!key)
451  return 0;
452  if (atom.size < 0 || str_size >= INT_MAX/2)
453  return AVERROR_INVALIDDATA;
454 
455  // Allocates enough space if data_type is a int32 or float32 number, otherwise
456  // worst-case requirement for output string in case of utf8 coded input
457  num = (data_type >= 21 && data_type <= 23);
458  str_size_alloc = (num ? 512 : (raw ? str_size : str_size * 2)) + 1;
459  str = av_mallocz(str_size_alloc);
460  if (!str)
461  return AVERROR(ENOMEM);
462 
463  if (parse)
464  parse(c, pb, str_size, key);
465  else {
466  if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
467  mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
468  } else if (data_type == 21) { // BE signed integer, variable size
469  int val = 0;
470  if (str_size == 1)
471  val = (int8_t)avio_r8(pb);
472  else if (str_size == 2)
473  val = (int16_t)avio_rb16(pb);
474  else if (str_size == 3)
475  val = ((int32_t)(avio_rb24(pb)<<8))>>8;
476  else if (str_size == 4)
477  val = (int32_t)avio_rb32(pb);
478  if (snprintf(str, str_size_alloc, "%d", val) >= str_size_alloc) {
479  av_log(c->fc, AV_LOG_ERROR,
480  "Failed to store the number (%d) in string.\n", val);
481  av_free(str);
482  return AVERROR_INVALIDDATA;
483  }
484  } else if (data_type == 22) { // BE unsigned integer, variable size
485  unsigned int val = 0;
486  if (str_size == 1)
487  val = avio_r8(pb);
488  else if (str_size == 2)
489  val = avio_rb16(pb);
490  else if (str_size == 3)
491  val = avio_rb24(pb);
492  else if (str_size == 4)
493  val = avio_rb32(pb);
494  if (snprintf(str, str_size_alloc, "%u", val) >= str_size_alloc) {
495  av_log(c->fc, AV_LOG_ERROR,
496  "Failed to store the number (%u) in string.\n", val);
497  av_free(str);
498  return AVERROR_INVALIDDATA;
499  }
500  } else if (data_type == 23 && str_size >= 4) { // BE float32
501  float val = av_int2float(avio_rb32(pb));
502  if (snprintf(str, str_size_alloc, "%f", val) >= str_size_alloc) {
503  av_log(c->fc, AV_LOG_ERROR,
504  "Failed to store the float32 number (%f) in string.\n", val);
505  av_free(str);
506  return AVERROR_INVALIDDATA;
507  }
508  } else {
509  int ret = ffio_read_size(pb, str, str_size);
510  if (ret < 0) {
511  av_free(str);
512  return ret;
513  }
514  str[str_size] = 0;
515  }
517  av_dict_set(&c->fc->metadata, key, str, 0);
518  if (*language && strcmp(language, "und")) {
519  snprintf(key2, sizeof(key2), "%s-%s", key, language);
520  av_dict_set(&c->fc->metadata, key2, str, 0);
521  }
522  if (!strcmp(key, "encoder")) {
523  int major, minor, micro;
524  if (sscanf(str, "HandBrake %d.%d.%d", &major, &minor, &micro) == 3) {
525  c->handbrake_version = 1000000*major + 1000*minor + micro;
526  }
527  }
528  }
529 
530  av_freep(&str);
531  return 0;
532 }
533 
535 {
536  int64_t start;
537  int i, nb_chapters, str_len, version;
538  char str[256+1];
539  int ret;
540 
541  if (c->ignore_chapters)
542  return 0;
543 
544  if ((atom.size -= 5) < 0)
545  return 0;
546 
547  version = avio_r8(pb);
548  avio_rb24(pb);
549  if (version)
550  avio_rb32(pb); // ???
551  nb_chapters = avio_r8(pb);
552 
553  for (i = 0; i < nb_chapters; i++) {
554  if (atom.size < 9)
555  return 0;
556 
557  start = avio_rb64(pb);
558  str_len = avio_r8(pb);
559 
560  if ((atom.size -= 9+str_len) < 0)
561  return 0;
562 
563  ret = ffio_read_size(pb, str, str_len);
564  if (ret < 0)
565  return ret;
566  str[str_len] = 0;
567  avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
568  }
569  return 0;
570 }
571 
572 #define MIN_DATA_ENTRY_BOX_SIZE 12
574 {
575  AVStream *st;
576  MOVStreamContext *sc;
577  int entries, i, j;
578 
579  if (c->fc->nb_streams < 1)
580  return 0;
581  st = c->fc->streams[c->fc->nb_streams-1];
582  sc = st->priv_data;
583 
584  avio_rb32(pb); // version + flags
585  entries = avio_rb32(pb);
586  if (!entries ||
587  entries > (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
588  entries >= UINT_MAX / sizeof(*sc->drefs))
589  return AVERROR_INVALIDDATA;
590 
591  av_free(sc->drefs);
592  sc->drefs_count = 0;
593  sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
594  if (!sc->drefs)
595  return AVERROR(ENOMEM);
596  sc->drefs_count = entries;
597 
598  for (i = 0; i < entries; i++) {
599  MOVDref *dref = &sc->drefs[i];
600  uint32_t size = avio_rb32(pb);
601  int64_t next = avio_tell(pb) + size - 4;
602 
603  if (size < 12)
604  return AVERROR_INVALIDDATA;
605 
606  dref->type = avio_rl32(pb);
607  avio_rb32(pb); // version + flags
608 
609  if (dref->type == MKTAG('a','l','i','s') && size > 150) {
610  /* macintosh alias record */
611  uint16_t volume_len, len;
612  int16_t type;
613  int ret;
614 
615  avio_skip(pb, 10);
616 
617  volume_len = avio_r8(pb);
618  volume_len = FFMIN(volume_len, 27);
619  ret = ffio_read_size(pb, dref->volume, 27);
620  if (ret < 0)
621  return ret;
622  dref->volume[volume_len] = 0;
623  av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
624 
625  avio_skip(pb, 12);
626 
627  len = avio_r8(pb);
628  len = FFMIN(len, 63);
629  ret = ffio_read_size(pb, dref->filename, 63);
630  if (ret < 0)
631  return ret;
632  dref->filename[len] = 0;
633  av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
634 
635  avio_skip(pb, 16);
636 
637  /* read next level up_from_alias/down_to_target */
638  dref->nlvl_from = avio_rb16(pb);
639  dref->nlvl_to = avio_rb16(pb);
640  av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
641  dref->nlvl_from, dref->nlvl_to);
642 
643  avio_skip(pb, 16);
644 
645  for (type = 0; type != -1 && avio_tell(pb) < next; ) {
646  if (avio_feof(pb))
647  return AVERROR_EOF;
648  type = avio_rb16(pb);
649  len = avio_rb16(pb);
650  av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
651  if (len&1)
652  len += 1;
653  if (type == 2) { // absolute path
654  av_free(dref->path);
655  dref->path = av_mallocz(len+1);
656  if (!dref->path)
657  return AVERROR(ENOMEM);
658 
659  ret = ffio_read_size(pb, dref->path, len);
660  if (ret < 0) {
661  av_freep(&dref->path);
662  return ret;
663  }
664  if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
665  len -= volume_len;
666  memmove(dref->path, dref->path+volume_len, len);
667  dref->path[len] = 0;
668  }
669  // trim string of any ending zeros
670  for (j = len - 1; j >= 0; j--) {
671  if (dref->path[j] == 0)
672  len--;
673  else
674  break;
675  }
676  for (j = 0; j < len; j++)
677  if (dref->path[j] == ':' || dref->path[j] == 0)
678  dref->path[j] = '/';
679  av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
680  } else if (type == 0) { // directory name
681  av_free(dref->dir);
682  dref->dir = av_malloc(len+1);
683  if (!dref->dir)
684  return AVERROR(ENOMEM);
685 
686  ret = ffio_read_size(pb, dref->dir, len);
687  if (ret < 0) {
688  av_freep(&dref->dir);
689  return ret;
690  }
691  dref->dir[len] = 0;
692  for (j = 0; j < len; j++)
693  if (dref->dir[j] == ':')
694  dref->dir[j] = '/';
695  av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
696  } else
697  avio_skip(pb, len);
698  }
699  } else {
700  av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x%08"PRIx32" size %"PRIu32"\n",
701  dref->type, size);
702  entries--;
703  i--;
704  }
705  avio_seek(pb, next, SEEK_SET);
706  }
707  return 0;
708 }
709 
711 {
712  AVStream *st;
713  uint32_t type;
714  uint32_t ctype;
715  int64_t title_size;
716  char *title_str;
717  int ret;
718 
719  avio_r8(pb); /* version */
720  avio_rb24(pb); /* flags */
721 
722  /* component type */
723  ctype = avio_rl32(pb);
724  type = avio_rl32(pb); /* component subtype */
725 
726  av_log(c->fc, AV_LOG_TRACE, "ctype=%s\n", av_fourcc2str(ctype));
727  av_log(c->fc, AV_LOG_TRACE, "stype=%s\n", av_fourcc2str(type));
728 
729  if (c->trak_index < 0) { // meta not inside a trak
730  if (type == MKTAG('m','d','t','a')) {
731  c->found_hdlr_mdta = 1;
732  }
733  return 0;
734  }
735 
736  st = c->fc->streams[c->fc->nb_streams-1];
737 
738  if (type == MKTAG('v','i','d','e'))
740  else if (type == MKTAG('s','o','u','n'))
742  else if (type == MKTAG('m','1','a',' '))
744  else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
746 
747  avio_rb32(pb); /* component manufacture */
748  avio_rb32(pb); /* component flags */
749  avio_rb32(pb); /* component flags mask */
750 
751  title_size = atom.size - 24;
752  if (title_size > 0) {
753  if (title_size > FFMIN(INT_MAX, SIZE_MAX-1))
754  return AVERROR_INVALIDDATA;
755  title_str = av_malloc(title_size + 1); /* Add null terminator */
756  if (!title_str)
757  return AVERROR(ENOMEM);
758 
759  ret = ffio_read_size(pb, title_str, title_size);
760  if (ret < 0) {
761  av_freep(&title_str);
762  return ret;
763  }
764  title_str[title_size] = 0;
765  if (title_str[0]) {
766  int off = (!c->isom && title_str[0] == title_size - 1);
767  // flag added so as to not set stream handler name if already set from mdia->hdlr
768  av_dict_set(&st->metadata, "handler_name", title_str + off, AV_DICT_DONT_OVERWRITE);
769  }
770  av_freep(&title_str);
771  }
772 
773  return 0;
774 }
775 
777 {
778  return ff_mov_read_esds(c->fc, pb);
779 }
780 
782 {
783  AVStream *st;
784  enum AVAudioServiceType *ast;
785  int ac3info, acmod, lfeon, bsmod;
786 
787  if (c->fc->nb_streams < 1)
788  return 0;
789  st = c->fc->streams[c->fc->nb_streams-1];
790 
792  sizeof(*ast));
793  if (!ast)
794  return AVERROR(ENOMEM);
795 
796  ac3info = avio_rb24(pb);
797  bsmod = (ac3info >> 14) & 0x7;
798  acmod = (ac3info >> 11) & 0x7;
799  lfeon = (ac3info >> 10) & 0x1;
800  st->codecpar->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
802  if (lfeon)
804  *ast = bsmod;
805  if (st->codecpar->channels > 1 && bsmod == 0x7)
807 
808 #if FF_API_LAVF_AVCTX
810  st->codec->audio_service_type = *ast;
812 #endif
813 
814  return 0;
815 }
816 
818 {
819  AVStream *st;
820  enum AVAudioServiceType *ast;
821  int eac3info, acmod, lfeon, bsmod;
822 
823  if (c->fc->nb_streams < 1)
824  return 0;
825  st = c->fc->streams[c->fc->nb_streams-1];
826 
828  sizeof(*ast));
829  if (!ast)
830  return AVERROR(ENOMEM);
831 
832  /* No need to parse fields for additional independent substreams and its
833  * associated dependent substreams since libavcodec's E-AC-3 decoder
834  * does not support them yet. */
835  avio_rb16(pb); /* data_rate and num_ind_sub */
836  eac3info = avio_rb24(pb);
837  bsmod = (eac3info >> 12) & 0x1f;
838  acmod = (eac3info >> 9) & 0x7;
839  lfeon = (eac3info >> 8) & 0x1;
841  if (lfeon)
844  *ast = bsmod;
845  if (st->codecpar->channels > 1 && bsmod == 0x7)
847 
848 #if FF_API_LAVF_AVCTX
850  st->codec->audio_service_type = *ast;
852 #endif
853 
854  return 0;
855 }
856 
858 {
859 #define DDTS_SIZE 20
861  AVStream *st = NULL;
862  uint32_t frame_duration_code = 0;
863  uint32_t channel_layout_code = 0;
864  GetBitContext gb;
865  int ret;
866 
867  if ((ret = ffio_read_size(pb, buf, DDTS_SIZE)) < 0)
868  return ret;
869 
870  init_get_bits(&gb, buf, 8 * DDTS_SIZE);
871 
872  if (c->fc->nb_streams < 1) {
873  return 0;
874  }
875  st = c->fc->streams[c->fc->nb_streams-1];
876 
877  st->codecpar->sample_rate = get_bits_long(&gb, 32);
878  if (st->codecpar->sample_rate <= 0) {
879  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
880  return AVERROR_INVALIDDATA;
881  }
882  skip_bits_long(&gb, 32); /* max bitrate */
883  st->codecpar->bit_rate = get_bits_long(&gb, 32);
884  st->codecpar->bits_per_coded_sample = get_bits(&gb, 8);
885  frame_duration_code = get_bits(&gb, 2);
886  skip_bits(&gb, 30); /* various fields */
887  channel_layout_code = get_bits(&gb, 16);
888 
889  st->codecpar->frame_size =
890  (frame_duration_code == 0) ? 512 :
891  (frame_duration_code == 1) ? 1024 :
892  (frame_duration_code == 2) ? 2048 :
893  (frame_duration_code == 3) ? 4096 : 0;
894 
895  if (channel_layout_code > 0xff) {
896  av_log(c->fc, AV_LOG_WARNING, "Unsupported DTS audio channel layout\n");
897  }
898  st->codecpar->channel_layout =
899  ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
900  ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
901  ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
902  ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
903  ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
904  ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0);
905 
907 
908  return 0;
909 }
910 
912 {
913  AVStream *st;
914 
915  if (c->fc->nb_streams < 1)
916  return 0;
917  st = c->fc->streams[c->fc->nb_streams-1];
918 
919  if (atom.size < 16)
920  return 0;
921 
922  /* skip version and flags */
923  avio_skip(pb, 4);
924 
925  ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
926 
927  return 0;
928 }
929 
931 {
932  AVStream *st;
933  int ret;
934 
935  if (c->fc->nb_streams < 1)
936  return 0;
937  st = c->fc->streams[c->fc->nb_streams-1];
938 
939  if ((ret = ff_get_wav_header(c->fc, pb, st->codecpar, atom.size, 0)) < 0)
940  av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
941 
942  return ret;
943 }
944 
946 {
947  const int num = avio_rb32(pb);
948  const int den = avio_rb32(pb);
949  AVStream *st;
950 
951  if (c->fc->nb_streams < 1)
952  return 0;
953  st = c->fc->streams[c->fc->nb_streams-1];
954 
955  if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
956  (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
958  "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
960  num, den);
961  } else if (den != 0) {
963  num, den, 32767);
964  }
965  return 0;
966 }
967 
968 /* this atom contains actual media data */
970 {
971  if (atom.size == 0) /* wrong one (MP4) */
972  return 0;
973  c->found_mdat=1;
974  return 0; /* now go for moov */
975 }
976 
977 #define DRM_BLOB_SIZE 56
978 
980 {
981  uint8_t intermediate_key[20];
982  uint8_t intermediate_iv[20];
983  uint8_t input[64];
984  uint8_t output[64];
985  uint8_t file_checksum[20];
986  uint8_t calculated_checksum[20];
987  struct AVSHA *sha;
988  int i;
989  int ret = 0;
990  uint8_t *activation_bytes = c->activation_bytes;
991  uint8_t *fixed_key = c->audible_fixed_key;
992 
993  c->aax_mode = 1;
994 
995  sha = av_sha_alloc();
996  if (!sha)
997  return AVERROR(ENOMEM);
998  av_free(c->aes_decrypt);
999  c->aes_decrypt = av_aes_alloc();
1000  if (!c->aes_decrypt) {
1001  ret = AVERROR(ENOMEM);
1002  goto fail;
1003  }
1004 
1005  /* drm blob processing */
1006  avio_read(pb, output, 8); // go to offset 8, absolute position 0x251
1007  avio_read(pb, input, DRM_BLOB_SIZE);
1008  avio_read(pb, output, 4); // go to offset 4, absolute position 0x28d
1009  avio_read(pb, file_checksum, 20);
1010 
1011  av_log(c->fc, AV_LOG_INFO, "[aax] file checksum == "); // required by external tools
1012  for (i = 0; i < 20; i++)
1013  av_log(c->fc, AV_LOG_INFO, "%02x", file_checksum[i]);
1014  av_log(c->fc, AV_LOG_INFO, "\n");
1015 
1016  /* verify activation data */
1017  if (!activation_bytes) {
1018  av_log(c->fc, AV_LOG_WARNING, "[aax] activation_bytes option is missing!\n");
1019  ret = 0; /* allow ffprobe to continue working on .aax files */
1020  goto fail;
1021  }
1022  if (c->activation_bytes_size != 4) {
1023  av_log(c->fc, AV_LOG_FATAL, "[aax] activation_bytes value needs to be 4 bytes!\n");
1024  ret = AVERROR(EINVAL);
1025  goto fail;
1026  }
1027 
1028  /* verify fixed key */
1029  if (c->audible_fixed_key_size != 16) {
1030  av_log(c->fc, AV_LOG_FATAL, "[aax] audible_fixed_key value needs to be 16 bytes!\n");
1031  ret = AVERROR(EINVAL);
1032  goto fail;
1033  }
1034 
1035  /* AAX (and AAX+) key derivation */
1036  av_sha_init(sha, 160);
1037  av_sha_update(sha, fixed_key, 16);
1038  av_sha_update(sha, activation_bytes, 4);
1039  av_sha_final(sha, intermediate_key);
1040  av_sha_init(sha, 160);
1041  av_sha_update(sha, fixed_key, 16);
1042  av_sha_update(sha, intermediate_key, 20);
1043  av_sha_update(sha, activation_bytes, 4);
1044  av_sha_final(sha, intermediate_iv);
1045  av_sha_init(sha, 160);
1046  av_sha_update(sha, intermediate_key, 16);
1047  av_sha_update(sha, intermediate_iv, 16);
1048  av_sha_final(sha, calculated_checksum);
1049  if (memcmp(calculated_checksum, file_checksum, 20)) { // critical error
1050  av_log(c->fc, AV_LOG_ERROR, "[aax] mismatch in checksums!\n");
1051  ret = AVERROR_INVALIDDATA;
1052  goto fail;
1053  }
1054  av_aes_init(c->aes_decrypt, intermediate_key, 128, 1);
1055  av_aes_crypt(c->aes_decrypt, output, input, DRM_BLOB_SIZE >> 4, intermediate_iv, 1);
1056  for (i = 0; i < 4; i++) {
1057  // file data (in output) is stored in big-endian mode
1058  if (activation_bytes[i] != output[3 - i]) { // critical error
1059  av_log(c->fc, AV_LOG_ERROR, "[aax] error in drm blob decryption!\n");
1060  ret = AVERROR_INVALIDDATA;
1061  goto fail;
1062  }
1063  }
1064  memcpy(c->file_key, output + 8, 16);
1065  memcpy(input, output + 26, 16);
1066  av_sha_init(sha, 160);
1067  av_sha_update(sha, input, 16);
1068  av_sha_update(sha, c->file_key, 16);
1069  av_sha_update(sha, fixed_key, 16);
1070  av_sha_final(sha, c->file_iv);
1071 
1072 fail:
1073  av_free(sha);
1074 
1075  return ret;
1076 }
1077 
1078 // Audible AAX (and AAX+) bytestream decryption
1080 {
1081  int blocks = 0;
1082  unsigned char iv[16];
1083 
1084  memcpy(iv, c->file_iv, 16); // iv is overwritten
1085  blocks = size >> 4; // trailing bytes are not encrypted!
1086  av_aes_init(c->aes_decrypt, c->file_key, 128, 1);
1087  av_aes_crypt(c->aes_decrypt, input, input, blocks, iv, 1);
1088 
1089  return 0;
1090 }
1091 
1092 /* read major brand, minor version and compatible brands and store them as metadata */
1094 {
1095  uint32_t minor_ver;
1096  int comp_brand_size;
1097  char* comp_brands_str;
1098  uint8_t type[5] = {0};
1099  int ret = ffio_read_size(pb, type, 4);
1100  if (ret < 0)
1101  return ret;
1102 
1103  if (strcmp(type, "qt "))
1104  c->isom = 1;
1105  av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
1106  av_dict_set(&c->fc->metadata, "major_brand", type, 0);
1107  minor_ver = avio_rb32(pb); /* minor version */
1108  av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
1109 
1110  comp_brand_size = atom.size - 8;
1111  if (comp_brand_size < 0 || comp_brand_size == INT_MAX)
1112  return AVERROR_INVALIDDATA;
1113  comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
1114  if (!comp_brands_str)
1115  return AVERROR(ENOMEM);
1116 
1117  ret = ffio_read_size(pb, comp_brands_str, comp_brand_size);
1118  if (ret < 0) {
1119  av_freep(&comp_brands_str);
1120  return ret;
1121  }
1122  comp_brands_str[comp_brand_size] = 0;
1123  av_dict_set(&c->fc->metadata, "compatible_brands",
1124  comp_brands_str, AV_DICT_DONT_STRDUP_VAL);
1125 
1126  return 0;
1127 }
1128 
1129 /* this atom should contain all header atoms */
1131 {
1132  int ret;
1133 
1134  if (c->found_moov) {
1135  av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
1136  avio_skip(pb, atom.size);
1137  return 0;
1138  }
1139 
1140  if ((ret = mov_read_default(c, pb, atom)) < 0)
1141  return ret;
1142  /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
1143  /* so we don't parse the whole file if over a network */
1144  c->found_moov=1;
1145  return 0; /* now go for mdat */
1146 }
1147 
1149  MOVFragmentIndex *frag_index,
1150  int index,
1151  int id)
1152 {
1153  int i;
1154  MOVFragmentIndexItem * item;
1155 
1156  if (index < 0 || index >= frag_index->nb_items)
1157  return NULL;
1158  item = &frag_index->item[index];
1159  for (i = 0; i < item->nb_stream_info; i++)
1160  if (item->stream_info[i].id == id)
1161  return &item->stream_info[i];
1162 
1163  // This shouldn't happen
1164  return NULL;
1165 }
1166 
1167 static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
1168 {
1169  int i;
1170  MOVFragmentIndexItem * item;
1171 
1172  if (frag_index->current < 0 ||
1173  frag_index->current >= frag_index->nb_items)
1174  return;
1175 
1176  item = &frag_index->item[frag_index->current];
1177  for (i = 0; i < item->nb_stream_info; i++)
1178  if (item->stream_info[i].id == id) {
1179  item->current = i;
1180  return;
1181  }
1182 
1183  // id not found. This shouldn't happen.
1184  item->current = -1;
1185 }
1186 
1188  MOVFragmentIndex *frag_index)
1189 {
1190  MOVFragmentIndexItem *item;
1191  if (frag_index->current < 0 ||
1192  frag_index->current >= frag_index->nb_items)
1193  return NULL;
1194 
1195  item = &frag_index->item[frag_index->current];
1196  if (item->current >= 0 && item->current < item->nb_stream_info)
1197  return &item->stream_info[item->current];
1198 
1199  // This shouldn't happen
1200  return NULL;
1201 }
1202 
1203 static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
1204 {
1205  int a, b, m;
1206  int64_t moof_offset;
1207 
1208  // Optimize for appending new entries
1209  if (!frag_index->nb_items ||
1210  frag_index->item[frag_index->nb_items - 1].moof_offset < offset)
1211  return frag_index->nb_items;
1212 
1213  a = -1;
1214  b = frag_index->nb_items;
1215 
1216  while (b - a > 1) {
1217  m = (a + b) >> 1;
1218  moof_offset = frag_index->item[m].moof_offset;
1219  if (moof_offset >= offset)
1220  b = m;
1221  if (moof_offset <= offset)
1222  a = m;
1223  }
1224  return b;
1225 }
1226 
1227 static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
1228 {
1229  av_assert0(frag_stream_info);
1230  if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1231  return frag_stream_info->sidx_pts;
1232  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1233  return frag_stream_info->first_tfra_pts;
1234  return frag_stream_info->tfdt_dts;
1235 }
1236 
1237 static int64_t get_frag_time(MOVFragmentIndex *frag_index,
1238  int index, int track_id)
1239 {
1240  MOVFragmentStreamInfo * frag_stream_info;
1241  int64_t timestamp;
1242  int i;
1243 
1244  if (track_id >= 0) {
1245  frag_stream_info = get_frag_stream_info(frag_index, index, track_id);
1246  return frag_stream_info->sidx_pts;
1247  }
1248 
1249  for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
1250  frag_stream_info = &frag_index->item[index].stream_info[i];
1251  timestamp = get_stream_info_time(frag_stream_info);
1252  if (timestamp != AV_NOPTS_VALUE)
1253  return timestamp;
1254  }
1255  return AV_NOPTS_VALUE;
1256 }
1257 
1259  AVStream *st, int64_t timestamp)
1260 {
1261  int a, b, m, m0;
1262  int64_t frag_time;
1263  int id = -1;
1264 
1265  if (st) {
1266  // If the stream is referenced by any sidx, limit the search
1267  // to fragments that referenced this stream in the sidx
1268  MOVStreamContext *sc = st->priv_data;
1269  if (sc->has_sidx)
1270  id = st->id;
1271  }
1272 
1273  a = -1;
1274  b = frag_index->nb_items;
1275 
1276  while (b - a > 1) {
1277  m0 = m = (a + b) >> 1;
1278 
1279  while (m < b &&
1280  (frag_time = get_frag_time(frag_index, m, id)) == AV_NOPTS_VALUE)
1281  m++;
1282 
1283  if (m < b && frag_time <= timestamp)
1284  a = m;
1285  else
1286  b = m0;
1287  }
1288 
1289  return a;
1290 }
1291 
1292 static int update_frag_index(MOVContext *c, int64_t offset)
1293 {
1294  int index, i;
1295  MOVFragmentIndexItem * item;
1296  MOVFragmentStreamInfo * frag_stream_info;
1297 
1298  // If moof_offset already exists in frag_index, return index to it
1299  index = search_frag_moof_offset(&c->frag_index, offset);
1300  if (index < c->frag_index.nb_items &&
1301  c->frag_index.item[index].moof_offset == offset)
1302  return index;
1303 
1304  // offset is not yet in frag index.
1305  // Insert new item at index (sorted by moof offset)
1306  item = av_fast_realloc(c->frag_index.item,
1308  (c->frag_index.nb_items + 1) *
1309  sizeof(*c->frag_index.item));
1310  if (!item)
1311  return -1;
1312  c->frag_index.item = item;
1313 
1314  frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
1315  sizeof(*item->stream_info));
1316  if (!frag_stream_info)
1317  return -1;
1318 
1319  for (i = 0; i < c->fc->nb_streams; i++) {
1320  // Avoid building frag index if streams lack track id.
1321  if (c->fc->streams[i]->id < 0) {
1322  av_free(frag_stream_info);
1323  return AVERROR_INVALIDDATA;
1324  }
1325 
1326  frag_stream_info[i].id = c->fc->streams[i]->id;
1327  frag_stream_info[i].sidx_pts = AV_NOPTS_VALUE;
1328  frag_stream_info[i].tfdt_dts = AV_NOPTS_VALUE;
1329  frag_stream_info[i].next_trun_dts = AV_NOPTS_VALUE;
1330  frag_stream_info[i].first_tfra_pts = AV_NOPTS_VALUE;
1331  frag_stream_info[i].index_entry = -1;
1332  frag_stream_info[i].encryption_index = NULL;
1333  }
1334 
1335  if (index < c->frag_index.nb_items)
1336  memmove(c->frag_index.item + index + 1, c->frag_index.item + index,
1337  (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
1338 
1339  item = &c->frag_index.item[index];
1340  item->headers_read = 0;
1341  item->current = 0;
1342  item->nb_stream_info = c->fc->nb_streams;
1343  item->moof_offset = offset;
1344  item->stream_info = frag_stream_info;
1345  c->frag_index.nb_items++;
1346 
1347  return index;
1348 }
1349 
1350 static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
1351  int id, int entries)
1352 {
1353  int i;
1354  MOVFragmentStreamInfo * frag_stream_info;
1355 
1356  if (index < 0)
1357  return;
1358  for (i = index; i < frag_index->nb_items; i++) {
1359  frag_stream_info = get_frag_stream_info(frag_index, i, id);
1360  if (frag_stream_info && frag_stream_info->index_entry >= 0)
1361  frag_stream_info->index_entry += entries;
1362  }
1363 }
1364 
1366 {
1367  // Set by mov_read_tfhd(). mov_read_trun() will reject files missing tfhd.
1368  c->fragment.found_tfhd = 0;
1369 
1370  if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
1371  c->has_looked_for_mfra = 1;
1372  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1373  int ret;
1374  av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
1375  "for a mfra\n");
1376  if ((ret = mov_read_mfra(c, pb)) < 0) {
1377  av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
1378  "read the mfra (may be a live ismv)\n");
1379  }
1380  } else {
1381  av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
1382  "seekable, can not look for mfra\n");
1383  }
1384  }
1386  av_log(c->fc, AV_LOG_TRACE, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
1388  return mov_read_default(c, pb, atom);
1389 }
1390 
1391 static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time, void *logctx)
1392 {
1393  if (time) {
1394  if (time >= 2082844800)
1395  time -= 2082844800; /* seconds between 1904-01-01 and Epoch */
1396 
1397  if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
1398  av_log(logctx, AV_LOG_DEBUG, "creation_time is not representable\n");
1399  return;
1400  }
1401 
1402  avpriv_dict_set_timestamp(metadata, "creation_time", time * 1000000);
1403  }
1404 }
1405 
1407 {
1408  AVStream *st;
1409  MOVStreamContext *sc;
1410  int version;
1411  char language[4] = {0};
1412  unsigned lang;
1413  int64_t creation_time;
1414 
1415  if (c->fc->nb_streams < 1)
1416  return 0;
1417  st = c->fc->streams[c->fc->nb_streams-1];
1418  sc = st->priv_data;
1419 
1420  if (sc->time_scale) {
1421  av_log(c->fc, AV_LOG_ERROR, "Multiple mdhd?\n");
1422  return AVERROR_INVALIDDATA;
1423  }
1424 
1425  version = avio_r8(pb);
1426  if (version > 1) {
1427  avpriv_request_sample(c->fc, "Version %d", version);
1428  return AVERROR_PATCHWELCOME;
1429  }
1430  avio_rb24(pb); /* flags */
1431  if (version == 1) {
1432  creation_time = avio_rb64(pb);
1433  avio_rb64(pb);
1434  } else {
1435  creation_time = avio_rb32(pb);
1436  avio_rb32(pb); /* modification time */
1437  }
1438  mov_metadata_creation_time(&st->metadata, creation_time, c->fc);
1439 
1440  sc->time_scale = avio_rb32(pb);
1441  if (sc->time_scale <= 0) {
1442  av_log(c->fc, AV_LOG_ERROR, "Invalid mdhd time scale %d, defaulting to 1\n", sc->time_scale);
1443  sc->time_scale = 1;
1444  }
1445  st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1446 
1447  lang = avio_rb16(pb); /* language */
1448  if (ff_mov_lang_to_iso639(lang, language))
1449  av_dict_set(&st->metadata, "language", language, 0);
1450  avio_rb16(pb); /* quality */
1451 
1452  return 0;
1453 }
1454 
1456 {
1457  int i;
1458  int64_t creation_time;
1459  int version = avio_r8(pb); /* version */
1460  avio_rb24(pb); /* flags */
1461 
1462  if (version == 1) {
1463  creation_time = avio_rb64(pb);
1464  avio_rb64(pb);
1465  } else {
1466  creation_time = avio_rb32(pb);
1467  avio_rb32(pb); /* modification time */
1468  }
1469  mov_metadata_creation_time(&c->fc->metadata, creation_time, c->fc);
1470  c->time_scale = avio_rb32(pb); /* time scale */
1471  if (c->time_scale <= 0) {
1472  av_log(c->fc, AV_LOG_ERROR, "Invalid mvhd time scale %d, defaulting to 1\n", c->time_scale);
1473  c->time_scale = 1;
1474  }
1475  av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale);
1476 
1477  c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1478  // set the AVFormatContext duration because the duration of individual tracks
1479  // may be inaccurate
1480  if (c->time_scale > 0 && !c->trex_data)
1482  avio_rb32(pb); /* preferred scale */
1483 
1484  avio_rb16(pb); /* preferred volume */
1485 
1486  avio_skip(pb, 10); /* reserved */
1487 
1488  /* movie display matrix, store it in main context and use it later on */
1489  for (i = 0; i < 3; i++) {
1490  c->movie_display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
1491  c->movie_display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
1492  c->movie_display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
1493  }
1494 
1495  avio_rb32(pb); /* preview time */
1496  avio_rb32(pb); /* preview duration */
1497  avio_rb32(pb); /* poster time */
1498  avio_rb32(pb); /* selection time */
1499  avio_rb32(pb); /* selection duration */
1500  avio_rb32(pb); /* current time */
1501  avio_rb32(pb); /* next track ID */
1502 
1503  return 0;
1504 }
1505 
1507 {
1508  AVStream *st;
1509  int little_endian;
1510 
1511  if (c->fc->nb_streams < 1)
1512  return 0;
1513  st = c->fc->streams[c->fc->nb_streams-1];
1514 
1515  little_endian = avio_rb16(pb) & 0xFF;
1516  av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian);
1517  if (little_endian == 1) {
1518  switch (st->codecpar->codec_id) {
1519  case AV_CODEC_ID_PCM_S24BE:
1521  break;
1522  case AV_CODEC_ID_PCM_S32BE:
1524  break;
1525  case AV_CODEC_ID_PCM_F32BE:
1527  break;
1528  case AV_CODEC_ID_PCM_F64BE:
1530  break;
1531  default:
1532  break;
1533  }
1534  }
1535  return 0;
1536 }
1537 
1539 {
1540  AVStream *st;
1541  uint8_t *icc_profile;
1542  char color_parameter_type[5] = { 0 };
1543  uint16_t color_primaries, color_trc, color_matrix;
1544  int ret;
1545 
1546  if (c->fc->nb_streams < 1)
1547  return 0;
1548  st = c->fc->streams[c->fc->nb_streams - 1];
1549 
1550  ret = ffio_read_size(pb, color_parameter_type, 4);
1551  if (ret < 0)
1552  return ret;
1553  if (strncmp(color_parameter_type, "nclx", 4) &&
1554  strncmp(color_parameter_type, "nclc", 4) &&
1555  strncmp(color_parameter_type, "prof", 4)) {
1556  av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
1557  color_parameter_type);
1558  return 0;
1559  }
1560 
1561  if (!strncmp(color_parameter_type, "prof", 4)) {
1562  icc_profile = av_stream_new_side_data(st, AV_PKT_DATA_ICC_PROFILE, atom.size - 4);
1563  if (!icc_profile)
1564  return AVERROR(ENOMEM);
1565  ret = ffio_read_size(pb, icc_profile, atom.size - 4);
1566  if (ret < 0)
1567  return ret;
1568  } else {
1569  color_primaries = avio_rb16(pb);
1570  color_trc = avio_rb16(pb);
1571  color_matrix = avio_rb16(pb);
1572 
1573  av_log(c->fc, AV_LOG_TRACE,
1574  "%s: pri %d trc %d matrix %d",
1575  color_parameter_type, color_primaries, color_trc, color_matrix);
1576 
1577  if (!strncmp(color_parameter_type, "nclx", 4)) {
1578  uint8_t color_range = avio_r8(pb) >> 7;
1579  av_log(c->fc, AV_LOG_TRACE, " full %"PRIu8"", color_range);
1580  if (color_range)
1582  else
1584  }
1585 
1586  if (!av_color_primaries_name(color_primaries))
1587  color_primaries = AVCOL_PRI_UNSPECIFIED;
1588  if (!av_color_transfer_name(color_trc))
1589  color_trc = AVCOL_TRC_UNSPECIFIED;
1590  if (!av_color_space_name(color_matrix))
1591  color_matrix = AVCOL_SPC_UNSPECIFIED;
1592 
1594  st->codecpar->color_trc = color_trc;
1595  st->codecpar->color_space = color_matrix;
1596  av_log(c->fc, AV_LOG_TRACE, "\n");
1597  }
1598  return 0;
1599 }
1600 
1602 {
1603  AVStream *st;
1604  unsigned mov_field_order;
1605  enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
1606 
1607  if (c->fc->nb_streams < 1) // will happen with jp2 files
1608  return 0;
1609  st = c->fc->streams[c->fc->nb_streams-1];
1610  if (atom.size < 2)
1611  return AVERROR_INVALIDDATA;
1612  mov_field_order = avio_rb16(pb);
1613  if ((mov_field_order & 0xFF00) == 0x0100)
1614  decoded_field_order = AV_FIELD_PROGRESSIVE;
1615  else if ((mov_field_order & 0xFF00) == 0x0200) {
1616  switch (mov_field_order & 0xFF) {
1617  case 0x01: decoded_field_order = AV_FIELD_TT;
1618  break;
1619  case 0x06: decoded_field_order = AV_FIELD_BB;
1620  break;
1621  case 0x09: decoded_field_order = AV_FIELD_TB;
1622  break;
1623  case 0x0E: decoded_field_order = AV_FIELD_BT;
1624  break;
1625  }
1626  }
1627  if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
1628  av_log(c->fc, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
1629  }
1630  st->codecpar->field_order = decoded_field_order;
1631 
1632  return 0;
1633 }
1634 
1636 {
1637  int err = 0;
1638  uint64_t size = (uint64_t)par->extradata_size + atom.size + 8 + AV_INPUT_BUFFER_PADDING_SIZE;
1639  if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
1640  return AVERROR_INVALIDDATA;
1641  if ((err = av_reallocp(&par->extradata, size)) < 0) {
1642  par->extradata_size = 0;
1643  return err;
1644  }
1646  return 0;
1647 }
1648 
1649 /* Read a whole atom into the extradata return the size of the atom read, possibly truncated if != atom.size */
1651  AVCodecParameters *par, uint8_t *buf)
1652 {
1653  int64_t result = atom.size;
1654  int err;
1655 
1656  AV_WB32(buf , atom.size + 8);
1657  AV_WL32(buf + 4, atom.type);
1658  err = ffio_read_size(pb, buf + 8, atom.size);
1659  if (err < 0) {
1660  par->extradata_size -= atom.size;
1661  return err;
1662  } else if (err < atom.size) {
1663  av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
1664  par->extradata_size -= atom.size - err;
1665  result = err;
1666  }
1667  memset(buf + 8 + err, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1668  return result;
1669 }
1670 
1671 /* FIXME modify QDM2/SVQ3/H.264 decoders to take full atom as extradata */
1673  enum AVCodecID codec_id)
1674 {
1675  AVStream *st;
1676  uint64_t original_size;
1677  int err;
1678 
1679  if (c->fc->nb_streams < 1) // will happen with jp2 files
1680  return 0;
1681  st = c->fc->streams[c->fc->nb_streams-1];
1682 
1683  if (st->codecpar->codec_id != codec_id)
1684  return 0; /* unexpected codec_id - don't mess with extradata */
1685 
1686  original_size = st->codecpar->extradata_size;
1687  err = mov_realloc_extradata(st->codecpar, atom);
1688  if (err)
1689  return err;
1690 
1691  err = mov_read_atom_into_extradata(c, pb, atom, st->codecpar, st->codecpar->extradata + original_size);
1692  if (err < 0)
1693  return err;
1694  return 0; // Note: this is the original behavior to ignore truncation.
1695 }
1696 
1697 /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
1699 {
1700  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
1701 }
1702 
1704 {
1705  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
1706 }
1707 
1709 {
1710  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
1711 }
1712 
1714 {
1715  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
1716 }
1717 
1719 {
1720  int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
1721  if (!ret)
1722  ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_DNXHD);
1723  return ret;
1724 }
1725 
1727 {
1728  int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
1729 
1730  if (!ret && c->fc->nb_streams >= 1) {
1731  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1732  if (par->extradata_size >= 40) {
1733  par->height = AV_RB16(&par->extradata[36]);
1734  par->width = AV_RB16(&par->extradata[38]);
1735  }
1736  }
1737  return ret;
1738 }
1739 
1741 {
1742  if (c->fc->nb_streams >= 1) {
1743  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1744  if (par->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
1745  par->codec_id == AV_CODEC_ID_H264 &&
1746  atom.size > 11) {
1747  int cid;
1748  avio_skip(pb, 10);
1749  cid = avio_rb16(pb);
1750  /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
1751  if (cid == 0xd4d || cid == 0xd4e)
1752  par->width = 1440;
1753  return 0;
1754  } else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
1755  par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
1756  par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
1757  atom.size >= 24) {
1758  int num, den;
1759  avio_skip(pb, 12);
1760  num = avio_rb32(pb);
1761  den = avio_rb32(pb);
1762  if (num <= 0 || den <= 0)
1763  return 0;
1764  switch (avio_rb32(pb)) {
1765  case 2:
1766  if (den >= INT_MAX / 2)
1767  return 0;
1768  den *= 2;
1769  case 1:
1770  c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.num = num;
1771  c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.den = den;
1772  default:
1773  return 0;
1774  }
1775  }
1776  }
1777 
1778  return mov_read_avid(c, pb, atom);
1779 }
1780 
1782 {
1783  int ret = 0;
1784  int length = 0;
1785  uint64_t original_size;
1786  if (c->fc->nb_streams >= 1) {
1787  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1788  if (par->codec_id == AV_CODEC_ID_H264)
1789  return 0;
1790  if (atom.size == 16) {
1791  original_size = par->extradata_size;
1792  ret = mov_realloc_extradata(par, atom);
1793  if (!ret) {
1794  length = mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
1795  if (length == atom.size) {
1796  const uint8_t range_value = par->extradata[original_size + 19];
1797  switch (range_value) {
1798  case 1:
1800  break;
1801  case 2:
1803  break;
1804  default:
1805  av_log(c->fc, AV_LOG_WARNING, "ignored unknown aclr value (%d)\n", range_value);
1806  break;
1807  }
1808  ff_dlog(c->fc, "color_range: %d\n", par->color_range);
1809  } else {
1810  /* For some reason the whole atom was not added to the extradata */
1811  av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
1812  }
1813  } else {
1814  av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - unable to add atom to extradata\n");
1815  }
1816  } else {
1817  av_log(c->fc, AV_LOG_WARNING, "aclr not decoded - unexpected size %"PRId64"\n", atom.size);
1818  }
1819  }
1820 
1821  return ret;
1822 }
1823 
1825 {
1826  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
1827 }
1828 
1830 {
1831  AVStream *st;
1832  int ret;
1833 
1834  if (c->fc->nb_streams < 1)
1835  return 0;
1836  st = c->fc->streams[c->fc->nb_streams-1];
1837 
1838  if ((uint64_t)atom.size > (1<<30))
1839  return AVERROR_INVALIDDATA;
1840 
1841  if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
1844  // pass all frma atom to codec, needed at least for QDMC and QDM2
1845  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1846  if (ret < 0)
1847  return ret;
1848  } else if (atom.size > 8) { /* to read frma, esds atoms */
1849  if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
1850  uint64_t buffer;
1851  ret = ffio_ensure_seekback(pb, 8);
1852  if (ret < 0)
1853  return ret;
1854  buffer = avio_rb64(pb);
1855  atom.size -= 8;
1856  if ( (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
1857  && buffer >> 32 <= atom.size
1858  && buffer >> 32 >= 8) {
1859  avio_skip(pb, -8);
1860  atom.size += 8;
1861  } else if (!st->codecpar->extradata_size) {
1862 #define ALAC_EXTRADATA_SIZE 36
1864  if (!st->codecpar->extradata)
1865  return AVERROR(ENOMEM);
1868  AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
1869  AV_WB64(st->codecpar->extradata + 12, buffer);
1870  avio_read(pb, st->codecpar->extradata + 20, 16);
1871  avio_skip(pb, atom.size - 24);
1872  return 0;
1873  }
1874  }
1875  if ((ret = mov_read_default(c, pb, atom)) < 0)
1876  return ret;
1877  } else
1878  avio_skip(pb, atom.size);
1879  return 0;
1880 }
1881 
1882 /**
1883  * This function reads atom content and puts data in extradata without tag
1884  * nor size unlike mov_read_extradata.
1885  */
1887 {
1888  AVStream *st;
1889  int ret;
1890 
1891  if (c->fc->nb_streams < 1)
1892  return 0;
1893  st = c->fc->streams[c->fc->nb_streams-1];
1894 
1895  if ((uint64_t)atom.size > (1<<30))
1896  return AVERROR_INVALIDDATA;
1897 
1898  if (atom.size >= 10) {
1899  // Broken files created by legacy versions of libavformat will
1900  // wrap a whole fiel atom inside of a glbl atom.
1901  unsigned size = avio_rb32(pb);
1902  unsigned type = avio_rl32(pb);
1903  avio_seek(pb, -8, SEEK_CUR);
1904  if (type == MKTAG('f','i','e','l') && size == atom.size)
1905  return mov_read_default(c, pb, atom);
1906  }
1907  if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
1908  av_log(c->fc, AV_LOG_WARNING, "ignoring multiple glbl\n");
1909  return 0;
1910  }
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  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 7);
1944  if (ret < 0)
1945  return ret;
1946 
1947  return 0;
1948 }
1949 
1950 /**
1951  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
1952  * but can have extradata appended at the end after the 40 bytes belonging
1953  * to the struct.
1954  */
1956 {
1957  AVStream *st;
1958  int ret;
1959 
1960  if (c->fc->nb_streams < 1)
1961  return 0;
1962  if (atom.size <= 40)
1963  return 0;
1964  st = c->fc->streams[c->fc->nb_streams-1];
1965 
1966  if ((uint64_t)atom.size > (1<<30))
1967  return AVERROR_INVALIDDATA;
1968 
1969  avio_skip(pb, 40);
1970  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 40);
1971  if (ret < 0)
1972  return ret;
1973 
1974  return 0;
1975 }
1976 
1978 {
1979  AVStream *st;
1980  MOVStreamContext *sc;
1981  unsigned int i, entries;
1982 
1983  if (c->trak_index < 0) {
1984  av_log(c->fc, AV_LOG_WARNING, "STCO outside TRAK\n");
1985  return 0;
1986  }
1987  if (c->fc->nb_streams < 1)
1988  return 0;
1989  st = c->fc->streams[c->fc->nb_streams-1];
1990  sc = st->priv_data;
1991 
1992  avio_r8(pb); /* version */
1993  avio_rb24(pb); /* flags */
1994 
1995  entries = avio_rb32(pb);
1996 
1997  if (!entries)
1998  return 0;
1999 
2000  if (sc->chunk_offsets)
2001  av_log(c->fc, AV_LOG_WARNING, "Duplicated STCO atom\n");
2002  av_free(sc->chunk_offsets);
2003  sc->chunk_count = 0;
2004  sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2005  if (!sc->chunk_offsets)
2006  return AVERROR(ENOMEM);
2007  sc->chunk_count = entries;
2008 
2009  if (atom.type == MKTAG('s','t','c','o'))
2010  for (i = 0; i < entries && !pb->eof_reached; i++)
2011  sc->chunk_offsets[i] = avio_rb32(pb);
2012  else if (atom.type == MKTAG('c','o','6','4'))
2013  for (i = 0; i < entries && !pb->eof_reached; i++)
2014  sc->chunk_offsets[i] = avio_rb64(pb);
2015  else
2016  return AVERROR_INVALIDDATA;
2017 
2018  sc->chunk_count = i;
2019 
2020  if (pb->eof_reached) {
2021  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STCO atom\n");
2022  return AVERROR_EOF;
2023  }
2024 
2025  return 0;
2026 }
2027 
2028 static int mov_codec_id(AVStream *st, uint32_t format)
2029 {
2030  int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
2031 
2032  if (id <= 0 &&
2033  ((format & 0xFFFF) == 'm' + ('s' << 8) ||
2034  (format & 0xFFFF) == 'T' + ('S' << 8)))
2035  id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
2036 
2037  if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
2039  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
2040  /* skip old ASF MPEG-4 tag */
2041  format && format != MKTAG('m','p','4','s')) {
2043  if (id <= 0)
2044  id = ff_codec_get_id(ff_codec_bmp_tags, format);
2045  if (id > 0)
2047  else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
2049  st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
2051  if (id > 0)
2053  else
2054  id = ff_codec_get_id(ff_codec_movdata_tags, format);
2055  }
2056  }
2057 
2058  st->codecpar->codec_tag = format;
2059 
2060  return id;
2061 }
2062 
2064  AVStream *st, MOVStreamContext *sc)
2065 {
2066  uint8_t codec_name[32] = { 0 };
2067  int64_t stsd_start;
2068  unsigned int len;
2069 
2070  /* The first 16 bytes of the video sample description are already
2071  * read in ff_mov_read_stsd_entries() */
2072  stsd_start = avio_tell(pb) - 16;
2073 
2074  avio_rb16(pb); /* version */
2075  avio_rb16(pb); /* revision level */
2076  avio_rb32(pb); /* vendor */
2077  avio_rb32(pb); /* temporal quality */
2078  avio_rb32(pb); /* spatial quality */
2079 
2080  st->codecpar->width = avio_rb16(pb); /* width */
2081  st->codecpar->height = avio_rb16(pb); /* height */
2082 
2083  avio_rb32(pb); /* horiz resolution */
2084  avio_rb32(pb); /* vert resolution */
2085  avio_rb32(pb); /* data size, always 0 */
2086  avio_rb16(pb); /* frames per samples */
2087 
2088  len = avio_r8(pb); /* codec name, pascal string */
2089  if (len > 31)
2090  len = 31;
2091  mov_read_mac_string(c, pb, len, codec_name, sizeof(codec_name));
2092  if (len < 31)
2093  avio_skip(pb, 31 - len);
2094 
2095  if (codec_name[0])
2096  av_dict_set(&st->metadata, "encoder", codec_name, 0);
2097 
2098  /* codec_tag YV12 triggers an UV swap in rawdec.c */
2099  if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
2100  st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
2101  st->codecpar->width &= ~1;
2102  st->codecpar->height &= ~1;
2103  }
2104  /* Flash Media Server uses tag H.263 with Sorenson Spark */
2105  if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
2106  !strncmp(codec_name, "Sorenson H263", 13))
2108 
2109  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
2110 
2111  avio_seek(pb, stsd_start, SEEK_SET);
2112 
2113  if (ff_get_qtpalette(st->codecpar->codec_id, pb, sc->palette)) {
2114  st->codecpar->bits_per_coded_sample &= 0x1F;
2115  sc->has_palette = 1;
2116  }
2117 }
2118 
2120  AVStream *st, MOVStreamContext *sc)
2121 {
2122  int bits_per_sample, flags;
2123  uint16_t version = avio_rb16(pb);
2124  AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
2125 
2126  avio_rb16(pb); /* revision level */
2127  avio_rb32(pb); /* vendor */
2128 
2129  st->codecpar->channels = avio_rb16(pb); /* channel count */
2130  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* sample size */
2131  av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codecpar->channels);
2132 
2133  sc->audio_cid = avio_rb16(pb);
2134  avio_rb16(pb); /* packet size = 0 */
2135 
2136  st->codecpar->sample_rate = ((avio_rb32(pb) >> 16));
2137 
2138  // Read QT version 1 fields. In version 0 these do not exist.
2139  av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom);
2140  if (!c->isom ||
2141  (compatible_brands && strstr(compatible_brands->value, "qt ")) ||
2142  (sc->stsd_version == 0 && version > 0)) {
2143  if (version == 1) {
2144  sc->samples_per_frame = avio_rb32(pb);
2145  avio_rb32(pb); /* bytes per packet */
2146  sc->bytes_per_frame = avio_rb32(pb);
2147  avio_rb32(pb); /* bytes per sample */
2148  } else if (version == 2) {
2149  avio_rb32(pb); /* sizeof struct only */
2151  st->codecpar->channels = avio_rb32(pb);
2152  avio_rb32(pb); /* always 0x7F000000 */
2154 
2155  flags = avio_rb32(pb); /* lpcm format specific flag */
2156  sc->bytes_per_frame = avio_rb32(pb);
2157  sc->samples_per_frame = avio_rb32(pb);
2158  if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
2159  st->codecpar->codec_id =
2161  flags);
2162  }
2163  if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
2164  /* can't correctly handle variable sized packet as audio unit */
2165  switch (st->codecpar->codec_id) {
2166  case AV_CODEC_ID_MP2:
2167  case AV_CODEC_ID_MP3:
2169  break;
2170  }
2171  }
2172  }
2173 
2174  if (sc->format == 0) {
2175  if (st->codecpar->bits_per_coded_sample == 8)
2176  st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
2177  else if (st->codecpar->bits_per_coded_sample == 16)
2178  st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
2179  }
2180 
2181  switch (st->codecpar->codec_id) {
2182  case AV_CODEC_ID_PCM_S8:
2183  case AV_CODEC_ID_PCM_U8:
2184  if (st->codecpar->bits_per_coded_sample == 16)
2186  break;
2187  case AV_CODEC_ID_PCM_S16LE:
2188  case AV_CODEC_ID_PCM_S16BE:
2189  if (st->codecpar->bits_per_coded_sample == 8)
2191  else if (st->codecpar->bits_per_coded_sample == 24)
2192  st->codecpar->codec_id =
2195  else if (st->codecpar->bits_per_coded_sample == 32)
2196  st->codecpar->codec_id =
2199  break;
2200  /* set values for old format before stsd version 1 appeared */
2201  case AV_CODEC_ID_MACE3:
2202  sc->samples_per_frame = 6;
2203  sc->bytes_per_frame = 2 * st->codecpar->channels;
2204  break;
2205  case AV_CODEC_ID_MACE6:
2206  sc->samples_per_frame = 6;
2207  sc->bytes_per_frame = 1 * st->codecpar->channels;
2208  break;
2210  sc->samples_per_frame = 64;
2211  sc->bytes_per_frame = 34 * st->codecpar->channels;
2212  break;
2213  case AV_CODEC_ID_GSM:
2214  sc->samples_per_frame = 160;
2215  sc->bytes_per_frame = 33;
2216  break;
2217  default:
2218  break;
2219  }
2220 
2221  bits_per_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2222  if (bits_per_sample) {
2223  st->codecpar->bits_per_coded_sample = bits_per_sample;
2224  sc->sample_size = (bits_per_sample >> 3) * st->codecpar->channels;
2225  }
2226 }
2227 
2229  AVStream *st, MOVStreamContext *sc,
2230  int64_t size)
2231 {
2232  // ttxt stsd contains display flags, justification, background
2233  // color, fonts, and default styles, so fake an atom to read it
2234  MOVAtom fake_atom = { .size = size };
2235  // mp4s contains a regular esds atom
2236  if (st->codecpar->codec_tag != AV_RL32("mp4s"))
2237  mov_read_glbl(c, pb, fake_atom);
2238  st->codecpar->width = sc->width;
2239  st->codecpar->height = sc->height;
2240 }
2241 
2242 static uint32_t yuv_to_rgba(uint32_t ycbcr)
2243 {
2244  uint8_t r, g, b;
2245  int y, cb, cr;
2246 
2247  y = (ycbcr >> 16) & 0xFF;
2248  cr = (ycbcr >> 8) & 0xFF;
2249  cb = ycbcr & 0xFF;
2250 
2251  b = av_clip_uint8((1164 * (y - 16) + 2018 * (cb - 128)) / 1000);
2252  g = av_clip_uint8((1164 * (y - 16) - 813 * (cr - 128) - 391 * (cb - 128)) / 1000);
2253  r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128) ) / 1000);
2254 
2255  return (r << 16) | (g << 8) | b;
2256 }
2257 
2259 {
2260  char buf[256] = {0};
2261  uint8_t *src = st->codecpar->extradata;
2262  int i, ret;
2263 
2264  if (st->codecpar->extradata_size != 64)
2265  return 0;
2266 
2267  if (st->codecpar->width > 0 && st->codecpar->height > 0)
2268  snprintf(buf, sizeof(buf), "size: %dx%d\n",
2269  st->codecpar->width, st->codecpar->height);
2270  av_strlcat(buf, "palette: ", sizeof(buf));
2271 
2272  for (i = 0; i < 16; i++) {
2273  uint32_t yuv = AV_RB32(src + i * 4);
2274  uint32_t rgba = yuv_to_rgba(yuv);
2275 
2276  av_strlcatf(buf, sizeof(buf), "%06"PRIx32"%s", rgba, i != 15 ? ", " : "");
2277  }
2278 
2279  if (av_strlcat(buf, "\n", sizeof(buf)) >= sizeof(buf))
2280  return 0;
2281 
2282  ret = ff_alloc_extradata(st->codecpar, strlen(buf));
2283  if (ret < 0)
2284  return ret;
2285  memcpy(st->codecpar->extradata, buf, st->codecpar->extradata_size);
2286 
2287  return 0;
2288 }
2289 
2291  AVStream *st, MOVStreamContext *sc,
2292  int64_t size)
2293 {
2294  int ret;
2295 
2296  if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
2297  if ((int)size != size)
2298  return AVERROR(ENOMEM);
2299 
2300  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
2301  if (ret < 0)
2302  return ret;
2303  if (size > 16) {
2304  MOVStreamContext *tmcd_ctx = st->priv_data;
2305  int val;
2306  val = AV_RB32(st->codecpar->extradata + 4);
2307  tmcd_ctx->tmcd_flags = val;
2308  st->avg_frame_rate.num = AV_RB32(st->codecpar->extradata + 8); /* timescale */
2309  st->avg_frame_rate.den = AV_RB32(st->codecpar->extradata + 12); /* frameDuration */
2310 #if FF_API_LAVF_AVCTX
2312  st->codec->time_base = av_inv_q(st->avg_frame_rate);
2314 #endif
2315  /* adjust for per frame dur in counter mode */
2316  if (tmcd_ctx->tmcd_flags & 0x0008) {
2317  int timescale = AV_RB32(st->codecpar->extradata + 8);
2318  int framedur = AV_RB32(st->codecpar->extradata + 12);
2319  st->avg_frame_rate.num *= timescale;
2320  st->avg_frame_rate.den *= framedur;
2321 #if FF_API_LAVF_AVCTX
2323  st->codec->time_base.den *= timescale;
2324  st->codec->time_base.num *= framedur;
2326 #endif
2327  }
2328  if (size > 30) {
2329  uint32_t len = AV_RB32(st->codecpar->extradata + 18); /* name atom length */
2330  uint32_t format = AV_RB32(st->codecpar->extradata + 22);
2331  if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
2332  uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
2333  if (str_size > 0 && size >= (int)str_size + 30 &&
2334  st->codecpar->extradata[30] /* Don't add empty string */) {
2335  char *reel_name = av_malloc(str_size + 1);
2336  if (!reel_name)
2337  return AVERROR(ENOMEM);
2338  memcpy(reel_name, st->codecpar->extradata + 30, str_size);
2339  reel_name[str_size] = 0; /* Add null terminator */
2340  av_dict_set(&st->metadata, "reel_name", reel_name,
2342  }
2343  }
2344  }
2345  }
2346  } else {
2347  /* other codec type, just skip (rtp, mp4s ...) */
2348  avio_skip(pb, size);
2349  }
2350  return 0;
2351 }
2352 
2354  AVStream *st, MOVStreamContext *sc)
2355 {
2356  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2357  !st->codecpar->sample_rate && sc->time_scale > 1)
2358  st->codecpar->sample_rate = sc->time_scale;
2359 
2360  /* special codec parameters handling */
2361  switch (st->codecpar->codec_id) {
2362 #if CONFIG_DV_DEMUXER
2363  case AV_CODEC_ID_DVAUDIO:
2365  if (!c->dv_fctx) {
2366  av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
2367  return AVERROR(ENOMEM);
2368  }
2370  if (!c->dv_demux) {
2371  av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
2372  return AVERROR(ENOMEM);
2373  }
2374  sc->dv_audio_container = 1;
2376  break;
2377 #endif
2378  /* no ifdef since parameters are always those */
2379  case AV_CODEC_ID_QCELP:
2380  st->codecpar->channels = 1;
2381  // force sample rate for qcelp when not stored in mov
2382  if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
2383  st->codecpar->sample_rate = 8000;
2384  // FIXME: Why is the following needed for some files?
2385  sc->samples_per_frame = 160;
2386  if (!sc->bytes_per_frame)
2387  sc->bytes_per_frame = 35;
2388  break;
2389  case AV_CODEC_ID_AMR_NB:
2390  st->codecpar->channels = 1;
2391  /* force sample rate for amr, stsd in 3gp does not store sample rate */
2392  st->codecpar->sample_rate = 8000;
2393  break;
2394  case AV_CODEC_ID_AMR_WB:
2395  st->codecpar->channels = 1;
2396  st->codecpar->sample_rate = 16000;
2397  break;
2398  case AV_CODEC_ID_MP2:
2399  case AV_CODEC_ID_MP3:
2400  /* force type after stsd for m1a hdlr */
2402  break;
2403  case AV_CODEC_ID_GSM:
2404  case AV_CODEC_ID_ADPCM_MS:
2406  case AV_CODEC_ID_ILBC:
2407  case AV_CODEC_ID_MACE3:
2408  case AV_CODEC_ID_MACE6:
2409  case AV_CODEC_ID_QDM2:
2411  break;
2412  case AV_CODEC_ID_ALAC:
2413  if (st->codecpar->extradata_size == 36) {
2414  st->codecpar->channels = AV_RB8 (st->codecpar->extradata + 21);
2415  st->codecpar->sample_rate = AV_RB32(st->codecpar->extradata + 32);
2416  }
2417  break;
2418  case AV_CODEC_ID_AC3:
2419  case AV_CODEC_ID_EAC3:
2421  case AV_CODEC_ID_VC1:
2422  case AV_CODEC_ID_VP8:
2423  case AV_CODEC_ID_VP9:
2425  break;
2426  case AV_CODEC_ID_AV1:
2428  break;
2429  default:
2430  break;
2431  }
2432  return 0;
2433 }
2434 
2436  int codec_tag, int format,
2437  int64_t size)
2438 {
2439  int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2440 
2441  if (codec_tag &&
2442  (codec_tag != format &&
2443  // AVID 1:1 samples with differing data format and codec tag exist
2444  (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
2445  // prores is allowed to have differing data format and codec tag
2446  codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
2447  // so is dv (sigh)
2448  codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
2449  (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
2450  : codec_tag != MKTAG('j','p','e','g')))) {
2451  /* Multiple fourcc, we skip JPEG. This is not correct, we should
2452  * export it as a separate AVStream but this needs a few changes
2453  * in the MOV demuxer, patch welcome. */
2454 
2455  av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
2456  avio_skip(pb, size);
2457  return 1;
2458  }
2459 
2460  return 0;
2461 }
2462 
2464 {
2465  AVStream *st;
2466  MOVStreamContext *sc;
2467  int pseudo_stream_id;
2468 
2469  av_assert0 (c->fc->nb_streams >= 1);
2470  st = c->fc->streams[c->fc->nb_streams-1];
2471  sc = st->priv_data;
2472 
2473  for (pseudo_stream_id = 0;
2474  pseudo_stream_id < entries && !pb->eof_reached;
2475  pseudo_stream_id++) {
2476  //Parsing Sample description table
2477  enum AVCodecID id;
2478  int ret, dref_id = 1;
2479  MOVAtom a = { AV_RL32("stsd") };
2480  int64_t start_pos = avio_tell(pb);
2481  int64_t size = avio_rb32(pb); /* size */
2482  uint32_t format = avio_rl32(pb); /* data format */
2483 
2484  if (size >= 16) {
2485  avio_rb32(pb); /* reserved */
2486  avio_rb16(pb); /* reserved */
2487  dref_id = avio_rb16(pb);
2488  } else if (size <= 7) {
2489  av_log(c->fc, AV_LOG_ERROR,
2490  "invalid size %"PRId64" in stsd\n", size);
2491  return AVERROR_INVALIDDATA;
2492  }
2493 
2494  if (mov_skip_multiple_stsd(c, pb, st->codecpar->codec_tag, format,
2495  size - (avio_tell(pb) - start_pos))) {
2496  sc->stsd_count++;
2497  continue;
2498  }
2499 
2500  sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
2501  sc->dref_id= dref_id;
2502  sc->format = format;
2503 
2504  id = mov_codec_id(st, format);
2505 
2506  av_log(c->fc, AV_LOG_TRACE,
2507  "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
2508  av_fourcc2str(format), st->codecpar->codec_type);
2509 
2510  st->codecpar->codec_id = id;
2512  mov_parse_stsd_video(c, pb, st, sc);
2513  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
2514  mov_parse_stsd_audio(c, pb, st, sc);
2515  if (st->codecpar->sample_rate < 0) {
2516  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
2517  return AVERROR_INVALIDDATA;
2518  }
2519  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
2520  mov_parse_stsd_subtitle(c, pb, st, sc,
2521  size - (avio_tell(pb) - start_pos));
2522  } else {
2523  ret = mov_parse_stsd_data(c, pb, st, sc,
2524  size - (avio_tell(pb) - start_pos));
2525  if (ret < 0)
2526  return ret;
2527  }
2528  /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
2529  a.size = size - (avio_tell(pb) - start_pos);
2530  if (a.size > 8) {
2531  if ((ret = mov_read_default(c, pb, a)) < 0)
2532  return ret;
2533  } else if (a.size > 0)
2534  avio_skip(pb, a.size);
2535 
2536  if (sc->extradata && st->codecpar->extradata) {
2537  int extra_size = st->codecpar->extradata_size;
2538 
2539  /* Move the current stream extradata to the stream context one. */
2540  sc->extradata_size[pseudo_stream_id] = extra_size;
2541  sc->extradata[pseudo_stream_id] = st->codecpar->extradata;
2542  st->codecpar->extradata = NULL;
2543  st->codecpar->extradata_size = 0;
2544  }
2545  sc->stsd_count++;
2546  }
2547 
2548  if (pb->eof_reached) {
2549  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSD atom\n");
2550  return AVERROR_EOF;
2551  }
2552 
2553  return 0;
2554 }
2555 
2557 {
2558  AVStream *st;
2559  MOVStreamContext *sc;
2560  int ret, entries;
2561 
2562  if (c->fc->nb_streams < 1)
2563  return 0;
2564  st = c->fc->streams[c->fc->nb_streams - 1];
2565  sc = st->priv_data;
2566 
2567  sc->stsd_version = avio_r8(pb);
2568  avio_rb24(pb); /* flags */
2569  entries = avio_rb32(pb);
2570 
2571  /* Each entry contains a size (4 bytes) and format (4 bytes). */
2572  if (entries <= 0 || entries > atom.size / 8) {
2573  av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2574  return AVERROR_INVALIDDATA;
2575  }
2576 
2577  if (sc->extradata) {
2578  av_log(c->fc, AV_LOG_ERROR,
2579  "Duplicate stsd found in this track.\n");
2580  return AVERROR_INVALIDDATA;
2581  }
2582 
2583  /* Prepare space for hosting multiple extradata. */
2584  sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
2585  if (!sc->extradata)
2586  return AVERROR(ENOMEM);
2587 
2588  sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
2589  if (!sc->extradata_size) {
2590  ret = AVERROR(ENOMEM);
2591  goto fail;
2592  }
2593 
2594  ret = ff_mov_read_stsd_entries(c, pb, entries);
2595  if (ret < 0)
2596  goto fail;
2597 
2598  /* Restore back the primary extradata. */
2599  av_freep(&st->codecpar->extradata);
2600  st->codecpar->extradata_size = sc->extradata_size[0];
2601  if (sc->extradata_size[0]) {
2603  if (!st->codecpar->extradata)
2604  return AVERROR(ENOMEM);
2605  memcpy(st->codecpar->extradata, sc->extradata[0], sc->extradata_size[0]);
2606  }
2607 
2608  return mov_finalize_stsd_codec(c, pb, st, sc);
2609 fail:
2610  if (sc->extradata) {
2611  int j;
2612  for (j = 0; j < sc->stsd_count; j++)
2613  av_freep(&sc->extradata[j]);
2614  }
2615 
2616  av_freep(&sc->extradata);
2617  av_freep(&sc->extradata_size);
2618  return ret;
2619 }
2620 
2622 {
2623  AVStream *st;
2624  MOVStreamContext *sc;
2625  unsigned int i, entries;
2626 
2627  if (c->fc->nb_streams < 1)
2628  return 0;
2629  st = c->fc->streams[c->fc->nb_streams-1];
2630  sc = st->priv_data;
2631 
2632  avio_r8(pb); /* version */
2633  avio_rb24(pb); /* flags */
2634 
2635  entries = avio_rb32(pb);
2636  if ((uint64_t)entries * 12 + 4 > atom.size)
2637  return AVERROR_INVALIDDATA;
2638 
2639  av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2640 
2641  if (!entries)
2642  return 0;
2643  if (sc->stsc_data)
2644  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSC atom\n");
2645  av_free(sc->stsc_data);
2646  sc->stsc_count = 0;
2647  sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2648  if (!sc->stsc_data)
2649  return AVERROR(ENOMEM);
2650 
2651  for (i = 0; i < entries && !pb->eof_reached; i++) {
2652  sc->stsc_data[i].first = avio_rb32(pb);
2653  sc->stsc_data[i].count = avio_rb32(pb);
2654  sc->stsc_data[i].id = avio_rb32(pb);
2655  }
2656 
2657  sc->stsc_count = i;
2658  for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
2659  int64_t first_min = i + 1;
2660  if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
2661  (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
2662  sc->stsc_data[i].first < first_min ||
2663  sc->stsc_data[i].count < 1 ||
2664  sc->stsc_data[i].id < 1) {
2665  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);
2666  if (i+1 >= sc->stsc_count) {
2667  if (sc->stsc_data[i].count == 0 && i > 0) {
2668  sc->stsc_count --;
2669  continue;
2670  }
2671  sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
2672  if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
2673  sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
2674  sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
2675  sc->stsc_data[i].id = FFMAX(sc->stsc_data[i].id, 1);
2676  continue;
2677  }
2678  av_assert0(sc->stsc_data[i+1].first >= 2);
2679  // We replace this entry by the next valid
2680  sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
2681  sc->stsc_data[i].count = sc->stsc_data[i+1].count;
2682  sc->stsc_data[i].id = sc->stsc_data[i+1].id;
2683  }
2684  }
2685 
2686  if (pb->eof_reached) {
2687  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSC atom\n");
2688  return AVERROR_EOF;
2689  }
2690 
2691  return 0;
2692 }
2693 
2694 static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
2695 {
2696  return index < count - 1;
2697 }
2698 
2699 /* Compute the samples value for the stsc entry at the given index. */
2700 static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
2701 {
2702  int chunk_count;
2703 
2704  if (mov_stsc_index_valid(index, sc->stsc_count))
2705  chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
2706  else {
2707  // Validation for stsc / stco happens earlier in mov_read_stsc + mov_read_trak.
2708  av_assert0(sc->stsc_data[index].first <= sc->chunk_count);
2709  chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
2710  }
2711 
2712  return sc->stsc_data[index].count * (int64_t)chunk_count;
2713 }
2714 
2716 {
2717  AVStream *st;
2718  MOVStreamContext *sc;
2719  unsigned i, entries;
2720 
2721  if (c->fc->nb_streams < 1)
2722  return 0;
2723  st = c->fc->streams[c->fc->nb_streams-1];
2724  sc = st->priv_data;
2725 
2726  avio_rb32(pb); // version + flags
2727 
2728  entries = avio_rb32(pb);
2729  if (sc->stps_data)
2730  av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
2731  av_free(sc->stps_data);
2732  sc->stps_count = 0;
2733  sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2734  if (!sc->stps_data)
2735  return AVERROR(ENOMEM);
2736 
2737  for (i = 0; i < entries && !pb->eof_reached; i++) {
2738  sc->stps_data[i] = avio_rb32(pb);
2739  }
2740 
2741  sc->stps_count = i;
2742 
2743  if (pb->eof_reached) {
2744  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STPS atom\n");
2745  return AVERROR_EOF;
2746  }
2747 
2748  return 0;
2749 }
2750 
2752 {
2753  AVStream *st;
2754  MOVStreamContext *sc;
2755  unsigned int i, entries;
2756 
2757  if (c->fc->nb_streams < 1)
2758  return 0;
2759  st = c->fc->streams[c->fc->nb_streams-1];
2760  sc = st->priv_data;
2761 
2762  avio_r8(pb); /* version */
2763  avio_rb24(pb); /* flags */
2764 
2765  entries = avio_rb32(pb);
2766 
2767  av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
2768 
2769  if (!entries) {
2770  sc->keyframe_absent = 1;
2771  if (!st->need_parsing && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2773  return 0;
2774  }
2775  if (sc->keyframes)
2776  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
2777  if (entries >= UINT_MAX / sizeof(int))
2778  return AVERROR_INVALIDDATA;
2779  av_freep(&sc->keyframes);
2780  sc->keyframe_count = 0;
2781  sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
2782  if (!sc->keyframes)
2783  return AVERROR(ENOMEM);
2784 
2785  for (i = 0; i < entries && !pb->eof_reached; i++) {
2786  sc->keyframes[i] = avio_rb32(pb);
2787  }
2788 
2789  sc->keyframe_count = i;
2790 
2791  if (pb->eof_reached) {
2792  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSS atom\n");
2793  return AVERROR_EOF;
2794  }
2795 
2796  return 0;
2797 }
2798 
2800 {
2801  AVStream *st;
2802  MOVStreamContext *sc;
2803  unsigned int i, entries, sample_size, field_size, num_bytes;
2804  GetBitContext gb;
2805  unsigned char* buf;
2806  int ret;
2807 
2808  if (c->fc->nb_streams < 1)
2809  return 0;
2810  st = c->fc->streams[c->fc->nb_streams-1];
2811  sc = st->priv_data;
2812 
2813  avio_r8(pb); /* version */
2814  avio_rb24(pb); /* flags */
2815 
2816  if (atom.type == MKTAG('s','t','s','z')) {
2817  sample_size = avio_rb32(pb);
2818  if (!sc->sample_size) /* do not overwrite value computed in stsd */
2819  sc->sample_size = sample_size;
2820  sc->stsz_sample_size = sample_size;
2821  field_size = 32;
2822  } else {
2823  sample_size = 0;
2824  avio_rb24(pb); /* reserved */
2825  field_size = avio_r8(pb);
2826  }
2827  entries = avio_rb32(pb);
2828 
2829  av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
2830 
2831  sc->sample_count = entries;
2832  if (sample_size)
2833  return 0;
2834 
2835  if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2836  av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
2837  return AVERROR_INVALIDDATA;
2838  }
2839 
2840  if (!entries)
2841  return 0;
2842  if (entries >= (UINT_MAX - 4) / field_size)
2843  return AVERROR_INVALIDDATA;
2844  if (sc->sample_sizes)
2845  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
2846  av_free(sc->sample_sizes);
2847  sc->sample_count = 0;
2848  sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
2849  if (!sc->sample_sizes)
2850  return AVERROR(ENOMEM);
2851 
2852  num_bytes = (entries*field_size+4)>>3;
2853 
2854  buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
2855  if (!buf) {
2856  av_freep(&sc->sample_sizes);
2857  return AVERROR(ENOMEM);
2858  }
2859 
2860  ret = ffio_read_size(pb, buf, num_bytes);
2861  if (ret < 0) {
2862  av_freep(&sc->sample_sizes);
2863  av_free(buf);
2864  av_log(c->fc, AV_LOG_WARNING, "STSZ atom truncated\n");
2865  return 0;
2866  }
2867 
2868  init_get_bits(&gb, buf, 8*num_bytes);
2869 
2870  for (i = 0; i < entries && !pb->eof_reached; i++) {
2871  sc->sample_sizes[i] = get_bits_long(&gb, field_size);
2872  if (sc->sample_sizes[i] < 0) {
2873  av_free(buf);
2874  av_log(c->fc, AV_LOG_ERROR, "Invalid sample size %d\n", sc->sample_sizes[i]);
2875  return AVERROR_INVALIDDATA;
2876  }
2877  sc->data_size += sc->sample_sizes[i];
2878  }
2879 
2880  sc->sample_count = i;
2881 
2882  av_free(buf);
2883 
2884  if (pb->eof_reached) {
2885  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSZ atom\n");
2886  return AVERROR_EOF;
2887  }
2888 
2889  return 0;
2890 }
2891 
2893 {
2894  AVStream *st;
2895  MOVStreamContext *sc;
2896  unsigned int i, entries, alloc_size = 0;
2897  int64_t duration = 0;
2898  int64_t total_sample_count = 0;
2899 
2900  if (c->fc->nb_streams < 1)
2901  return 0;
2902  st = c->fc->streams[c->fc->nb_streams-1];
2903  sc = st->priv_data;
2904 
2905  avio_r8(pb); /* version */
2906  avio_rb24(pb); /* flags */
2907  entries = avio_rb32(pb);
2908 
2909  av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
2910  c->fc->nb_streams-1, entries);
2911 
2912  if (sc->stts_data)
2913  av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
2914  av_freep(&sc->stts_data);
2915  sc->stts_count = 0;
2916  if (entries >= INT_MAX / sizeof(*sc->stts_data))
2917  return AVERROR(ENOMEM);
2918 
2919  for (i = 0; i < entries && !pb->eof_reached; i++) {
2920  int sample_duration;
2921  unsigned int sample_count;
2922  unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
2923  MOVStts *stts_data = av_fast_realloc(sc->stts_data, &alloc_size,
2924  min_entries * sizeof(*sc->stts_data));
2925  if (!stts_data) {
2926  av_freep(&sc->stts_data);
2927  sc->stts_count = 0;
2928  return AVERROR(ENOMEM);
2929  }
2930  sc->stts_count = min_entries;
2931  sc->stts_data = stts_data;
2932 
2933  sample_count = avio_rb32(pb);
2934  sample_duration = avio_rb32(pb);
2935 
2936  sc->stts_data[i].count= sample_count;
2937  sc->stts_data[i].duration= sample_duration;
2938 
2939  av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n",
2940  sample_count, sample_duration);
2941 
2942  duration+=(int64_t)sample_duration*(uint64_t)sample_count;
2943  total_sample_count+=sample_count;
2944  }
2945 
2946  sc->stts_count = i;
2947 
2948  if (duration > 0 &&
2949  duration <= INT64_MAX - sc->duration_for_fps &&
2950  total_sample_count <= INT_MAX - sc->nb_frames_for_fps) {
2951  sc->duration_for_fps += duration;
2952  sc->nb_frames_for_fps += total_sample_count;
2953  }
2954 
2955  if (pb->eof_reached) {
2956  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STTS atom\n");
2957  return AVERROR_EOF;
2958  }
2959 
2960  st->nb_frames= total_sample_count;
2961  if (duration)
2962  st->duration= FFMIN(st->duration, duration);
2963  sc->track_end = duration;
2964  return 0;
2965 }
2966 
2968 {
2969  AVStream *st;
2970  MOVStreamContext *sc;
2971  int64_t i, entries;
2972 
2973  if (c->fc->nb_streams < 1)
2974  return 0;
2975  st = c->fc->streams[c->fc->nb_streams - 1];
2976  sc = st->priv_data;
2977 
2978  avio_r8(pb); /* version */
2979  avio_rb24(pb); /* flags */
2980  entries = atom.size - 4;
2981 
2982  av_log(c->fc, AV_LOG_TRACE, "track[%u].sdtp.entries = %" PRId64 "\n",
2983  c->fc->nb_streams - 1, entries);
2984 
2985  if (sc->sdtp_data)
2986  av_log(c->fc, AV_LOG_WARNING, "Duplicated SDTP atom\n");
2987  av_freep(&sc->sdtp_data);
2988  sc->sdtp_count = 0;
2989 
2990  sc->sdtp_data = av_mallocz(entries);
2991  if (!sc->sdtp_data)
2992  return AVERROR(ENOMEM);
2993 
2994  for (i = 0; i < entries && !pb->eof_reached; i++)
2995  sc->sdtp_data[i] = avio_r8(pb);
2996  sc->sdtp_count = i;
2997 
2998  return 0;
2999 }
3000 
3001 static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logctx)
3002 {
3003  if (duration < 0) {
3004  if (duration == INT_MIN) {
3005  av_log(logctx, AV_LOG_WARNING, "mov_update_dts_shift(): dts_shift set to %d\n", INT_MAX);
3006  duration++;
3007  }
3008  sc->dts_shift = FFMAX(sc->dts_shift, -duration);
3009  }
3010 }
3011 
3013 {
3014  AVStream *st;
3015  MOVStreamContext *sc;
3016  unsigned int i, entries, ctts_count = 0;
3017 
3018  if (c->fc->nb_streams < 1)
3019  return 0;
3020  st = c->fc->streams[c->fc->nb_streams-1];
3021  sc = st->priv_data;
3022 
3023  avio_r8(pb); /* version */
3024  avio_rb24(pb); /* flags */
3025  entries = avio_rb32(pb);
3026 
3027  av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
3028 
3029  if (!entries)
3030  return 0;
3031  if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
3032  return AVERROR_INVALIDDATA;
3033  av_freep(&sc->ctts_data);
3034  sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
3035  if (!sc->ctts_data)
3036  return AVERROR(ENOMEM);
3037 
3038  for (i = 0; i < entries && !pb->eof_reached; i++) {
3039  int count = avio_rb32(pb);
3040  int duration = avio_rb32(pb);
3041 
3042  if (count <= 0) {
3043  av_log(c->fc, AV_LOG_TRACE,
3044  "ignoring CTTS entry with count=%d duration=%d\n",
3045  count, duration);
3046  continue;
3047  }
3048 
3049  add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
3050  count, duration);
3051 
3052  av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
3053  count, duration);
3054 
3055  if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3056  av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
3057  av_freep(&sc->ctts_data);
3058  sc->ctts_count = 0;
3059  return 0;
3060  }
3061 
3062  if (i+2<entries)
3063  mov_update_dts_shift(sc, duration, c->fc);
3064  }
3065 
3066  sc->ctts_count = ctts_count;
3067 
3068  if (pb->eof_reached) {
3069  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted CTTS atom\n");
3070  return AVERROR_EOF;
3071  }
3072 
3073  av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift);
3074 
3075  return 0;
3076 }
3077 
3079 {
3080  AVStream *st;
3081  MOVStreamContext *sc;
3082  unsigned int i, entries;
3083  uint8_t version;
3084  uint32_t grouping_type;
3085 
3086  if (c->fc->nb_streams < 1)
3087  return 0;
3088  st = c->fc->streams[c->fc->nb_streams-1];
3089  sc = st->priv_data;
3090 
3091  version = avio_r8(pb); /* version */
3092  avio_rb24(pb); /* flags */
3093  grouping_type = avio_rl32(pb);
3094  if (grouping_type != MKTAG( 'r','a','p',' '))
3095  return 0; /* only support 'rap ' grouping */
3096  if (version == 1)
3097  avio_rb32(pb); /* grouping_type_parameter */
3098 
3099  entries = avio_rb32(pb);
3100  if (!entries)
3101  return 0;
3102  if (sc->rap_group)
3103  av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
3104  av_free(sc->rap_group);
3105  sc->rap_group_count = 0;
3106  sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
3107  if (!sc->rap_group)
3108  return AVERROR(ENOMEM);
3109 
3110  for (i = 0; i < entries && !pb->eof_reached; i++) {
3111  sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
3112  sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
3113  }
3114 
3115  sc->rap_group_count = i;
3116 
3117  if (pb->eof_reached) {
3118  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted SBGP atom\n");
3119  return AVERROR_EOF;
3120  }
3121 
3122  return 0;
3123 }
3124 
3125 /**
3126  * Get ith edit list entry (media time, duration).
3127  */
3129  const MOVStreamContext *msc,
3130  unsigned int edit_list_index,
3131  int64_t *edit_list_media_time,
3132  int64_t *edit_list_duration,
3133  int64_t global_timescale)
3134 {
3135  if (edit_list_index == msc->elst_count) {
3136  return 0;
3137  }
3138  *edit_list_media_time = msc->elst_data[edit_list_index].time;
3139  *edit_list_duration = msc->elst_data[edit_list_index].duration;
3140 
3141  /* duration is in global timescale units;convert to msc timescale */
3142  if (global_timescale == 0) {
3143  avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
3144  return 0;
3145  }
3146  *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
3147  global_timescale);
3148  return 1;
3149 }
3150 
3151 /**
3152  * Find the closest previous frame to the timestamp_pts, in e_old index
3153  * entries. Searching for just any frame / just key frames can be controlled by
3154  * last argument 'flag'.
3155  * Note that if ctts_data is not NULL, we will always search for a key frame
3156  * irrespective of the value of 'flag'. If we don't find any keyframe, we will
3157  * return the first frame of the video.
3158  *
3159  * Here the timestamp_pts is considered to be a presentation timestamp and
3160  * the timestamp of index entries are considered to be decoding timestamps.
3161  *
3162  * Returns 0 if successful in finding a frame, else returns -1.
3163  * Places the found index corresponding output arg.
3164  *
3165  * If ctts_old is not NULL, then refines the searched entry by searching
3166  * backwards from the found timestamp, to find the frame with correct PTS.
3167  *
3168  * Places the found ctts_index and ctts_sample in corresponding output args.
3169  */
3171  AVIndexEntry *e_old,
3172  int nb_old,
3173  MOVStts* ctts_data,
3174  int64_t ctts_count,
3175  int64_t timestamp_pts,
3176  int flag,
3177  int64_t* index,
3178  int64_t* ctts_index,
3179  int64_t* ctts_sample)
3180 {
3181  MOVStreamContext *msc = st->priv_data;
3182  AVIndexEntry *e_keep = st->index_entries;
3183  int nb_keep = st->nb_index_entries;
3184  int64_t i = 0;
3185  int64_t index_ctts_count;
3186 
3187  av_assert0(index);
3188 
3189  // If dts_shift > 0, then all the index timestamps will have to be offset by
3190  // at least dts_shift amount to obtain PTS.
3191  // Hence we decrement the searched timestamp_pts by dts_shift to find the closest index element.
3192  if (msc->dts_shift > 0) {
3193  timestamp_pts -= msc->dts_shift;
3194  }
3195 
3196  st->index_entries = e_old;
3197  st->nb_index_entries = nb_old;
3198  *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
3199 
3200  // Keep going backwards in the index entries until the timestamp is the same.
3201  if (*index >= 0) {
3202  for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
3203  i--) {
3204  if ((flag & AVSEEK_FLAG_ANY) ||
3205  (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
3206  *index = i - 1;
3207  }
3208  }
3209  }
3210 
3211  // If we have CTTS then refine the search, by searching backwards over PTS
3212  // computed by adding corresponding CTTS durations to index timestamps.
3213  if (ctts_data && *index >= 0) {
3214  av_assert0(ctts_index);
3215  av_assert0(ctts_sample);
3216  // Find out the ctts_index for the found frame.
3217  *ctts_index = 0;
3218  *ctts_sample = 0;
3219  for (index_ctts_count = 0; index_ctts_count < *index; index_ctts_count++) {
3220  if (*ctts_index < ctts_count) {
3221  (*ctts_sample)++;
3222  if (ctts_data[*ctts_index].count == *ctts_sample) {
3223  (*ctts_index)++;
3224  *ctts_sample = 0;
3225  }
3226  }
3227  }
3228 
3229  while (*index >= 0 && (*ctts_index) >= 0 && (*ctts_index) < ctts_count) {
3230  // Find a "key frame" with PTS <= timestamp_pts (So that we can decode B-frames correctly).
3231  // No need to add dts_shift to the timestamp here becase timestamp_pts has already been
3232  // compensated by dts_shift above.
3233  if ((e_old[*index].timestamp + ctts_data[*ctts_index].duration) <= timestamp_pts &&
3234  (e_old[*index].flags & AVINDEX_KEYFRAME)) {
3235  break;
3236  }
3237 
3238  (*index)--;
3239  if (*ctts_sample == 0) {
3240  (*ctts_index)--;
3241  if (*ctts_index >= 0)
3242  *ctts_sample = ctts_data[*ctts_index].count - 1;
3243  } else {
3244  (*ctts_sample)--;
3245  }
3246  }
3247  }
3248 
3249  /* restore AVStream state*/
3250  st->index_entries = e_keep;
3251  st->nb_index_entries = nb_keep;
3252  return *index >= 0 ? 0 : -1;
3253 }
3254 
3255 /**
3256  * Add index entry with the given values, to the end of st->index_entries.
3257  * Returns the new size st->index_entries if successful, else returns -1.
3258  *
3259  * This function is similar to ff_add_index_entry in libavformat/utils.c
3260  * except that here we are always unconditionally adding an index entry to
3261  * the end, instead of searching the entries list and skipping the add if
3262  * there is an existing entry with the same timestamp.
3263  * This is needed because the mov_fix_index calls this func with the same
3264  * unincremented timestamp for successive discarded frames.
3265  */
3266 static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
3267  int size, int distance, int flags)
3268 {
3269  AVIndexEntry *entries, *ie;
3270  int64_t index = -1;
3271  const size_t min_size_needed = (st->nb_index_entries + 1) * sizeof(AVIndexEntry);
3272 
3273  // Double the allocation each time, to lower memory fragmentation.
3274  // Another difference from ff_add_index_entry function.
3275  const size_t requested_size =
3276  min_size_needed > st->index_entries_allocated_size ?
3277  FFMAX(min_size_needed, 2 * st->index_entries_allocated_size) :
3278  min_size_needed;
3279 
3280  if (st->nb_index_entries + 1U >= UINT_MAX / sizeof(AVIndexEntry))
3281  return -1;
3282 
3283  entries = av_fast_realloc(st->index_entries,
3285  requested_size);
3286  if (!entries)
3287  return -1;
3288 
3289  st->index_entries= entries;
3290 
3291  index= st->nb_index_entries++;
3292  ie= &entries[index];
3293 
3294  ie->pos = pos;
3295  ie->timestamp = timestamp;
3296  ie->min_distance= distance;
3297  ie->size= size;
3298  ie->flags = flags;
3299  return index;
3300 }
3301 
3302 /**
3303  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3304  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
3305  */
3306 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
3307  int64_t* frame_duration_buffer,
3308  int frame_duration_buffer_size) {
3309  int i = 0;
3310  av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
3311  for (i = 0; i < frame_duration_buffer_size; i++) {
3312  end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
3313  st->index_entries[end_index - 1 - i].timestamp = end_ts;
3314  }
3315 }
3316 
3317 /**
3318  * Append a new ctts entry to ctts_data.
3319  * Returns the new ctts_count if successful, else returns -1.
3320  */
3321 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
3322  int count, int duration)
3323 {
3324  MOVStts *ctts_buf_new;
3325  const size_t min_size_needed = (*ctts_count + 1) * sizeof(MOVStts);
3326  const size_t requested_size =
3327  min_size_needed > *allocated_size ?
3328  FFMAX(min_size_needed, 2 * (*allocated_size)) :
3329  min_size_needed;
3330 
3331  if ((unsigned)(*ctts_count) >= UINT_MAX / sizeof(MOVStts) - 1)
3332  return -1;
3333 
3334  ctts_buf_new = av_fast_realloc(*ctts_data, allocated_size, requested_size);
3335 
3336  if (!ctts_buf_new)
3337  return -1;
3338 
3339  *ctts_data = ctts_buf_new;
3340 
3341  ctts_buf_new[*ctts_count].count = count;
3342  ctts_buf_new[*ctts_count].duration = duration;
3343 
3344  *ctts_count = (*ctts_count) + 1;
3345  return *ctts_count;
3346 }
3347 
3348 #define MAX_REORDER_DELAY 16
3350 {
3351  MOVStreamContext *msc = st->priv_data;
3352  int ind;
3353  int ctts_ind = 0;
3354  int ctts_sample = 0;
3355  int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
3356  int buf_start = 0;
3357  int j, r, num_swaps;
3358 
3359  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
3360  pts_buf[j] = INT64_MIN;
3361 
3362  if (st->codecpar->video_delay <= 0 && msc->ctts_data &&
3364  st->codecpar->video_delay = 0;
3365  for (ind = 0; ind < st->nb_index_entries && ctts_ind < msc->ctts_count; ++ind) {
3366  // Point j to the last elem of the buffer and insert the current pts there.
3367  j = buf_start;
3368  buf_start = (buf_start + 1);
3369  if (buf_start == MAX_REORDER_DELAY + 1)
3370  buf_start = 0;
3371 
3372  pts_buf[j] = st->index_entries[ind].timestamp + msc->ctts_data[ctts_ind].duration;
3373 
3374  // The timestamps that are already in the sorted buffer, and are greater than the
3375  // current pts, are exactly the timestamps that need to be buffered to output PTS
3376  // in correct sorted order.
3377  // Hence the video delay (which is the buffer size used to sort DTS and output PTS),
3378  // can be computed as the maximum no. of swaps any particular timestamp needs to
3379  // go through, to keep this buffer in sorted order.
3380  num_swaps = 0;
3381  while (j != buf_start) {
3382  r = j - 1;
3383  if (r < 0) r = MAX_REORDER_DELAY;
3384  if (pts_buf[j] < pts_buf[r]) {
3385  FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
3386  ++num_swaps;
3387  } else {
3388  break;
3389  }
3390  j = r;
3391  }
3392  st->codecpar->video_delay = FFMAX(st->codecpar->video_delay, num_swaps);
3393 
3394  ctts_sample++;
3395  if (ctts_sample == msc->ctts_data[ctts_ind].count) {
3396  ctts_ind++;
3397  ctts_sample = 0;
3398  }
3399  }
3400  av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
3401  st->codecpar->video_delay, st->index);
3402  }
3403 }
3404 
3406 {
3407  sc->current_sample++;
3408  sc->current_index++;
3409  if (sc->index_ranges &&
3410  sc->current_index >= sc->current_index_range->end &&
3411  sc->current_index_range->end) {
3412  sc->current_index_range++;
3414  }
3415 }
3416 
3418 {
3419  sc->current_sample--;
3420  sc->current_index--;
3421  if (sc->index_ranges &&
3423  sc->current_index_range > sc->index_ranges) {
3424  sc->current_index_range--;
3425  sc->current_index = sc->current_index_range->end - 1;
3426  }
3427 }
3428 
3429 static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
3430 {
3431  int64_t range_size;
3432 
3433  sc->current_sample = current_sample;
3434  sc->current_index = current_sample;
3435  if (!sc->index_ranges) {
3436  return;
3437  }
3438 
3439  for (sc->current_index_range = sc->index_ranges;
3440  sc->current_index_range->end;
3441  sc->current_index_range++) {
3442  range_size = sc->current_index_range->end - sc->current_index_range->start;
3443  if (range_size > current_sample) {
3444  sc->current_index = sc->current_index_range->start + current_sample;
3445  break;
3446  }
3447  current_sample -= range_size;
3448  }
3449 }
3450 
3451 /**
3452  * Fix st->index_entries, so that it contains only the entries (and the entries
3453  * which are needed to decode them) that fall in the edit list time ranges.
3454  * Also fixes the timestamps of the index entries to match the timeline
3455  * specified the edit lists.
3456  */
3457 static void mov_fix_index(MOVContext *mov, AVStream *st)
3458 {
3459  MOVStreamContext *msc = st->priv_data;
3460  AVIndexEntry *e_old = st->index_entries;
3461  int nb_old = st->nb_index_entries;
3462  const AVIndexEntry *e_old_end = e_old + nb_old;
3463  const AVIndexEntry *current = NULL;
3464  MOVStts *ctts_data_old = msc->ctts_data;
3465  int64_t ctts_index_old = 0;
3466  int64_t ctts_sample_old = 0;
3467  int64_t ctts_count_old = msc->ctts_count;
3468  int64_t edit_list_media_time = 0;
3469  int64_t edit_list_duration = 0;
3470  int64_t frame_duration = 0;
3471  int64_t edit_list_dts_counter = 0;
3472  int64_t edit_list_dts_entry_end = 0;
3473  int64_t edit_list_start_ctts_sample = 0;
3474  int64_t curr_cts;
3475  int64_t curr_ctts = 0;
3476  int64_t empty_edits_sum_duration = 0;
3477  int64_t edit_list_index = 0;
3478  int64_t index;
3479  int flags;
3480  int64_t start_dts = 0;
3481  int64_t edit_list_start_encountered = 0;
3482  int64_t search_timestamp = 0;
3483  int64_t* frame_duration_buffer = NULL;
3484  int num_discarded_begin = 0;
3485  int first_non_zero_audio_edit = -1;
3486  int packet_skip_samples = 0;
3487  MOVIndexRange *current_index_range;
3488  int i;
3489  int found_keyframe_after_edit = 0;
3490  int found_non_empty_edit = 0;
3491 
3492  if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
3493  return;
3494  }
3495 
3496  // allocate the index ranges array
3497  msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
3498  if (!msc->index_ranges) {
3499  av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
3500  return;
3501  }
3502  msc->current_index_range = msc->index_ranges;
3503  current_index_range = msc->index_ranges - 1;
3504 
3505  // Clean AVStream from traces of old index
3506  st->index_entries = NULL;
3508  st->nb_index_entries = 0;
3509 
3510  // Clean ctts fields of MOVStreamContext
3511  msc->ctts_data = NULL;
3512  msc->ctts_count = 0;
3513  msc->ctts_index = 0;
3514  msc->ctts_sample = 0;
3515  msc->ctts_allocated_size = 0;
3516 
3517  // Reinitialize min_corrected_pts so that it can be computed again.
3518  msc->min_corrected_pts = -1;
3519 
3520  // If the dts_shift is positive (in case of negative ctts values in mov),
3521  // then negate the DTS by dts_shift
3522  if (msc->dts_shift > 0) {
3523  edit_list_dts_entry_end -= msc->dts_shift;
3524  av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
3525  }
3526 
3527  start_dts = edit_list_dts_entry_end;
3528 
3529  while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
3530  &edit_list_duration, mov->time_scale)) {
3531  av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
3532  st->index, edit_list_index, edit_list_media_time, edit_list_duration);
3533  edit_list_index++;
3534  edit_list_dts_counter = edit_list_dts_entry_end;
3535  edit_list_dts_entry_end += edit_list_duration;
3536  num_discarded_begin = 0;
3537  if (!found_non_empty_edit && edit_list_media_time == -1) {
3538  empty_edits_sum_duration += edit_list_duration;
3539  continue;
3540  }
3541  found_non_empty_edit = 1;
3542 
3543  // If we encounter a non-negative edit list reset the skip_samples/start_pad fields and set them
3544  // according to the edit list below.
3545  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3546  if (first_non_zero_audio_edit < 0) {
3547  first_non_zero_audio_edit = 1;
3548  } else {
3549  first_non_zero_audio_edit = 0;
3550  }
3551 
3552  if (first_non_zero_audio_edit > 0)
3553  st->skip_samples = msc->start_pad = 0;
3554  }
3555 
3556  // While reordering frame index according to edit list we must handle properly
3557  // the scenario when edit list entry starts from none key frame.
3558  // We find closest previous key frame and preserve it and consequent frames in index.
3559  // All frames which are outside edit list entry time boundaries will be dropped after decoding.
3560  search_timestamp = edit_list_media_time;
3561  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3562  // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
3563  // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
3564  // edit_list_media_time to cover the decoder delay.
3565  search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
3566  }
3567 
3568  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, 0,
3569  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3570  av_log(mov->fc, AV_LOG_WARNING,
3571  "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
3572  st->index, edit_list_index, search_timestamp);
3573  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
3574  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3575  av_log(mov->fc, AV_LOG_WARNING,
3576  "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
3577  st->index, edit_list_index, search_timestamp);
3578  index = 0;
3579  ctts_index_old = 0;
3580  ctts_sample_old = 0;
3581  }
3582  }
3583  current = e_old + index;
3584  edit_list_start_ctts_sample = ctts_sample_old;
3585 
3586  // Iterate over index and arrange it according to edit list
3587  edit_list_start_encountered = 0;
3588  found_keyframe_after_edit = 0;
3589  for (; current < e_old_end; current++, index++) {
3590  // check if frame outside edit list mark it for discard
3591  frame_duration = (current + 1 < e_old_end) ?
3592  ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
3593 
3594  flags = current->flags;
3595 
3596  // frames (pts) before or after edit list
3597  curr_cts = current->timestamp + msc->dts_shift;
3598  curr_ctts = 0;
3599 
3600  if (ctts_data_old && ctts_index_old < ctts_count_old) {
3601  curr_ctts = ctts_data_old[ctts_index_old].duration;
3602  av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
3603  curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
3604  curr_cts += curr_ctts;
3605  ctts_sample_old++;
3606  if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
3607  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3608  &msc->ctts_allocated_size,
3609  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3610  ctts_data_old[ctts_index_old].duration) == -1) {
3611  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3612  ctts_index_old,
3613  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3614  ctts_data_old[ctts_index_old].duration);
3615  break;
3616  }
3617  ctts_index_old++;
3618  ctts_sample_old = 0;
3619  edit_list_start_ctts_sample = 0;
3620  }
3621  }
3622 
3623  if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3625  curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3626  first_non_zero_audio_edit > 0) {
3627  packet_skip_samples = edit_list_media_time - curr_cts;
3628  st->skip_samples += packet_skip_samples;
3629 
3630  // Shift the index entry timestamp by packet_skip_samples to be correct.
3631  edit_list_dts_counter -= packet_skip_samples;
3632  if (edit_list_start_encountered == 0) {
3633  edit_list_start_encountered = 1;
3634  // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
3635  // discarded packets.
3636  if (frame_duration_buffer) {
3637  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3638  frame_duration_buffer, num_discarded_begin);
3639  av_freep(&frame_duration_buffer);
3640  }
3641  }
3642 
3643  av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
3644  } else {
3645  flags |= AVINDEX_DISCARD_FRAME;
3646  av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
3647 
3648  if (edit_list_start_encountered == 0) {
3649  num_discarded_begin++;
3650  frame_duration_buffer = av_realloc(frame_duration_buffer,
3651  num_discarded_begin * sizeof(int64_t));
3652  if (!frame_duration_buffer) {
3653  av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
3654  break;
3655  }
3656  frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3657 
3658  // Increment skip_samples for the first non-zero audio edit list
3659  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3660  first_non_zero_audio_edit > 0 && st->codecpar->codec_id != AV_CODEC_ID_VORBIS) {
3661  st->skip_samples += frame_duration;
3662  }
3663  }
3664  }
3665  } else {
3666  if (msc->min_corrected_pts < 0) {
3667  msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
3668  } else {
3669  msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
3670  }
3671  if (edit_list_start_encountered == 0) {
3672  edit_list_start_encountered = 1;
3673  // Make timestamps strictly monotonically increasing by rewriting timestamps for
3674  // discarded packets.
3675  if (frame_duration_buffer) {
3676  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3677  frame_duration_buffer, num_discarded_begin);
3678  av_freep(&frame_duration_buffer);
3679  }
3680  }
3681  }
3682 
3683  if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
3684  current->min_distance, flags) == -1) {
3685  av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
3686  break;
3687  }
3688 
3689  // Update the index ranges array
3690  if (current_index_range < msc->index_ranges || index != current_index_range->end) {
3691  current_index_range++;
3692  current_index_range->start = index;
3693  }
3694  current_index_range->end = index + 1;
3695 
3696  // Only start incrementing DTS in frame_duration amounts, when we encounter a frame in edit list.
3697  if (edit_list_start_encountered > 0) {
3698  edit_list_dts_counter = edit_list_dts_counter + frame_duration;
3699  }
3700 
3701  // Break when found first key frame after edit entry completion
3702  if ((curr_cts + frame_duration >= (edit_list_duration + edit_list_media_time)) &&
3703  ((flags & AVINDEX_KEYFRAME) || ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)))) {
3704  if (ctts_data_old) {
3705  // If we have CTTS and this is the first keyframe after edit elist,
3706  // wait for one more, because there might be trailing B-frames after this I-frame
3707  // that do belong to the edit.
3708  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO && found_keyframe_after_edit == 0) {
3709  found_keyframe_after_edit = 1;
3710  continue;
3711  }
3712  if (ctts_sample_old != 0) {
3713  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3714  &msc->ctts_allocated_size,
3715  ctts_sample_old - edit_list_start_ctts_sample,
3716  ctts_data_old[ctts_index_old].duration) == -1) {
3717  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3718  ctts_index_old, ctts_sample_old - edit_list_start_ctts_sample,
3719  ctts_data_old[ctts_index_old].duration);
3720  break;
3721  }
3722  }
3723  }
3724  break;
3725  }
3726  }
3727  }
3728  // If there are empty edits, then msc->min_corrected_pts might be positive
3729  // intentionally. So we subtract the sum duration of emtpy edits here.
3730  msc->min_corrected_pts -= empty_edits_sum_duration;
3731 
3732  // If the minimum pts turns out to be greater than zero after fixing the index, then we subtract the
3733  // dts by that amount to make the first pts zero.
3734  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3735  if (msc->min_corrected_pts > 0) {
3736  av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by %"PRId64" to make first pts zero.\n", msc->min_corrected_pts);
3737  for (i = 0; i < st->nb_index_entries; ++i) {
3739  }
3740  }
3741  }
3742  // Start time should be equal to zero or the duration of any empty edits.
3743  st->start_time = empty_edits_sum_duration;
3744 
3745  // Update av stream length, if it ends up shorter than the track's media duration
3746  st->duration = FFMIN(st->duration, edit_list_dts_entry_end - start_dts);
3747  msc->start_pad = st->skip_samples;
3748 
3749  // Free the old index and the old CTTS structures
3750  av_free(e_old);
3751  av_free(ctts_data_old);
3752  av_freep(&frame_duration_buffer);
3753 
3754  // Null terminate the index ranges array
3755  current_index_range++;
3756  current_index_range->start = 0;
3757  current_index_range->end = 0;
3758  msc->current_index = msc->index_ranges[0].start;
3759 }
3760 
3761 static void mov_build_index(MOVContext *mov, AVStream *st)
3762 {
3763  MOVStreamContext *sc = st->priv_data;
3764  int64_t current_offset;
3765  int64_t current_dts = 0;
3766  unsigned int stts_index = 0;
3767  unsigned int stsc_index = 0;
3768  unsigned int stss_index = 0;
3769  unsigned int stps_index = 0;
3770  unsigned int i, j;
3771  uint64_t stream_size = 0;
3772  MOVStts *ctts_data_old = sc->ctts_data;
3773  unsigned int ctts_count_old = sc->ctts_count;
3774 
3775  if (sc->elst_count) {
3776  int i, edit_start_index = 0, multiple_edits = 0;
3777  int64_t empty_duration = 0; // empty duration of the first edit list entry
3778  int64_t start_time = 0; // start time of the media
3779 
3780  for (i = 0; i < sc->elst_count; i++) {
3781  const MOVElst *e = &sc->elst_data[i];
3782  if (i == 0 && e->time == -1) {
3783  /* if empty, the first entry is the start time of the stream
3784  * relative to the presentation itself */
3785  empty_duration = e->duration;
3786  edit_start_index = 1;
3787  } else if (i == edit_start_index && e->time >= 0) {
3788  start_time = e->time;
3789  } else {
3790  multiple_edits = 1;
3791  }
3792  }
3793 
3794  if (multiple_edits && !mov->advanced_editlist)
3795  av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
3796  "Use -advanced_editlist to correctly decode otherwise "
3797  "a/v desync might occur\n");
3798 
3799  /* adjust first dts according to edit list */
3800  if ((empty_duration || start_time) && mov->time_scale > 0) {
3801  if (empty_duration)
3802  empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
3803  sc->time_offset = start_time - empty_duration;
3805  if (!mov->advanced_editlist)
3806  current_dts = -sc->time_offset;
3807  }
3808 
3809  if (!multiple_edits && !mov->advanced_editlist &&
3810  st->codecpar->codec_id == AV_CODEC_ID_AAC && start_time > 0)
3811  sc->start_pad = start_time;
3812  }
3813 
3814  /* only use old uncompressed audio chunk demuxing when stts specifies it */
3815  if (!(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3816  sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
3817  unsigned int current_sample = 0;
3818  unsigned int stts_sample = 0;
3819  unsigned int sample_size;
3820  unsigned int distance = 0;
3821  unsigned int rap_group_index = 0;
3822  unsigned int rap_group_sample = 0;
3823  int64_t last_dts = 0;
3824  int64_t dts_correction = 0;
3825  int rap_group_present = sc->rap_group_count && sc->rap_group;
3826  int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
3827 
3828  current_dts -= sc->dts_shift;
3829  last_dts = current_dts;
3830 
3831  if (!sc->sample_count || st->nb_index_entries)
3832  return;
3833  if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
3834  return;
3836  st->nb_index_entries + sc->sample_count,
3837  sizeof(*st->index_entries)) < 0) {
3838  st->nb_index_entries = 0;
3839  return;
3840  }
3842 
3843  if (ctts_data_old) {
3844  // Expand ctts entries such that we have a 1-1 mapping with samples
3845  if (sc->sample_count >= UINT_MAX / sizeof(*sc->ctts_data))
3846  return;
3847  sc->ctts_count = 0;
3848  sc->ctts_allocated_size = 0;
3850  sc->sample_count * sizeof(*sc->ctts_data));
3851  if (!sc->ctts_data) {
3852  av_free(ctts_data_old);
3853  return;
3854  }
3855 
3856  memset((uint8_t*)(sc->ctts_data), 0, sc->ctts_allocated_size);
3857 
3858  for (i = 0; i < ctts_count_old &&
3859  sc->ctts_count < sc->sample_count; i++)
3860  for (j = 0; j < ctts_data_old[i].count &&
3861  sc->ctts_count < sc->sample_count; j++)
3862  add_ctts_entry(&sc->ctts_data, &sc->ctts_count,
3863  &sc->ctts_allocated_size, 1,
3864  ctts_data_old[i].duration);
3865  av_free(ctts_data_old);
3866  }
3867 
3868  for (i = 0; i < sc->chunk_count; i++) {
3869  int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
3870  current_offset = sc->chunk_offsets[i];
3871  while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
3872  i + 1 == sc->stsc_data[stsc_index + 1].first)
3873  stsc_index++;
3874 
3875  if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
3876  sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
3877  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
3878  sc->stsz_sample_size = sc->sample_size;
3879  }
3880  if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
3881  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
3882  sc->stsz_sample_size = sc->sample_size;
3883  }
3884 
3885  for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
3886  int keyframe = 0;
3887  if (current_sample >= sc->sample_count) {
3888  av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
3889  return;
3890  }
3891 
3892  if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
3893  keyframe = 1;
3894  if (stss_index + 1 < sc->keyframe_count)
3895  stss_index++;
3896  } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
3897  keyframe = 1;
3898  if (stps_index + 1 < sc->stps_count)
3899  stps_index++;
3900  }
3901  if (rap_group_present && rap_group_index < sc->rap_group_count) {
3902  if (sc->rap_group[rap_group_index].index > 0)
3903  keyframe = 1;
3904  if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
3905  rap_group_sample = 0;
3906  rap_group_index++;
3907  }
3908  }
3909  if (sc->keyframe_absent
3910  && !sc->stps_count
3911  && !rap_group_present
3912  && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
3913  keyframe = 1;
3914  if (keyframe)
3915  distance = 0;
3916  sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
3917  if (sc->pseudo_stream_id == -1 ||
3918  sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
3919  AVIndexEntry *e;
3920  if (sample_size > 0x3FFFFFFF) {
3921  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", sample_size);
3922  return;
3923  }
3924  e = &st->index_entries[st->nb_index_entries++];
3925  e->pos = current_offset;
3926  e->timestamp = current_dts;
3927  e->size = sample_size;
3928  e->min_distance = distance;
3929  e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
3930  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
3931  "size %u, distance %u, keyframe %d\n", st->index, current_sample,
3932  current_offset, current_dts, sample_size, distance, keyframe);
3933  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
3934  ff_rfps_add_frame(mov->fc, st, current_dts);
3935  }
3936 
3937  current_offset += sample_size;
3938  stream_size += sample_size;
3939 
3940  /* A negative sample duration is invalid based on the spec,
3941  * but some samples need it to correct the DTS. */
3942  if (sc->stts_data[stts_index].duration < 0) {
3943  av_log(mov->fc, AV_LOG_WARNING,
3944  "Invalid SampleDelta %d in STTS, at %d st:%d\n",
3945  sc->stts_data[stts_index].duration, stts_index,
3946  st->index);
3947  dts_correction += sc->stts_data[stts_index].duration - 1;
3948  sc->stts_data[stts_index].duration = 1;
3949  }
3950  current_dts += sc->stts_data[stts_index].duration;
3951  if (!dts_correction || current_dts + dts_correction > last_dts) {
3952  current_dts += dts_correction;
3953  dts_correction = 0;
3954  } else {
3955  /* Avoid creating non-monotonous DTS */
3956  dts_correction += current_dts - last_dts - 1;
3957  current_dts = last_dts + 1;
3958  }
3959  last_dts = current_dts;
3960  distance++;
3961  stts_sample++;
3962  current_sample++;
3963  if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
3964  stts_sample = 0;
3965  stts_index++;
3966  }
3967  }
3968  }
3969  if (st->duration > 0)
3970  st->codecpar->bit_rate = stream_size*8*sc->time_scale/st->duration;
3971  } else {
3972  unsigned chunk_samples, total = 0;
3973 
3974  if (!sc->chunk_count)
3975  return;
3976 
3977  // compute total chunk count
3978  for (i = 0; i < sc->stsc_count; i++) {
3979  unsigned count, chunk_count;
3980 
3981  chunk_samples = sc->stsc_data[i].count;
3982  if (i != sc->stsc_count - 1 &&
3983  sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
3984  av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
3985  return;
3986  }
3987 
3988  if (sc->samples_per_frame >= 160) { // gsm
3989  count = chunk_samples / sc->samples_per_frame;
3990  } else if (sc->samples_per_frame > 1) {
3991  unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
3992  count = (chunk_samples+samples-1) / samples;
3993  } else {
3994  count = (chunk_samples+1023) / 1024;
3995  }
3996 
3997  if (mov_stsc_index_valid(i, sc->stsc_count))
3998  chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
3999  else
4000  chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
4001  total += chunk_count * count;
4002  }
4003 
4004  av_log(mov->fc, AV_LOG_TRACE, "chunk count %u\n", total);
4005  if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
4006  return;
4008  st->nb_index_entries + total,
4009  sizeof(*st->index_entries)) < 0) {
4010  st->nb_index_entries = 0;
4011  return;
4012  }
4013  st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
4014 
4015  // populate index
4016  for (i = 0; i < sc->chunk_count; i++) {
4017  current_offset = sc->chunk_offsets[i];
4018  if (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
4019  i + 1 == sc->stsc_data[stsc_index + 1].first)
4020  stsc_index++;
4021  chunk_samples = sc->stsc_data[stsc_index].count;
4022 
4023  while (chunk_samples > 0) {
4024  AVIndexEntry *e;
4025  unsigned size, samples;
4026 
4027  if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
4029  "Zero bytes per frame, but %d samples per frame",
4030  sc->samples_per_frame);
4031  return;
4032  }
4033 
4034  if (sc->samples_per_frame >= 160) { // gsm
4035  samples = sc->samples_per_frame;
4036  size = sc->bytes_per_frame;
4037  } else {
4038  if (sc->samples_per_frame > 1) {
4039  samples = FFMIN((1024 / sc->samples_per_frame)*
4040  sc->samples_per_frame, chunk_samples);
4041  size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
4042  } else {
4043  samples = FFMIN(1024, chunk_samples);
4044  size = samples * sc->sample_size;
4045  }
4046  }
4047 
4048  if (st->nb_index_entries >= total) {
4049  av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %u\n", total);
4050  return;
4051  }
4052  if (size > 0x3FFFFFFF) {
4053  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", size);
4054  return;
4055  }
4056  e = &st->index_entries[st->nb_index_entries++];
4057  e->pos = current_offset;
4058  e->timestamp = current_dts;
4059  e->size = size;
4060  e->min_distance = 0;
4061  e->flags = AVINDEX_KEYFRAME;
4062  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
4063  "size %u, duration %u\n", st->index, i, current_offset, current_dts,
4064  size, samples);
4065 
4066  current_offset += size;
4067  current_dts += samples;
4068  chunk_samples -= samples;
4069  }
4070  }
4071  }
4072 
4073  if (!mov->ignore_editlist && mov->advanced_editlist) {
4074  // Fix index according to edit lists.
4075  mov_fix_index(mov, st);
4076  }
4077 
4078  // Update start time of the stream.
4080  st->start_time = st->index_entries[0].timestamp + sc->dts_shift;
4081  if (sc->ctts_data) {
4082  st->start_time += sc->ctts_data[0].duration;
4083  }
4084  }
4085 
4086  mov_estimate_video_delay(mov, st);
4087 }
4088 
4089 static int test_same_origin(const char *src, const char *ref) {
4090  char src_proto[64];
4091  char ref_proto[64];
4092  char src_auth[256];
4093  char ref_auth[256];
4094  char src_host[256];
4095  char ref_host[256];
4096  int src_port=-1;
4097  int ref_port=-1;
4098 
4099  av_url_split(src_proto, sizeof(src_proto), src_auth, sizeof(src_auth), src_host, sizeof(src_host), &src_port, NULL, 0, src);
4100  av_url_split(ref_proto, sizeof(ref_proto), ref_auth, sizeof(ref_auth), ref_host, sizeof(ref_host), &ref_port, NULL, 0, ref);
4101 
4102  if (strlen(src) == 0) {
4103  return -1;
4104  } else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
4105  strlen(ref_auth) + 1 >= sizeof(ref_auth) ||
4106  strlen(src_host) + 1 >= sizeof(src_host) ||
4107  strlen(ref_host) + 1 >= sizeof(ref_host)) {
4108  return 0;
4109  } else if (strcmp(src_proto, ref_proto) ||
4110  strcmp(src_auth, ref_auth) ||
4111  strcmp(src_host, ref_host) ||
4112  src_port != ref_port) {
4113  return 0;
4114  } else
4115  return 1;
4116 }
4117 
4118 static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
4119 {
4120  /* try relative path, we do not try the absolute because it can leak information about our
4121  system to an attacker */
4122  if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
4123  char filename[1025];
4124  const char *src_path;
4125  int i, l;
4126 
4127  /* find a source dir */
4128  src_path = strrchr(src, '/');
4129  if (src_path)
4130  src_path++;
4131  else
4132  src_path = src;
4133 
4134  /* find a next level down to target */
4135  for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
4136  if (ref->path[l] == '/') {
4137  if (i == ref->nlvl_to - 1)
4138  break;
4139  else
4140  i++;
4141  }
4142 
4143  /* compose filename if next level down to target was found */
4144  if (i == ref->nlvl_to - 1 && src_path - src < sizeof(filename)) {
4145  memcpy(filename, src, src_path - src);
4146  filename[src_path - src] = 0;
4147 
4148  for (i = 1; i < ref->nlvl_from; i++)
4149  av_strlcat(filename, "../", sizeof(filename));
4150 
4151  av_strlcat(filename, ref->path + l + 1, sizeof(filename));
4152  if (!c->use_absolute_path) {
4153  int same_origin = test_same_origin(src, filename);
4154 
4155  if (!same_origin) {
4156  av_log(c->fc, AV_LOG_ERROR,
4157  "Reference with mismatching origin, %s not tried for security reasons, "
4158  "set demuxer option use_absolute_path to allow it anyway\n",
4159  ref->path);
4160  return AVERROR(ENOENT);
4161  }
4162 
4163  if (strstr(ref->path + l + 1, "..") ||
4164  strstr(ref->path + l + 1, ":") ||
4165  (ref->nlvl_from > 1 && same_origin < 0) ||
4166  (filename[0] == '/' && src_path == src))
4167  return AVERROR(ENOENT);
4168  }
4169 
4170  if (strlen(filename) + 1 == sizeof(filename))
4171  return AVERROR(ENOENT);
4172  if (!c->fc->io_open(c->fc, pb, filename, AVIO_FLAG_READ, NULL))
4173  return 0;
4174  }
4175  } else if (c->use_absolute_path) {
4176  av_log(c->fc, AV_LOG_WARNING, "Using absolute path on user request, "
4177  "this is a possible security issue\n");
4178  if (!c->fc->io_open(c->fc, pb, ref->path, AVIO_FLAG_READ, NULL))
4179  return 0;
4180  } else {
4181  av_log(c->fc, AV_LOG_ERROR,
4182  "Absolute path %s not tried for security reasons, "
4183  "set demuxer option use_absolute_path to allow absolute paths\n",
4184  ref->path);
4185  }
4186 
4187  return AVERROR(ENOENT);
4188 }
4189 
4191 {
4192  if (sc->time_scale <= 0) {
4193  av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
4194  sc->time_scale = c->time_scale;
4195  if (sc->time_scale <= 0)
4196  sc->time_scale = 1;
4197  }
4198 }
4199 
4201 {
4202  AVStream *st;
4203  MOVStreamContext *sc;
4204  int ret;
4205 
4206  st = avformat_new_stream(c->fc, NULL);
4207  if (!st) return AVERROR(ENOMEM);
4208  st->id = -1;
4209  sc = av_mallocz(sizeof(MOVStreamContext));
4210  if (!sc) return AVERROR(ENOMEM);
4211 
4212  st->priv_data = sc;
4214  sc->ffindex = st->index;
4215  c->trak_index = st->index;
4216 
4217  if ((ret = mov_read_default(c, pb, atom)) < 0)
4218  return ret;
4219 
4220  c->trak_index = -1;
4221 
4222  // Here stsc refers to a chunk not described in stco. This is technically invalid,
4223  // but we can overlook it (clearing stsc) whenever stts_count == 0 (indicating no samples).
4224  if (!sc->chunk_count && !sc->stts_count && sc->stsc_count) {
4225  sc->stsc_count = 0;
4226  av_freep(&sc->stsc_data);
4227  }
4228 
4229  /* sanity checks */
4230  if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
4231  (!sc->sample_size && !sc->sample_count))) ||
4232  (!sc->chunk_count && sc->sample_count)) {
4233  av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
4234  st->index);
4235  return 0;
4236  }
4237  if (sc->stsc_count && sc->stsc_data[ sc->stsc_count - 1 ].first > sc->chunk_count) {
4238  av_log(c->fc, AV_LOG_ERROR, "stream %d, contradictionary STSC and STCO\n",
4239  st->index);
4240  return AVERROR_INVALIDDATA;
4241  }
4242 
4243  fix_timescale(c, sc);
4244 
4245  avpriv_set_pts_info(st, 64, 1, sc->time_scale);
4246 
4247  mov_build_index(c, st);
4248 
4249  if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
4250  MOVDref *dref = &sc->drefs[sc->dref_id - 1];
4251  if (c->enable_drefs) {
4252  if (mov_open_dref(c, &sc->pb, c->fc->url, dref) < 0)
4253  av_log(c->fc, AV_LOG_ERROR,
4254  "stream %d, error opening alias: path='%s', dir='%s', "
4255  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
4256  st->index, dref->path, dref->dir, dref->filename,
4257  dref->volume, dref->nlvl_from, dref->nlvl_to);
4258  } else {
4259  av_log(c->fc, AV_LOG_WARNING,
4260  "Skipped opening external track: "
4261  "stream %d, alias: path='%s', dir='%s', "
4262  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
4263  "Set enable_drefs to allow this.\n",
4264  st->index, dref->path, dref->dir, dref->filename,
4265  dref->volume, dref->nlvl_from, dref->nlvl_to);
4266  }
4267  } else {
4268  sc->pb = c->fc->pb;
4269  sc->pb_is_copied = 1;
4270  }
4271 
4272  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
4273  if (!st->sample_aspect_ratio.num && st->codecpar->width && st->codecpar->height &&
4274  sc->height && sc->width &&
4275  (st->codecpar->width != sc->width || st->codecpar->height != sc->height)) {
4276  st->sample_aspect_ratio = av_d2q(((double)st->codecpar->height * sc->width) /
4277  ((double)st->codecpar->width * sc->height), INT_MAX);
4278  }
4279 
4280 #if FF_API_R_FRAME_RATE
4281  if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
4283  sc->time_scale, sc->stts_data[0].duration, INT_MAX);
4284 #endif
4285  }
4286 
4287  // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
4288  if (!st->codecpar->extradata_size && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
4289  TAG_IS_AVCI(st->codecpar->codec_tag)) {
4290  ret = ff_generate_avci_extradata(st);
4291  if (ret < 0)
4292  return ret;
4293  }
4294 
4295  switch (st->codecpar->codec_id) {
4296 #if CONFIG_H261_DECODER
4297  case AV_CODEC_ID_H261:
4298 #endif
4299 #if CONFIG_H263_DECODER
4300  case AV_CODEC_ID_H263:
4301 #endif
4302 #if CONFIG_MPEG4_DECODER
4303  case AV_CODEC_ID_MPEG4:
4304 #endif
4305  st->codecpar->width = 0; /* let decoder init width/height */
4306  st->codecpar->height= 0;
4307  break;
4308  }
4309 
4310  // If the duration of the mp3 packets is not constant, then they could need a parser
4311  if (st->codecpar->codec_id == AV_CODEC_ID_MP3
4312  && sc->stts_count > 3
4313  && sc->stts_count*10 > st->nb_frames
4314  && sc->time_scale == st->codecpar->sample_rate) {
4316  }
4317  /* Do not need those anymore. */
4318  av_freep(&sc->chunk_offsets);
4319  av_freep(&sc->sample_sizes);
4320  av_freep(&sc->keyframes);
4321  av_freep(&sc->stts_data);
4322  av_freep(&sc->stps_data);
4323  av_freep(&sc->elst_data);
4324  av_freep(&sc->rap_group);
4325 
4326  return 0;
4327 }
4328 
4330 {
4331  int ret;
4332  c->itunes_metadata = 1;
4333  ret = mov_read_default(c, pb, atom);
4334  c->itunes_metadata = 0;
4335  return ret;
4336 }
4337 
4339 {
4340  uint32_t count;
4341  uint32_t i;
4342 
4343  if (atom.size < 8)
4344  return 0;
4345 
4346  avio_skip(pb, 4);
4347  count = avio_rb32(pb);
4348  if (count > UINT_MAX / sizeof(*c->meta_keys) - 1) {
4349  av_log(c->fc, AV_LOG_ERROR,
4350  "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
4351  return AVERROR_INVALIDDATA;
4352  }
4353 
4354  c->meta_keys_count = count + 1;
4355  c->meta_keys = av_mallocz(c->meta_keys_count * sizeof(*c->meta_keys));
4356  if (!c->meta_keys)
4357  return AVERROR(ENOMEM);
4358 
4359  for (i = 1; i <= count; ++i) {
4360  uint32_t key_size = avio_rb32(pb);
4361  uint32_t type = avio_rl32(pb);
4362  if (key_size < 8) {
4363  av_log(c->fc, AV_LOG_ERROR,
4364  "The key# %"PRIu32" in meta has invalid size:"
4365  "%"PRIu32"\n", i, key_size);
4366  return AVERROR_INVALIDDATA;
4367  }
4368  key_size -= 8;
4369  if (type != MKTAG('m','d','t','a')) {
4370  avio_skip(pb, key_size);
4371  }
4372  c->meta_keys[i] = av_mallocz(key_size + 1);
4373  if (!c->meta_keys[i])
4374  return AVERROR(ENOMEM);
4375  avio_read(pb, c->meta_keys[i], key_size);
4376  }
4377 
4378  return 0;
4379 }
4380 
4382 {
4383  int64_t end = avio_tell(pb) + atom.size;
4384  uint8_t *key = NULL, *val = NULL, *mean = NULL;
4385  int i;
4386  int ret = 0;
4387  AVStream *st;
4388  MOVStreamContext *sc;
4389 
4390  if (c->fc->nb_streams < 1)
4391  return 0;
4392  st = c->fc->streams[c->fc->nb_streams-1];
4393  sc = st->priv_data;
4394 
4395  for (i = 0; i < 3; i++) {
4396  uint8_t **p;
4397  uint32_t len, tag;
4398 
4399  if (end - avio_tell(pb) <= 12)
4400  break;
4401 
4402  len = avio_rb32(pb);
4403  tag = avio_rl32(pb);
4404  avio_skip(pb, 4); // flags
4405 
4406  if (len < 12 || len - 12 > end - avio_tell(pb))
4407  break;
4408  len -= 12;
4409 
4410  if (tag == MKTAG('m', 'e', 'a', 'n'))
4411  p = &mean;
4412  else if (tag == MKTAG('n', 'a', 'm', 'e'))
4413  p = &key;
4414  else if (tag == MKTAG('d', 'a', 't', 'a') && len > 4) {
4415  avio_skip(pb, 4);
4416  len -= 4;
4417  p = &val;
4418  } else
4419  break;
4420 
4421  if (*p)
4422  break;
4423 
4424  *p = av_malloc(len + 1);
4425  if (!*p) {
4426  ret = AVERROR(ENOMEM);
4427  break;
4428  }
4429  ret = ffio_read_size(pb, *p, len);
4430  if (ret < 0) {
4431  av_freep(p);
4432  break;
4433  }
4434  (*p)[len] = 0;
4435  }
4436 
4437  if (mean && key && val) {
4438  if (strcmp(key, "iTunSMPB") == 0) {
4439  int priming, remainder, samples;
4440  if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
4441  if(priming>0 && priming<16384)
4442  sc->start_pad = priming;
4443  }
4444  }
4445  if (strcmp(key, "cdec") != 0) {
4446  av_dict_set(&c->fc->metadata, key, val,
4448  key = val = NULL;
4449  }
4450  } else {
4451  av_log(c->fc, AV_LOG_VERBOSE,
4452  "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
4453  }
4454 
4455  avio_seek(pb, end, SEEK_SET);
4456  av_freep(&key);
4457  av_freep(&val);
4458  av_freep(&mean);
4459  return ret;
4460 }
4461 
4463 {
4464  while (atom.size > 8) {
4465  uint32_t tag;
4466  if (avio_feof(pb))
4467  return AVERROR_EOF;
4468  tag = avio_rl32(pb);
4469  atom.size -= 4;
4470  if (tag == MKTAG('h','d','l','r')) {
4471  avio_seek(pb, -8, SEEK_CUR);
4472  atom.size += 8;
4473  return mov_read_default(c, pb, atom);
4474  }
4475  }
4476  return 0;
4477 }
4478 
4479 // return 1 when matrix is identity, 0 otherwise
4480 #define IS_MATRIX_IDENT(matrix) \
4481  ( (matrix)[0][0] == (1 << 16) && \
4482  (matrix)[1][1] == (1 << 16) && \
4483  (matrix)[2][2] == (1 << 30) && \
4484  !(matrix)[0][1] && !(matrix)[0][2] && \
4485  !(matrix)[1][0] && !(matrix)[1][2] && \
4486  !(matrix)[2][0] && !(matrix)[2][1])
4487 
4489 {
4490  int i, j, e;
4491  int width;
4492  int height;
4493  int display_matrix[3][3];
4494  int res_display_matrix[3][3] = { { 0 } };
4495  AVStream *st;
4496  MOVStreamContext *sc;
4497  int version;
4498  int flags;
4499 
4500  if (c->fc->nb_streams < 1)
4501  return 0;
4502  st = c->fc->streams[c->fc->nb_streams-1];
4503  sc = st->priv_data;
4504 
4505  // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
4506  // avoids corrupting AVStreams mapped to an earlier tkhd.
4507  if (st->id != -1)
4508  return AVERROR_INVALIDDATA;
4509 
4510  version = avio_r8(pb);
4511  flags = avio_rb24(pb);
4513 
4514  if (version == 1) {
4515  avio_rb64(pb);
4516  avio_rb64(pb);
4517  } else {
4518  avio_rb32(pb); /* creation time */
4519  avio_rb32(pb); /* modification time */
4520  }
4521  st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
4522  avio_rb32(pb); /* reserved */
4523 
4524  /* highlevel (considering edits) duration in movie timebase */
4525  (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
4526  avio_rb32(pb); /* reserved */
4527  avio_rb32(pb); /* reserved */
4528 
4529  avio_rb16(pb); /* layer */
4530  avio_rb16(pb); /* alternate group */
4531  avio_rb16(pb); /* volume */
4532  avio_rb16(pb); /* reserved */
4533 
4534  //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
4535  // they're kept in fixed point format through all calculations
4536  // save u,v,z to store the whole matrix in the AV_PKT_DATA_DISPLAYMATRIX
4537  // side data, but the scale factor is not needed to calculate aspect ratio
4538  for (i = 0; i < 3; i++) {
4539  display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
4540  display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
4541  display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
4542  }
4543 
4544  width = avio_rb32(pb); // 16.16 fixed point track width
4545  height = avio_rb32(pb); // 16.16 fixed point track height
4546  sc->width = width >> 16;
4547  sc->height = height >> 16;
4548 
4549  // apply the moov display matrix (after the tkhd one)
4550  for (i = 0; i < 3; i++) {
4551  const int sh[3] = { 16, 16, 30 };
4552  for (j = 0; j < 3; j++) {
4553  for (e = 0; e < 3; e++) {
4554  res_display_matrix[i][j] +=
4555  ((int64_t) display_matrix[i][e] *
4556  c->movie_display_matrix[e][j]) >> sh[e];
4557  }
4558  }
4559  }
4560 
4561  // save the matrix when it is not the default identity
4562  if (!IS_MATRIX_IDENT(res_display_matrix)) {
4563  double rotate;
4564 
4565  av_freep(&sc->display_matrix);
4566  sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
4567  if (!sc->display_matrix)
4568  return AVERROR(ENOMEM);
4569 
4570  for (i = 0; i < 3; i++)
4571  for (j = 0; j < 3; j++)
4572  sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
4573 
4576  if (!isnan(rotate)) {
4577  char rotate_buf[64];
4578  rotate = -rotate;
4579  if (rotate < 0) // for backward compatibility
4580  rotate += 360;
4581  snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
4582  av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
4583  }
4584 #endif
4585  }
4586 
4587  // transform the display width/height according to the matrix
4588  // to keep the same scale, use [width height 1<<16]
4589  if (width && height && sc->display_matrix) {
4590  double disp_transform[2];
4591 
4592  for (i = 0; i < 2; i++)
4593  disp_transform[i] = hypot(sc->display_matrix[0 + i],
4594  sc->display_matrix[3 + i]);
4595 
4596  if (disp_transform[0] > 0 && disp_transform[1] > 0 &&
4597  disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4598  fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4600  disp_transform[0] / disp_transform[1],
4601  INT_MAX);
4602  }
4603  return 0;
4604 }
4605 
4607 {
4608  MOVFragment *frag = &c->fragment;
4609  MOVTrackExt *trex = NULL;
4610  int flags, track_id, i;
4611  MOVFragmentStreamInfo * frag_stream_info;
4612 
4613  avio_r8(pb); /* version */
4614  flags = avio_rb24(pb);
4615 
4616  track_id = avio_rb32(pb);
4617  if (!track_id)
4618  return AVERROR_INVALIDDATA;
4619  for (i = 0; i < c->trex_count; i++)
4620  if (c->trex_data[i].track_id == track_id) {
4621  trex = &c->trex_data[i];
4622  break;
4623  }
4624  if (!trex) {
4625  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding trex (id %u)\n", track_id);
4626  return 0;
4627  }
4628  c->fragment.found_tfhd = 1;
4629  frag->track_id = track_id;
4630  set_frag_stream(&c->frag_index, track_id);
4631 
4634  frag->moof_offset : frag->implicit_offset;
4635  frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
4636 
4637  frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
4638  avio_rb32(pb) : trex->duration;
4639  frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
4640  avio_rb32(pb) : trex->size;
4641  frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
4642  avio_rb32(pb) : trex->flags;
4643  av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
4644 
4645  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4646  if (frag_stream_info)
4647  frag_stream_info->next_trun_dts = AV_NOPTS_VALUE;
4648 
4649  return 0;
4650 }
4651 
4653 {
4654  unsigned i, num;
4655  void *new_tracks;
4656 
4657  num = atom.size / 4;
4658  if (!(new_tracks = av_malloc_array(num, sizeof(int))))
4659  return AVERROR(ENOMEM);
4660 
4661  av_free(c->chapter_tracks);
4662  c->chapter_tracks = new_tracks;
4663  c->nb_chapter_tracks = num;
4664 
4665  for (i = 0; i < num && !pb->eof_reached; i++)
4666  c->chapter_tracks[i] = avio_rb32(pb);
4667 
4668  return 0;
4669 }
4670 
4672 {
4673  MOVTrackExt *trex;
4674  int err;
4675 
4676  if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
4677  return AVERROR_INVALIDDATA;
4678  if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
4679  sizeof(*c->trex_data))) < 0) {
4680  c->trex_count = 0;
4681  return err;
4682  }
4683 
4684  c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
4685 
4686  trex = &c->trex_data[c->trex_count++];