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