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