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