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", comp_brands_str, 0);
1133  av_freep(&comp_brands_str);
1134 
1135  return 0;
1136 }
1137 
1138 /* this atom should contain all header atoms */
1140 {
1141  int ret;
1142 
1143  if (c->found_moov) {
1144  av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
1145  avio_skip(pb, atom.size);
1146  return 0;
1147  }
1148 
1149  if ((ret = mov_read_default(c, pb, atom)) < 0)
1150  return ret;
1151  /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
1152  /* so we don't parse the whole file if over a network */
1153  c->found_moov=1;
1154  return 0; /* now go for mdat */
1155 }
1156 
1158  MOVFragmentIndex *frag_index,
1159  int index,
1160  int id)
1161 {
1162  int i;
1163  MOVFragmentIndexItem * item;
1164 
1165  if (index < 0 || index >= frag_index->nb_items)
1166  return NULL;
1167  item = &frag_index->item[index];
1168  for (i = 0; i < item->nb_stream_info; i++)
1169  if (item->stream_info[i].id == id)
1170  return &item->stream_info[i];
1171 
1172  // This shouldn't happen
1173  return NULL;
1174 }
1175 
1176 static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
1177 {
1178  int i;
1179  MOVFragmentIndexItem * item;
1180 
1181  if (frag_index->current < 0 ||
1182  frag_index->current >= frag_index->nb_items)
1183  return;
1184 
1185  item = &frag_index->item[frag_index->current];
1186  for (i = 0; i < item->nb_stream_info; i++)
1187  if (item->stream_info[i].id == id) {
1188  item->current = i;
1189  return;
1190  }
1191 
1192  // id not found. This shouldn't happen.
1193  item->current = -1;
1194 }
1195 
1197  MOVFragmentIndex *frag_index)
1198 {
1199  MOVFragmentIndexItem *item;
1200  if (frag_index->current < 0 ||
1201  frag_index->current >= frag_index->nb_items)
1202  return NULL;
1203 
1204  item = &frag_index->item[frag_index->current];
1205  if (item->current >= 0 && item->current < item->nb_stream_info)
1206  return &item->stream_info[item->current];
1207 
1208  // This shouldn't happen
1209  return NULL;
1210 }
1211 
1212 static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
1213 {
1214  int a, b, m;
1215  int64_t moof_offset;
1216 
1217  // Optimize for appending new entries
1218  if (!frag_index->nb_items ||
1219  frag_index->item[frag_index->nb_items - 1].moof_offset < offset)
1220  return frag_index->nb_items;
1221 
1222  a = -1;
1223  b = frag_index->nb_items;
1224 
1225  while (b - a > 1) {
1226  m = (a + b) >> 1;
1227  moof_offset = frag_index->item[m].moof_offset;
1228  if (moof_offset >= offset)
1229  b = m;
1230  if (moof_offset <= offset)
1231  a = m;
1232  }
1233  return b;
1234 }
1235 
1236 static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
1237 {
1238  av_assert0(frag_stream_info);
1239  if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1240  return frag_stream_info->sidx_pts;
1241  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1242  return frag_stream_info->first_tfra_pts;
1243  return frag_stream_info->tfdt_dts;
1244 }
1245 
1246 static int64_t get_frag_time(MOVFragmentIndex *frag_index,
1247  int index, int track_id)
1248 {
1249  MOVFragmentStreamInfo * frag_stream_info;
1250  int64_t timestamp;
1251  int i;
1252 
1253  if (track_id >= 0) {
1254  frag_stream_info = get_frag_stream_info(frag_index, index, track_id);
1255  return frag_stream_info->sidx_pts;
1256  }
1257 
1258  for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
1259  frag_stream_info = &frag_index->item[index].stream_info[i];
1260  timestamp = get_stream_info_time(frag_stream_info);
1261  if (timestamp != AV_NOPTS_VALUE)
1262  return timestamp;
1263  }
1264  return AV_NOPTS_VALUE;
1265 }
1266 
1268  AVStream *st, int64_t timestamp)
1269 {
1270  int a, b, m, m0;
1271  int64_t frag_time;
1272  int id = -1;
1273 
1274  if (st) {
1275  // If the stream is referenced by any sidx, limit the search
1276  // to fragments that referenced this stream in the sidx
1277  MOVStreamContext *sc = st->priv_data;
1278  if (sc->has_sidx)
1279  id = st->id;
1280  }
1281 
1282  a = -1;
1283  b = frag_index->nb_items;
1284 
1285  while (b - a > 1) {
1286  m0 = m = (a + b) >> 1;
1287 
1288  while (m < b &&
1289  (frag_time = get_frag_time(frag_index, m, id)) == AV_NOPTS_VALUE)
1290  m++;
1291 
1292  if (m < b && frag_time <= timestamp)
1293  a = m;
1294  else
1295  b = m0;
1296  }
1297 
1298  return a;
1299 }
1300 
1301 static int update_frag_index(MOVContext *c, int64_t offset)
1302 {
1303  int index, i;
1304  MOVFragmentIndexItem * item;
1305  MOVFragmentStreamInfo * frag_stream_info;
1306 
1307  // If moof_offset already exists in frag_index, return index to it
1308  index = search_frag_moof_offset(&c->frag_index, offset);
1309  if (index < c->frag_index.nb_items &&
1310  c->frag_index.item[index].moof_offset == offset)
1311  return index;
1312 
1313  // offset is not yet in frag index.
1314  // Insert new item at index (sorted by moof offset)
1315  item = av_fast_realloc(c->frag_index.item,
1317  (c->frag_index.nb_items + 1) *
1318  sizeof(*c->frag_index.item));
1319  if(!item)
1320  return -1;
1321  c->frag_index.item = item;
1322 
1323  frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
1324  sizeof(*item->stream_info));
1325  if (!frag_stream_info)
1326  return -1;
1327 
1328  for (i = 0; i < c->fc->nb_streams; i++) {
1329  // Avoid building frag index if streams lack track id.
1330  if (c->fc->streams[i]->id < 0)
1331  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  av_freep(&st->codecpar->extradata);
1842  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1843  if (ret < 0)
1844  return ret;
1845  } else if (atom.size > 8) { /* to read frma, esds atoms */
1846  if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
1847  uint64_t buffer;
1848  ret = ffio_ensure_seekback(pb, 8);
1849  if (ret < 0)
1850  return ret;
1851  buffer = avio_rb64(pb);
1852  atom.size -= 8;
1853  if ( (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
1854  && buffer >> 32 <= atom.size
1855  && buffer >> 32 >= 8) {
1856  avio_skip(pb, -8);
1857  atom.size += 8;
1858  } else if (!st->codecpar->extradata_size) {
1859 #define ALAC_EXTRADATA_SIZE 36
1861  if (!st->codecpar->extradata)
1862  return AVERROR(ENOMEM);
1865  AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
1866  AV_WB64(st->codecpar->extradata + 12, buffer);
1867  avio_read(pb, st->codecpar->extradata + 20, 16);
1868  avio_skip(pb, atom.size - 24);
1869  return 0;
1870  }
1871  }
1872  if ((ret = mov_read_default(c, pb, atom)) < 0)
1873  return ret;
1874  } else
1875  avio_skip(pb, atom.size);
1876  return 0;
1877 }
1878 
1879 /**
1880  * This function reads atom content and puts data in extradata without tag
1881  * nor size unlike mov_read_extradata.
1882  */
1884 {
1885  AVStream *st;
1886  int ret;
1887 
1888  if (c->fc->nb_streams < 1)
1889  return 0;
1890  st = c->fc->streams[c->fc->nb_streams-1];
1891 
1892  if ((uint64_t)atom.size > (1<<30))
1893  return AVERROR_INVALIDDATA;
1894 
1895  if (atom.size >= 10) {
1896  // Broken files created by legacy versions of libavformat will
1897  // wrap a whole fiel atom inside of a glbl atom.
1898  unsigned size = avio_rb32(pb);
1899  unsigned type = avio_rl32(pb);
1900  avio_seek(pb, -8, SEEK_CUR);
1901  if (type == MKTAG('f','i','e','l') && size == atom.size)
1902  return mov_read_default(c, pb, atom);
1903  }
1904  if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
1905  av_log(c->fc, AV_LOG_WARNING, "ignoring multiple glbl\n");
1906  return 0;
1907  }
1908  av_freep(&st->codecpar->extradata);
1909  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1910  if (ret < 0)
1911  return ret;
1912  if (atom.type == MKTAG('h','v','c','C') && st->codecpar->codec_tag == MKTAG('d','v','h','1'))
1913  /* HEVC-based Dolby Vision derived from hvc1.
1914  Happens to match with an identifier
1915  previously utilized for DV. Thus, if we have
1916  the hvcC extradata box available as specified,
1917  set codec to HEVC */
1919 
1920  return 0;
1921 }
1922 
1924 {
1925  AVStream *st;
1926  uint8_t profile_level;
1927  int ret;
1928 
1929  if (c->fc->nb_streams < 1)
1930  return 0;
1931  st = c->fc->streams[c->fc->nb_streams-1];
1932 
1933  if (atom.size >= (1<<28) || atom.size < 7)
1934  return AVERROR_INVALIDDATA;
1935 
1936  profile_level = avio_r8(pb);
1937  if ((profile_level & 0xf0) != 0xc0)
1938  return 0;
1939 
1940  avio_seek(pb, 6, SEEK_CUR);
1941  av_freep(&st->codecpar->extradata);
1942  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 7);
1943  if (ret < 0)
1944  return ret;
1945 
1946  return 0;
1947 }
1948 
1949 /**
1950  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
1951  * but can have extradata appended at the end after the 40 bytes belonging
1952  * to the struct.
1953  */
1955 {
1956  AVStream *st;
1957  int ret;
1958 
1959  if (c->fc->nb_streams < 1)
1960  return 0;
1961  if (atom.size <= 40)
1962  return 0;
1963  st = c->fc->streams[c->fc->nb_streams-1];
1964 
1965  if ((uint64_t)atom.size > (1<<30))
1966  return AVERROR_INVALIDDATA;
1967 
1968  avio_skip(pb, 40);
1969  av_freep(&st->codecpar->extradata);
1970  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 40);
1971  if (ret < 0)
1972  return ret;
1973 
1974  return 0;
1975 }
1976 
1978 {
1979  AVStream *st;
1980  MOVStreamContext *sc;
1981  unsigned int i, entries;
1982 
1983  if (c->fc->nb_streams < 1)
1984  return 0;
1985  st = c->fc->streams[c->fc->nb_streams-1];
1986  sc = st->priv_data;
1987 
1988  avio_r8(pb); /* version */
1989  avio_rb24(pb); /* flags */
1990 
1991  entries = avio_rb32(pb);
1992 
1993  if (!entries)
1994  return 0;
1995 
1996  if (sc->chunk_offsets)
1997  av_log(c->fc, AV_LOG_WARNING, "Duplicated STCO atom\n");
1998  av_free(sc->chunk_offsets);
1999  sc->chunk_count = 0;
2000  sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2001  if (!sc->chunk_offsets)
2002  return AVERROR(ENOMEM);
2003  sc->chunk_count = entries;
2004 
2005  if (atom.type == MKTAG('s','t','c','o'))
2006  for (i = 0; i < entries && !pb->eof_reached; i++)
2007  sc->chunk_offsets[i] = avio_rb32(pb);
2008  else if (atom.type == MKTAG('c','o','6','4'))
2009  for (i = 0; i < entries && !pb->eof_reached; i++)
2010  sc->chunk_offsets[i] = avio_rb64(pb);
2011  else
2012  return AVERROR_INVALIDDATA;
2013 
2014  sc->chunk_count = i;
2015 
2016  if (pb->eof_reached) {
2017  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STCO atom\n");
2018  return AVERROR_EOF;
2019  }
2020 
2021  return 0;
2022 }
2023 
2024 static int mov_codec_id(AVStream *st, uint32_t format)
2025 {
2026  int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
2027 
2028  if (id <= 0 &&
2029  ((format & 0xFFFF) == 'm' + ('s' << 8) ||
2030  (format & 0xFFFF) == 'T' + ('S' << 8)))
2031  id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
2032 
2033  if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
2035  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
2036  /* skip old ASF MPEG-4 tag */
2037  format && format != MKTAG('m','p','4','s')) {
2039  if (id <= 0)
2040  id = ff_codec_get_id(ff_codec_bmp_tags, format);
2041  if (id > 0)
2043  else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
2045  st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
2047  if (id > 0)
2049  else
2050  id = ff_codec_get_id(ff_codec_movdata_tags, format);
2051  }
2052  }
2053 
2054  st->codecpar->codec_tag = format;
2055 
2056  return id;
2057 }
2058 
2060  AVStream *st, MOVStreamContext *sc)
2061 {
2062  uint8_t codec_name[32] = { 0 };
2063  int64_t stsd_start;
2064  unsigned int len;
2065 
2066  /* The first 16 bytes of the video sample description are already
2067  * read in ff_mov_read_stsd_entries() */
2068  stsd_start = avio_tell(pb) - 16;
2069 
2070  avio_rb16(pb); /* version */
2071  avio_rb16(pb); /* revision level */
2072  avio_rb32(pb); /* vendor */
2073  avio_rb32(pb); /* temporal quality */
2074  avio_rb32(pb); /* spatial quality */
2075 
2076  st->codecpar->width = avio_rb16(pb); /* width */
2077  st->codecpar->height = avio_rb16(pb); /* height */
2078 
2079  avio_rb32(pb); /* horiz resolution */
2080  avio_rb32(pb); /* vert resolution */
2081  avio_rb32(pb); /* data size, always 0 */
2082  avio_rb16(pb); /* frames per samples */
2083 
2084  len = avio_r8(pb); /* codec name, pascal string */
2085  if (len > 31)
2086  len = 31;
2087  mov_read_mac_string(c, pb, len, codec_name, sizeof(codec_name));
2088  if (len < 31)
2089  avio_skip(pb, 31 - len);
2090 
2091  if (codec_name[0])
2092  av_dict_set(&st->metadata, "encoder", codec_name, 0);
2093 
2094  /* codec_tag YV12 triggers an UV swap in rawdec.c */
2095  if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
2096  st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
2097  st->codecpar->width &= ~1;
2098  st->codecpar->height &= ~1;
2099  }
2100  /* Flash Media Server uses tag H.263 with Sorenson Spark */
2101  if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
2102  !strncmp(codec_name, "Sorenson H263", 13))
2104 
2105  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
2106 
2107  avio_seek(pb, stsd_start, SEEK_SET);
2108 
2109  if (ff_get_qtpalette(st->codecpar->codec_id, pb, sc->palette)) {
2110  st->codecpar->bits_per_coded_sample &= 0x1F;
2111  sc->has_palette = 1;
2112  }
2113 }
2114 
2116  AVStream *st, MOVStreamContext *sc)
2117 {
2118  int bits_per_sample, flags;
2119  uint16_t version = avio_rb16(pb);
2120  AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
2121 
2122  avio_rb16(pb); /* revision level */
2123  avio_rb32(pb); /* vendor */
2124 
2125  st->codecpar->channels = avio_rb16(pb); /* channel count */
2126  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* sample size */
2127  av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codecpar->channels);
2128 
2129  sc->audio_cid = avio_rb16(pb);
2130  avio_rb16(pb); /* packet size = 0 */
2131 
2132  st->codecpar->sample_rate = ((avio_rb32(pb) >> 16));
2133 
2134  // Read QT version 1 fields. In version 0 these do not exist.
2135  av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom);
2136  if (!c->isom ||
2137  (compatible_brands && strstr(compatible_brands->value, "qt ")) ||
2138  (sc->stsd_version == 0 && version > 0)) {
2139  if (version == 1) {
2140  sc->samples_per_frame = avio_rb32(pb);
2141  avio_rb32(pb); /* bytes per packet */
2142  sc->bytes_per_frame = avio_rb32(pb);
2143  avio_rb32(pb); /* bytes per sample */
2144  } else if (version == 2) {
2145  avio_rb32(pb); /* sizeof struct only */
2147  st->codecpar->channels = avio_rb32(pb);
2148  avio_rb32(pb); /* always 0x7F000000 */
2150 
2151  flags = avio_rb32(pb); /* lpcm format specific flag */
2152  sc->bytes_per_frame = avio_rb32(pb);
2153  sc->samples_per_frame = avio_rb32(pb);
2154  if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
2155  st->codecpar->codec_id =
2157  flags);
2158  }
2159  if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
2160  /* can't correctly handle variable sized packet as audio unit */
2161  switch (st->codecpar->codec_id) {
2162  case AV_CODEC_ID_MP2:
2163  case AV_CODEC_ID_MP3:
2165  break;
2166  }
2167  }
2168  }
2169 
2170  if (sc->format == 0) {
2171  if (st->codecpar->bits_per_coded_sample == 8)
2172  st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
2173  else if (st->codecpar->bits_per_coded_sample == 16)
2174  st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
2175  }
2176 
2177  switch (st->codecpar->codec_id) {
2178  case AV_CODEC_ID_PCM_S8:
2179  case AV_CODEC_ID_PCM_U8:
2180  if (st->codecpar->bits_per_coded_sample == 16)
2182  break;
2183  case AV_CODEC_ID_PCM_S16LE:
2184  case AV_CODEC_ID_PCM_S16BE:
2185  if (st->codecpar->bits_per_coded_sample == 8)
2187  else if (st->codecpar->bits_per_coded_sample == 24)
2188  st->codecpar->codec_id =
2191  else if (st->codecpar->bits_per_coded_sample == 32)
2192  st->codecpar->codec_id =
2195  break;
2196  /* set values for old format before stsd version 1 appeared */
2197  case AV_CODEC_ID_MACE3:
2198  sc->samples_per_frame = 6;
2199  sc->bytes_per_frame = 2 * st->codecpar->channels;
2200  break;
2201  case AV_CODEC_ID_MACE6:
2202  sc->samples_per_frame = 6;
2203  sc->bytes_per_frame = 1 * st->codecpar->channels;
2204  break;
2206  sc->samples_per_frame = 64;
2207  sc->bytes_per_frame = 34 * st->codecpar->channels;
2208  break;
2209  case AV_CODEC_ID_GSM:
2210  sc->samples_per_frame = 160;
2211  sc->bytes_per_frame = 33;
2212  break;
2213  default:
2214  break;
2215  }
2216 
2217  bits_per_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2218  if (bits_per_sample) {
2219  st->codecpar->bits_per_coded_sample = bits_per_sample;
2220  sc->sample_size = (bits_per_sample >> 3) * st->codecpar->channels;
2221  }
2222 }
2223 
2225  AVStream *st, MOVStreamContext *sc,
2226  int64_t size)
2227 {
2228  // ttxt stsd contains display flags, justification, background
2229  // color, fonts, and default styles, so fake an atom to read it
2230  MOVAtom fake_atom = { .size = size };
2231  // mp4s contains a regular esds atom
2232  if (st->codecpar->codec_tag != AV_RL32("mp4s"))
2233  mov_read_glbl(c, pb, fake_atom);
2234  st->codecpar->width = sc->width;
2235  st->codecpar->height = sc->height;
2236 }
2237 
2238 static uint32_t yuv_to_rgba(uint32_t ycbcr)
2239 {
2240  uint8_t r, g, b;
2241  int y, cb, cr;
2242 
2243  y = (ycbcr >> 16) & 0xFF;
2244  cr = (ycbcr >> 8) & 0xFF;
2245  cb = ycbcr & 0xFF;
2246 
2247  b = av_clip_uint8((1164 * (y - 16) + 2018 * (cb - 128)) / 1000);
2248  g = av_clip_uint8((1164 * (y - 16) - 813 * (cr - 128) - 391 * (cb - 128)) / 1000);
2249  r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128) ) / 1000);
2250 
2251  return (r << 16) | (g << 8) | b;
2252 }
2253 
2255 {
2256  char buf[256] = {0};
2257  uint8_t *src = st->codecpar->extradata;
2258  int i;
2259 
2260  if (st->codecpar->extradata_size != 64)
2261  return 0;
2262 
2263  if (st->codecpar->width > 0 && st->codecpar->height > 0)
2264  snprintf(buf, sizeof(buf), "size: %dx%d\n",
2265  st->codecpar->width, st->codecpar->height);
2266  av_strlcat(buf, "palette: ", sizeof(buf));
2267 
2268  for (i = 0; i < 16; i++) {
2269  uint32_t yuv = AV_RB32(src + i * 4);
2270  uint32_t rgba = yuv_to_rgba(yuv);
2271 
2272  av_strlcatf(buf, sizeof(buf), "%06"PRIx32"%s", rgba, i != 15 ? ", " : "");
2273  }
2274 
2275  if (av_strlcat(buf, "\n", sizeof(buf)) >= sizeof(buf))
2276  return 0;
2277 
2278  av_freep(&st->codecpar->extradata);
2279  st->codecpar->extradata_size = 0;
2281  if (!st->codecpar->extradata)
2282  return AVERROR(ENOMEM);
2283  st->codecpar->extradata_size = strlen(buf);
2284  memcpy(st->codecpar->extradata, buf, st->codecpar->extradata_size);
2285 
2286  return 0;
2287 }
2288 
2290  AVStream *st, MOVStreamContext *sc,
2291  int64_t size)
2292 {
2293  int ret;
2294 
2295  if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
2296  if ((int)size != size)
2297  return AVERROR(ENOMEM);
2298 
2299  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
2300  if (ret < 0)
2301  return ret;
2302  if (size > 16) {
2303  MOVStreamContext *tmcd_ctx = st->priv_data;
2304  int val;
2305  val = AV_RB32(st->codecpar->extradata + 4);
2306  tmcd_ctx->tmcd_flags = val;
2307  st->avg_frame_rate.num = AV_RB32(st->codecpar->extradata + 8); /* timescale */
2308  st->avg_frame_rate.den = AV_RB32(st->codecpar->extradata + 12); /* frameDuration */
2309 #if FF_API_LAVF_AVCTX
2311  st->codec->time_base = av_inv_q(st->avg_frame_rate);
2313 #endif
2314  /* adjust for per frame dur in counter mode */
2315  if (tmcd_ctx->tmcd_flags & 0x0008) {
2316  int timescale = AV_RB32(st->codecpar->extradata + 8);
2317  int framedur = AV_RB32(st->codecpar->extradata + 12);
2318  st->avg_frame_rate.num *= timescale;
2319  st->avg_frame_rate.den *= framedur;
2320 #if FF_API_LAVF_AVCTX
2322  st->codec->time_base.den *= timescale;
2323  st->codec->time_base.num *= framedur;
2325 #endif
2326  }
2327  if (size > 30) {
2328  uint32_t len = AV_RB32(st->codecpar->extradata + 18); /* name atom length */
2329  uint32_t format = AV_RB32(st->codecpar->extradata + 22);
2330  if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
2331  uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
2332  if (str_size > 0 && size >= (int)str_size + 26) {
2333  char *reel_name = av_malloc(str_size + 1);
2334  if (!reel_name)
2335  return AVERROR(ENOMEM);
2336  memcpy(reel_name, st->codecpar->extradata + 30, str_size);
2337  reel_name[str_size] = 0; /* Add null terminator */
2338  /* don't add reel_name if emtpy string */
2339  if (*reel_name == 0) {
2340  av_free(reel_name);
2341  } else {
2342  av_dict_set(&st->metadata, "reel_name", reel_name, AV_DICT_DONT_STRDUP_VAL);
2343  }
2344  }
2345  }
2346  }
2347  }
2348  } else {
2349  /* other codec type, just skip (rtp, mp4s ...) */
2350  avio_skip(pb, size);
2351  }
2352  return 0;
2353 }
2354 
2356  AVStream *st, MOVStreamContext *sc)
2357 {
2358  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2359  !st->codecpar->sample_rate && sc->time_scale > 1)
2360  st->codecpar->sample_rate = sc->time_scale;
2361 
2362  /* special codec parameters handling */
2363  switch (st->codecpar->codec_id) {
2364 #if CONFIG_DV_DEMUXER
2365  case AV_CODEC_ID_DVAUDIO:
2367  if (!c->dv_fctx) {
2368  av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
2369  return AVERROR(ENOMEM);
2370  }
2372  if (!c->dv_demux) {
2373  av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
2374  return AVERROR(ENOMEM);
2375  }
2376  sc->dv_audio_container = 1;
2378  break;
2379 #endif
2380  /* no ifdef since parameters are always those */
2381  case AV_CODEC_ID_QCELP:
2382  st->codecpar->channels = 1;
2383  // force sample rate for qcelp when not stored in mov
2384  if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
2385  st->codecpar->sample_rate = 8000;
2386  // FIXME: Why is the following needed for some files?
2387  sc->samples_per_frame = 160;
2388  if (!sc->bytes_per_frame)
2389  sc->bytes_per_frame = 35;
2390  break;
2391  case AV_CODEC_ID_AMR_NB:
2392  st->codecpar->channels = 1;
2393  /* force sample rate for amr, stsd in 3gp does not store sample rate */
2394  st->codecpar->sample_rate = 8000;
2395  break;
2396  case AV_CODEC_ID_AMR_WB:
2397  st->codecpar->channels = 1;
2398  st->codecpar->sample_rate = 16000;
2399  break;
2400  case AV_CODEC_ID_MP2:
2401  case AV_CODEC_ID_MP3:
2402  /* force type after stsd for m1a hdlr */
2404  break;
2405  case AV_CODEC_ID_GSM:
2406  case AV_CODEC_ID_ADPCM_MS:
2408  case AV_CODEC_ID_ILBC:
2409  case AV_CODEC_ID_MACE3:
2410  case AV_CODEC_ID_MACE6:
2411  case AV_CODEC_ID_QDM2:
2413  break;
2414  case AV_CODEC_ID_ALAC:
2415  if (st->codecpar->extradata_size == 36) {
2416  st->codecpar->channels = AV_RB8 (st->codecpar->extradata + 21);
2417  st->codecpar->sample_rate = AV_RB32(st->codecpar->extradata + 32);
2418  }
2419  break;
2420  case AV_CODEC_ID_AC3:
2421  case AV_CODEC_ID_EAC3:
2423  case AV_CODEC_ID_VC1:
2424  case AV_CODEC_ID_VP8:
2425  case AV_CODEC_ID_VP9:
2427  break;
2428  default:
2429  break;
2430  }
2431  return 0;
2432 }
2433 
2435  int codec_tag, int format,
2436  int64_t size)
2437 {
2438  int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2439 
2440  if (codec_tag &&
2441  (codec_tag != format &&
2442  // AVID 1:1 samples with differing data format and codec tag exist
2443  (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
2444  // prores is allowed to have differing data format and codec tag
2445  codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
2446  // so is dv (sigh)
2447  codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
2448  (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
2449  : codec_tag != MKTAG('j','p','e','g')))) {
2450  /* Multiple fourcc, we skip JPEG. This is not correct, we should
2451  * export it as a separate AVStream but this needs a few changes
2452  * in the MOV demuxer, patch welcome. */
2453 
2454  av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
2455  avio_skip(pb, size);
2456  return 1;
2457  }
2458 
2459  return 0;
2460 }
2461 
2463 {
2464  AVStream *st;
2465  MOVStreamContext *sc;
2466  int pseudo_stream_id;
2467 
2468  av_assert0 (c->fc->nb_streams >= 1);
2469  st = c->fc->streams[c->fc->nb_streams-1];
2470  sc = st->priv_data;
2471 
2472  for (pseudo_stream_id = 0;
2473  pseudo_stream_id < entries && !pb->eof_reached;
2474  pseudo_stream_id++) {
2475  //Parsing Sample description table
2476  enum AVCodecID id;
2477  int ret, dref_id = 1;
2478  MOVAtom a = { AV_RL32("stsd") };
2479  int64_t start_pos = avio_tell(pb);
2480  int64_t size = avio_rb32(pb); /* size */
2481  uint32_t format = avio_rl32(pb); /* data format */
2482 
2483  if (size >= 16) {
2484  avio_rb32(pb); /* reserved */
2485  avio_rb16(pb); /* reserved */
2486  dref_id = avio_rb16(pb);
2487  } else if (size <= 7) {
2488  av_log(c->fc, AV_LOG_ERROR,
2489  "invalid size %"PRId64" in stsd\n", size);
2490  return AVERROR_INVALIDDATA;
2491  }
2492 
2493  if (mov_skip_multiple_stsd(c, pb, st->codecpar->codec_tag, format,
2494  size - (avio_tell(pb) - start_pos))) {
2495  sc->stsd_count++;
2496  continue;
2497  }
2498 
2499  sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
2500  sc->dref_id= dref_id;
2501  sc->format = format;
2502 
2503  id = mov_codec_id(st, format);
2504 
2505  av_log(c->fc, AV_LOG_TRACE,
2506  "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
2507  av_fourcc2str(format), st->codecpar->codec_type);
2508 
2509  st->codecpar->codec_id = id;
2511  mov_parse_stsd_video(c, pb, st, sc);
2512  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
2513  mov_parse_stsd_audio(c, pb, st, sc);
2514  if (st->codecpar->sample_rate < 0) {
2515  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
2516  return AVERROR_INVALIDDATA;
2517  }
2518  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
2519  mov_parse_stsd_subtitle(c, pb, st, sc,
2520  size - (avio_tell(pb) - start_pos));
2521  } else {
2522  ret = mov_parse_stsd_data(c, pb, st, sc,
2523  size - (avio_tell(pb) - start_pos));
2524  if (ret < 0)
2525  return ret;
2526  }
2527  /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
2528  a.size = size - (avio_tell(pb) - start_pos);
2529  if (a.size > 8) {
2530  if ((ret = mov_read_default(c, pb, a)) < 0)
2531  return ret;
2532  } else if (a.size > 0)
2533  avio_skip(pb, a.size);
2534 
2535  if (sc->extradata && st->codecpar->extradata) {
2536  int extra_size = st->codecpar->extradata_size;
2537 
2538  /* Move the current stream extradata to the stream context one. */
2539  sc->extradata_size[pseudo_stream_id] = extra_size;
2540  sc->extradata[pseudo_stream_id] = av_malloc(extra_size + AV_INPUT_BUFFER_PADDING_SIZE);
2541  if (!sc->extradata[pseudo_stream_id])
2542  return AVERROR(ENOMEM);
2543  memcpy(sc->extradata[pseudo_stream_id], st->codecpar->extradata, extra_size);
2544  av_freep(&st->codecpar->extradata);
2545  st->codecpar->extradata_size = 0;
2546  }
2547  sc->stsd_count++;
2548  }
2549 
2550  if (pb->eof_reached) {
2551  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSD atom\n");
2552  return AVERROR_EOF;
2553  }
2554 
2555  return 0;
2556 }
2557 
2559 {
2560  AVStream *st;
2561  MOVStreamContext *sc;
2562  int ret, entries;
2563 
2564  if (c->fc->nb_streams < 1)
2565  return 0;
2566  st = c->fc->streams[c->fc->nb_streams - 1];
2567  sc = st->priv_data;
2568 
2569  sc->stsd_version = avio_r8(pb);
2570  avio_rb24(pb); /* flags */
2571  entries = avio_rb32(pb);
2572 
2573  /* Each entry contains a size (4 bytes) and format (4 bytes). */
2574  if (entries <= 0 || entries > atom.size / 8) {
2575  av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2576  return AVERROR_INVALIDDATA;
2577  }
2578 
2579  if (sc->extradata) {
2580  av_log(c->fc, AV_LOG_ERROR,
2581  "Duplicate stsd found in this track.\n");
2582  return AVERROR_INVALIDDATA;
2583  }
2584 
2585  /* Prepare space for hosting multiple extradata. */
2586  sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
2587  if (!sc->extradata)
2588  return AVERROR(ENOMEM);
2589 
2590  sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
2591  if (!sc->extradata_size) {
2592  ret = AVERROR(ENOMEM);
2593  goto fail;
2594  }
2595 
2596  ret = ff_mov_read_stsd_entries(c, pb, entries);
2597  if (ret < 0)
2598  goto fail;
2599 
2600  /* Restore back the primary extradata. */
2601  av_freep(&st->codecpar->extradata);
2602  st->codecpar->extradata_size = sc->extradata_size[0];
2603  if (sc->extradata_size[0]) {
2605  if (!st->codecpar->extradata)
2606  return AVERROR(ENOMEM);
2607  memcpy(st->codecpar->extradata, sc->extradata[0], sc->extradata_size[0]);
2608  }
2609 
2610  return mov_finalize_stsd_codec(c, pb, st, sc);
2611 fail:
2612  if (sc->extradata) {
2613  int j;
2614  for (j = 0; j < sc->stsd_count; j++)
2615  av_freep(&sc->extradata[j]);
2616  }
2617 
2618  av_freep(&sc->extradata);
2619  av_freep(&sc->extradata_size);
2620  return ret;
2621 }
2622 
2624 {
2625  AVStream *st;
2626  MOVStreamContext *sc;
2627  unsigned int i, entries;
2628 
2629  if (c->fc->nb_streams < 1)
2630  return 0;
2631  st = c->fc->streams[c->fc->nb_streams-1];
2632  sc = st->priv_data;
2633 
2634  avio_r8(pb); /* version */
2635  avio_rb24(pb); /* flags */
2636 
2637  entries = avio_rb32(pb);
2638  if ((uint64_t)entries * 12 + 4 > atom.size)
2639  return AVERROR_INVALIDDATA;
2640 
2641  av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2642 
2643  if (!entries)
2644  return 0;
2645  if (sc->stsc_data)
2646  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSC atom\n");
2647  av_free(sc->stsc_data);
2648  sc->stsc_count = 0;
2649  sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2650  if (!sc->stsc_data)
2651  return AVERROR(ENOMEM);
2652 
2653  for (i = 0; i < entries && !pb->eof_reached; i++) {
2654  sc->stsc_data[i].first = avio_rb32(pb);
2655  sc->stsc_data[i].count = avio_rb32(pb);
2656  sc->stsc_data[i].id = avio_rb32(pb);
2657  }
2658 
2659  sc->stsc_count = i;
2660  for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
2661  int64_t first_min = i + 1;
2662  if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
2663  (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
2664  sc->stsc_data[i].first < first_min ||
2665  sc->stsc_data[i].count < 1 ||
2666  sc->stsc_data[i].id < 1) {
2667  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);
2668  if (i+1 >= sc->stsc_count) {
2669  sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
2670  if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
2671  sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
2672  sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
2673  sc->stsc_data[i].id = FFMAX(sc->stsc_data[i].id, 1);
2674  continue;
2675  }
2676  av_assert0(sc->stsc_data[i+1].first >= 2);
2677  // We replace this entry by the next valid
2678  sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
2679  sc->stsc_data[i].count = sc->stsc_data[i+1].count;
2680  sc->stsc_data[i].id = sc->stsc_data[i+1].id;
2681  }
2682  }
2683 
2684  if (pb->eof_reached) {
2685  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSC atom\n");
2686  return AVERROR_EOF;
2687  }
2688 
2689  return 0;
2690 }
2691 
2692 static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
2693 {
2694  return index < count - 1;
2695 }
2696 
2697 /* Compute the samples value for the stsc entry at the given index. */
2698 static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
2699 {
2700  int chunk_count;
2701 
2702  if (mov_stsc_index_valid(index, sc->stsc_count))
2703  chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
2704  else {
2705  // Validation for stsc / stco happens earlier in mov_read_stsc + mov_read_trak.
2706  av_assert0(sc->stsc_data[index].first <= sc->chunk_count);
2707  chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
2708  }
2709 
2710  return sc->stsc_data[index].count * (int64_t)chunk_count;
2711 }
2712 
2714 {
2715  AVStream *st;
2716  MOVStreamContext *sc;
2717  unsigned i, entries;
2718 
2719  if (c->fc->nb_streams < 1)
2720  return 0;
2721  st = c->fc->streams[c->fc->nb_streams-1];
2722  sc = st->priv_data;
2723 
2724  avio_rb32(pb); // version + flags
2725 
2726  entries = avio_rb32(pb);
2727  if (sc->stps_data)
2728  av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
2729  av_free(sc->stps_data);
2730  sc->stps_count = 0;
2731  sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2732  if (!sc->stps_data)
2733  return AVERROR(ENOMEM);
2734 
2735  for (i = 0; i < entries && !pb->eof_reached; i++) {
2736  sc->stps_data[i] = avio_rb32(pb);
2737  }
2738 
2739  sc->stps_count = i;
2740 
2741  if (pb->eof_reached) {
2742  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STPS atom\n");
2743  return AVERROR_EOF;
2744  }
2745 
2746  return 0;
2747 }
2748 
2750 {
2751  AVStream *st;
2752  MOVStreamContext *sc;
2753  unsigned int i, entries;
2754 
2755  if (c->fc->nb_streams < 1)
2756  return 0;
2757  st = c->fc->streams[c->fc->nb_streams-1];
2758  sc = st->priv_data;
2759 
2760  avio_r8(pb); /* version */
2761  avio_rb24(pb); /* flags */
2762 
2763  entries = avio_rb32(pb);
2764 
2765  av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
2766 
2767  if (!entries)
2768  {
2769  sc->keyframe_absent = 1;
2770  if (!st->need_parsing && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2772  return 0;
2773  }
2774  if (sc->keyframes)
2775  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
2776  if (entries >= UINT_MAX / sizeof(int))
2777  return AVERROR_INVALIDDATA;
2778  av_freep(&sc->keyframes);
2779  sc->keyframe_count = 0;
2780  sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
2781  if (!sc->keyframes)
2782  return AVERROR(ENOMEM);
2783 
2784  for (i = 0; i < entries && !pb->eof_reached; i++) {
2785  sc->keyframes[i] = avio_rb32(pb);
2786  }
2787 
2788  sc->keyframe_count = i;
2789 
2790  if (pb->eof_reached) {
2791  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSS atom\n");
2792  return AVERROR_EOF;
2793  }
2794 
2795  return 0;
2796 }
2797 
2799 {
2800  AVStream *st;
2801  MOVStreamContext *sc;
2802  unsigned int i, entries, sample_size, field_size, num_bytes;
2803  GetBitContext gb;
2804  unsigned char* buf;
2805  int ret;
2806 
2807  if (c->fc->nb_streams < 1)
2808  return 0;
2809  st = c->fc->streams[c->fc->nb_streams-1];
2810  sc = st->priv_data;
2811 
2812  avio_r8(pb); /* version */
2813  avio_rb24(pb); /* flags */
2814 
2815  if (atom.type == MKTAG('s','t','s','z')) {
2816  sample_size = avio_rb32(pb);
2817  if (!sc->sample_size) /* do not overwrite value computed in stsd */
2818  sc->sample_size = sample_size;
2819  sc->stsz_sample_size = sample_size;
2820  field_size = 32;
2821  } else {
2822  sample_size = 0;
2823  avio_rb24(pb); /* reserved */
2824  field_size = avio_r8(pb);
2825  }
2826  entries = avio_rb32(pb);
2827 
2828  av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
2829 
2830  sc->sample_count = entries;
2831  if (sample_size)
2832  return 0;
2833 
2834  if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2835  av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
2836  return AVERROR_INVALIDDATA;
2837  }
2838 
2839  if (!entries)
2840  return 0;
2841  if (entries >= (UINT_MAX - 4) / field_size)
2842  return AVERROR_INVALIDDATA;
2843  if (sc->sample_sizes)
2844  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
2845  av_free(sc->sample_sizes);
2846  sc->sample_count = 0;
2847  sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
2848  if (!sc->sample_sizes)
2849  return AVERROR(ENOMEM);
2850 
2851  num_bytes = (entries*field_size+4)>>3;
2852 
2853  buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
2854  if (!buf) {
2855  av_freep(&sc->sample_sizes);
2856  return AVERROR(ENOMEM);
2857  }
2858 
2859  ret = ffio_read_size(pb, buf, num_bytes);
2860  if (ret < 0) {
2861  av_freep(&sc->sample_sizes);
2862  av_free(buf);
2863  av_log(c->fc, AV_LOG_WARNING, "STSZ atom truncated\n");
2864  return 0;
2865  }
2866 
2867  init_get_bits(&gb, buf, 8*num_bytes);
2868 
2869  for (i = 0; i < entries && !pb->eof_reached; i++) {
2870  sc->sample_sizes[i] = get_bits_long(&gb, field_size);
2871  sc->data_size += sc->sample_sizes[i];
2872  }
2873 
2874  sc->sample_count = i;
2875 
2876  av_free(buf);
2877 
2878  if (pb->eof_reached) {
2879  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSZ atom\n");
2880  return AVERROR_EOF;
2881  }
2882 
2883  return 0;
2884 }
2885 
2887 {
2888  AVStream *st;
2889  MOVStreamContext *sc;
2890  unsigned int i, entries, alloc_size = 0;
2891  int64_t duration=0;
2892  int64_t total_sample_count=0;
2893 
2894  if (c->fc->nb_streams < 1)
2895  return 0;
2896  st = c->fc->streams[c->fc->nb_streams-1];
2897  sc = st->priv_data;
2898 
2899  avio_r8(pb); /* version */
2900  avio_rb24(pb); /* flags */
2901  entries = avio_rb32(pb);
2902 
2903  av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
2904  c->fc->nb_streams-1, entries);
2905 
2906  if (sc->stts_data)
2907  av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
2908  av_freep(&sc->stts_data);
2909  sc->stts_count = 0;
2910  if (entries >= INT_MAX / sizeof(*sc->stts_data))
2911  return AVERROR(ENOMEM);
2912 
2913  for (i = 0; i < entries && !pb->eof_reached; i++) {
2914  int sample_duration;
2915  unsigned int sample_count;
2916  unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
2917  MOVStts *stts_data = av_fast_realloc(sc->stts_data, &alloc_size,
2918  min_entries * sizeof(*sc->stts_data));
2919  if (!stts_data) {
2920  av_freep(&sc->stts_data);
2921  sc->stts_count = 0;
2922  return AVERROR(ENOMEM);
2923  }
2924  sc->stts_count = min_entries;
2925  sc->stts_data = stts_data;
2926 
2927  sample_count=avio_rb32(pb);
2928  sample_duration = avio_rb32(pb);
2929 
2930  sc->stts_data[i].count= sample_count;
2931  sc->stts_data[i].duration= sample_duration;
2932 
2933  av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n",
2934  sample_count, sample_duration);
2935 
2936  duration+=(int64_t)sample_duration*(uint64_t)sample_count;
2937  total_sample_count+=sample_count;
2938  }
2939 
2940  sc->stts_count = i;
2941 
2942  if (duration > 0 &&
2943  duration <= INT64_MAX - sc->duration_for_fps &&
2944  total_sample_count <= INT_MAX - sc->nb_frames_for_fps
2945  ) {
2946  sc->duration_for_fps += duration;
2947  sc->nb_frames_for_fps += total_sample_count;
2948  }
2949 
2950  if (pb->eof_reached) {
2951  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STTS atom\n");
2952  return AVERROR_EOF;
2953  }
2954 
2955  st->nb_frames= total_sample_count;
2956  if (duration)
2957  st->duration= FFMIN(st->duration, duration);
2958  sc->track_end = duration;
2959  return 0;
2960 }
2961 
2963 {
2964  AVStream *st;
2965  MOVStreamContext *sc;
2966  int64_t i, entries;
2967 
2968  if (c->fc->nb_streams < 1)
2969  return 0;
2970  st = c->fc->streams[c->fc->nb_streams - 1];
2971  sc = st->priv_data;
2972 
2973  avio_r8(pb); /* version */
2974  avio_rb24(pb); /* flags */
2975  entries = atom.size - 4;
2976 
2977  av_log(c->fc, AV_LOG_TRACE, "track[%u].sdtp.entries = %" PRId64 "\n",
2978  c->fc->nb_streams - 1, entries);
2979 
2980  if (sc->sdtp_data)
2981  av_log(c->fc, AV_LOG_WARNING, "Duplicated SDTP atom\n");
2982  av_freep(&sc->sdtp_data);
2983  sc->sdtp_count = 0;
2984 
2985  sc->sdtp_data = av_mallocz(entries);
2986  if (!sc->sdtp_data)
2987  return AVERROR(ENOMEM);
2988 
2989  for (i = 0; i < entries && !pb->eof_reached; i++)
2990  sc->sdtp_data[i] = avio_r8(pb);
2991  sc->sdtp_count = i;
2992 
2993  return 0;
2994 }
2995 
2996 static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logctx)
2997 {
2998  if (duration < 0) {
2999  if (duration == INT_MIN) {
3000  av_log(logctx, AV_LOG_WARNING, "mov_update_dts_shift(): dts_shift set to %d\n", INT_MAX);
3001  duration++;
3002  }
3003  sc->dts_shift = FFMAX(sc->dts_shift, -duration);
3004  }
3005 }
3006 
3008 {
3009  AVStream *st;
3010  MOVStreamContext *sc;
3011  unsigned int i, entries, ctts_count = 0;
3012 
3013  if (c->fc->nb_streams < 1)
3014  return 0;
3015  st = c->fc->streams[c->fc->nb_streams-1];
3016  sc = st->priv_data;
3017 
3018  avio_r8(pb); /* version */
3019  avio_rb24(pb); /* flags */
3020  entries = avio_rb32(pb);
3021 
3022  av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
3023 
3024  if (!entries)
3025  return 0;
3026  if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
3027  return AVERROR_INVALIDDATA;
3028  av_freep(&sc->ctts_data);
3029  sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
3030  if (!sc->ctts_data)
3031  return AVERROR(ENOMEM);
3032 
3033  for (i = 0; i < entries && !pb->eof_reached; i++) {
3034  int count =avio_rb32(pb);
3035  int duration =avio_rb32(pb);
3036 
3037  if (count <= 0) {
3038  av_log(c->fc, AV_LOG_TRACE,
3039  "ignoring CTTS entry with count=%d duration=%d\n",
3040  count, duration);
3041  continue;
3042  }
3043 
3044  add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
3045  count, duration);
3046 
3047  av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
3048  count, duration);
3049 
3050  if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3051  av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
3052  av_freep(&sc->ctts_data);
3053  sc->ctts_count = 0;
3054  return 0;
3055  }
3056 
3057  if (i+2<entries)
3058  mov_update_dts_shift(sc, duration, c->fc);
3059  }
3060 
3061  sc->ctts_count = ctts_count;
3062 
3063  if (pb->eof_reached) {
3064  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted CTTS atom\n");
3065  return AVERROR_EOF;
3066  }
3067 
3068  av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift);
3069 
3070  return 0;
3071 }
3072 
3074 {
3075  AVStream *st;
3076  MOVStreamContext *sc;
3077  unsigned int i, entries;
3078  uint8_t version;
3079  uint32_t grouping_type;
3080 
3081  if (c->fc->nb_streams < 1)
3082  return 0;
3083  st = c->fc->streams[c->fc->nb_streams-1];
3084  sc = st->priv_data;
3085 
3086  version = avio_r8(pb); /* version */
3087  avio_rb24(pb); /* flags */
3088  grouping_type = avio_rl32(pb);
3089  if (grouping_type != MKTAG( 'r','a','p',' '))
3090  return 0; /* only support 'rap ' grouping */
3091  if (version == 1)
3092  avio_rb32(pb); /* grouping_type_parameter */
3093 
3094  entries = avio_rb32(pb);
3095  if (!entries)
3096  return 0;
3097  if (sc->rap_group)
3098  av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
3099  av_free(sc->rap_group);
3100  sc->rap_group_count = 0;
3101  sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
3102  if (!sc->rap_group)
3103  return AVERROR(ENOMEM);
3104 
3105  for (i = 0; i < entries && !pb->eof_reached; i++) {
3106  sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
3107  sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
3108  }
3109 
3110  sc->rap_group_count = i;
3111 
3112  if (pb->eof_reached) {
3113  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted SBGP atom\n");
3114  return AVERROR_EOF;
3115  }
3116 
3117  return 0;
3118 }
3119 
3120 /**
3121  * Get ith edit list entry (media time, duration).
3122  */
3124  const MOVStreamContext *msc,
3125  unsigned int edit_list_index,
3126  int64_t *edit_list_media_time,
3127  int64_t *edit_list_duration,
3128  int64_t global_timescale)
3129 {
3130  if (edit_list_index == msc->elst_count) {
3131  return 0;
3132  }
3133  *edit_list_media_time = msc->elst_data[edit_list_index].time;
3134  *edit_list_duration = msc->elst_data[edit_list_index].duration;
3135 
3136  /* duration is in global timescale units;convert to msc timescale */
3137  if (global_timescale == 0) {
3138  avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
3139  return 0;
3140  }
3141  *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
3142  global_timescale);
3143  return 1;
3144 }
3145 
3146 /**
3147  * Find the closest previous frame to the timestamp_pts, in e_old index
3148  * entries. Searching for just any frame / just key frames can be controlled by
3149  * last argument 'flag'.
3150  * Note that if ctts_data is not NULL, we will always search for a key frame
3151  * irrespective of the value of 'flag'. If we don't find any keyframe, we will
3152  * return the first frame of the video.
3153  *
3154  * Here the timestamp_pts is considered to be a presentation timestamp and
3155  * the timestamp of index entries are considered to be decoding timestamps.
3156  *
3157  * Returns 0 if successful in finding a frame, else returns -1.
3158  * Places the found index corresponding output arg.
3159  *
3160  * If ctts_old is not NULL, then refines the searched entry by searching
3161  * backwards from the found timestamp, to find the frame with correct PTS.
3162  *
3163  * Places the found ctts_index and ctts_sample in corresponding output args.
3164  */
3166  AVIndexEntry *e_old,
3167  int nb_old,
3168  MOVStts* ctts_data,
3169  int64_t ctts_count,
3170  int64_t timestamp_pts,
3171  int flag,
3172  int64_t* index,
3173  int64_t* ctts_index,
3174  int64_t* ctts_sample)
3175 {
3176  MOVStreamContext *msc = st->priv_data;
3177  AVIndexEntry *e_keep = st->index_entries;
3178  int nb_keep = st->nb_index_entries;
3179  int64_t i = 0;
3180  int64_t index_ctts_count;
3181 
3182  av_assert0(index);
3183 
3184  // If dts_shift > 0, then all the index timestamps will have to be offset by
3185  // at least dts_shift amount to obtain PTS.
3186  // Hence we decrement the searched timestamp_pts by dts_shift to find the closest index element.
3187  if (msc->dts_shift > 0) {
3188  timestamp_pts -= msc->dts_shift;
3189  }
3190 
3191  st->index_entries = e_old;
3192  st->nb_index_entries = nb_old;
3193  *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
3194 
3195  // Keep going backwards in the index entries until the timestamp is the same.
3196  if (*index >= 0) {
3197  for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
3198  i--) {
3199  if ((flag & AVSEEK_FLAG_ANY) ||
3200  (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
3201  *index = i - 1;
3202  }
3203  }
3204  }
3205 
3206  // If we have CTTS then refine the search, by searching backwards over PTS
3207  // computed by adding corresponding CTTS durations to index timestamps.
3208  if (ctts_data && *index >= 0) {
3209  av_assert0(ctts_index);
3210  av_assert0(ctts_sample);
3211  // Find out the ctts_index for the found frame.
3212  *ctts_index = 0;
3213  *ctts_sample = 0;
3214  for (index_ctts_count = 0; index_ctts_count < *index; index_ctts_count++) {
3215  if (*ctts_index < ctts_count) {
3216  (*ctts_sample)++;
3217  if (ctts_data[*ctts_index].count == *ctts_sample) {
3218  (*ctts_index)++;
3219  *ctts_sample = 0;
3220  }
3221  }
3222  }
3223 
3224  while (*index >= 0 && (*ctts_index) >= 0 && (*ctts_index) < ctts_count) {
3225  // Find a "key frame" with PTS <= timestamp_pts (So that we can decode B-frames correctly).
3226  // No need to add dts_shift to the timestamp here becase timestamp_pts has already been
3227  // compensated by dts_shift above.
3228  if ((e_old[*index].timestamp + ctts_data[*ctts_index].duration) <= timestamp_pts &&
3229  (e_old[*index].flags & AVINDEX_KEYFRAME)) {
3230  break;
3231  }
3232 
3233  (*index)--;
3234  if (*ctts_sample == 0) {
3235  (*ctts_index)--;
3236  if (*ctts_index >= 0)
3237  *ctts_sample = ctts_data[*ctts_index].count - 1;
3238  } else {
3239  (*ctts_sample)--;
3240  }
3241  }
3242  }
3243 
3244  /* restore AVStream state*/
3245  st->index_entries = e_keep;
3246  st->nb_index_entries = nb_keep;
3247  return *index >= 0 ? 0 : -1;
3248 }
3249 
3250 /**
3251  * Add index entry with the given values, to the end of st->index_entries.
3252  * Returns the new size st->index_entries if successful, else returns -1.
3253  *
3254  * This function is similar to ff_add_index_entry in libavformat/utils.c
3255  * except that here we are always unconditionally adding an index entry to
3256  * the end, instead of searching the entries list and skipping the add if
3257  * there is an existing entry with the same timestamp.
3258  * This is needed because the mov_fix_index calls this func with the same
3259  * unincremented timestamp for successive discarded frames.
3260  */
3261 static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
3262  int size, int distance, int flags)
3263 {
3264  AVIndexEntry *entries, *ie;
3265  int64_t index = -1;
3266  const size_t min_size_needed = (st->nb_index_entries + 1) * sizeof(AVIndexEntry);
3267 
3268  // Double the allocation each time, to lower memory fragmentation.
3269  // Another difference from ff_add_index_entry function.
3270  const size_t requested_size =
3271  min_size_needed > st->index_entries_allocated_size ?
3272  FFMAX(min_size_needed, 2 * st->index_entries_allocated_size) :
3273  min_size_needed;
3274 
3275  if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
3276  return -1;
3277 
3278  entries = av_fast_realloc(st->index_entries,
3280  requested_size);
3281  if(!entries)
3282  return -1;
3283 
3284  st->index_entries= entries;
3285 
3286  index= st->nb_index_entries++;
3287  ie= &entries[index];
3288 
3289  ie->pos = pos;
3290  ie->timestamp = timestamp;
3291  ie->min_distance= distance;
3292  ie->size= size;
3293  ie->flags = flags;
3294  return index;
3295 }
3296 
3297 /**
3298  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3299  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
3300  */
3301 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
3302  int64_t* frame_duration_buffer,
3303  int frame_duration_buffer_size) {
3304  int i = 0;
3305  av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
3306  for (i = 0; i < frame_duration_buffer_size; i++) {
3307  end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
3308  st->index_entries[end_index - 1 - i].timestamp = end_ts;
3309  }
3310 }
3311 
3312 /**
3313  * Append a new ctts entry to ctts_data.
3314  * Returns the new ctts_count if successful, else returns -1.
3315  */
3316 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
3317  int count, int duration)
3318 {
3319  MOVStts *ctts_buf_new;
3320  const size_t min_size_needed = (*ctts_count + 1) * sizeof(MOVStts);
3321  const size_t requested_size =
3322  min_size_needed > *allocated_size ?
3323  FFMAX(min_size_needed, 2 * (*allocated_size)) :
3324  min_size_needed;
3325 
3326  if((unsigned)(*ctts_count) >= UINT_MAX / sizeof(MOVStts) - 1)
3327  return -1;
3328 
3329  ctts_buf_new = av_fast_realloc(*ctts_data, allocated_size, requested_size);
3330 
3331  if(!ctts_buf_new)
3332  return -1;
3333 
3334  *ctts_data = ctts_buf_new;
3335 
3336  ctts_buf_new[*ctts_count].count = count;
3337  ctts_buf_new[*ctts_count].duration = duration;
3338 
3339  *ctts_count = (*ctts_count) + 1;
3340  return *ctts_count;
3341 }
3342 
3343 #define MAX_REORDER_DELAY 16
3345  MOVStreamContext *msc = st->priv_data;
3346  int ind;
3347  int ctts_ind = 0;
3348  int ctts_sample = 0;
3349  int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
3350  int buf_start = 0;
3351  int j, r, num_swaps;
3352 
3353  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
3354  pts_buf[j] = INT64_MIN;
3355 
3356  if (st->codecpar->video_delay <= 0 && msc->ctts_data &&
3358  st->codecpar->video_delay = 0;
3359  for(ind = 0; ind < st->nb_index_entries && ctts_ind < msc->ctts_count; ++ind) {
3360  // Point j to the last elem of the buffer and insert the current pts there.
3361  j = buf_start;
3362  buf_start = (buf_start + 1);
3363  if (buf_start == MAX_REORDER_DELAY + 1)
3364  buf_start = 0;
3365 
3366  pts_buf[j] = st->index_entries[ind].timestamp + msc->ctts_data[ctts_ind].duration;
3367 
3368  // The timestamps that are already in the sorted buffer, and are greater than the
3369  // current pts, are exactly the timestamps that need to be buffered to output PTS
3370  // in correct sorted order.
3371  // Hence the video delay (which is the buffer size used to sort DTS and output PTS),
3372  // can be computed as the maximum no. of swaps any particular timestamp needs to
3373  // go through, to keep this buffer in sorted order.
3374  num_swaps = 0;
3375  while (j != buf_start) {
3376  r = j - 1;
3377  if (r < 0) r = MAX_REORDER_DELAY;
3378  if (pts_buf[j] < pts_buf[r]) {
3379  FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
3380  ++num_swaps;
3381  } else {
3382  break;
3383  }
3384  j = r;
3385  }
3386  st->codecpar->video_delay = FFMAX(st->codecpar->video_delay, num_swaps);
3387 
3388  ctts_sample++;
3389  if (ctts_sample == msc->ctts_data[ctts_ind].count) {
3390  ctts_ind++;
3391  ctts_sample = 0;
3392  }
3393  }
3394  av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
3395  st->codecpar->video_delay, st->index);
3396  }
3397 }
3398 
3400 {
3401  sc->current_sample++;
3402  sc->current_index++;
3403  if (sc->index_ranges &&
3404  sc->current_index >= sc->current_index_range->end &&
3405  sc->current_index_range->end) {
3406  sc->current_index_range++;
3408  }
3409 }
3410 
3412 {
3413  sc->current_sample--;
3414  sc->current_index--;
3415  if (sc->index_ranges &&
3417  sc->current_index_range > sc->index_ranges) {
3418  sc->current_index_range--;
3419  sc->current_index = sc->current_index_range->end - 1;
3420  }
3421 }
3422 
3423 static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
3424 {
3425  int64_t range_size;
3426 
3427  sc->current_sample = current_sample;
3428  sc->current_index = current_sample;
3429  if (!sc->index_ranges) {
3430  return;
3431  }
3432 
3433  for (sc->current_index_range = sc->index_ranges;
3434  sc->current_index_range->end;
3435  sc->current_index_range++) {
3436  range_size = sc->current_index_range->end - sc->current_index_range->start;
3437  if (range_size > current_sample) {
3438  sc->current_index = sc->current_index_range->start + current_sample;
3439  break;
3440  }
3441  current_sample -= range_size;
3442  }
3443 }
3444 
3445 /**
3446  * Fix st->index_entries, so that it contains only the entries (and the entries
3447  * which are needed to decode them) that fall in the edit list time ranges.
3448  * Also fixes the timestamps of the index entries to match the timeline
3449  * specified the edit lists.
3450  */
3451 static void mov_fix_index(MOVContext *mov, AVStream *st)
3452 {
3453  MOVStreamContext *msc = st->priv_data;
3454  AVIndexEntry *e_old = st->index_entries;
3455  int nb_old = st->nb_index_entries;
3456  const AVIndexEntry *e_old_end = e_old + nb_old;
3457  const AVIndexEntry *current = NULL;
3458  MOVStts *ctts_data_old = msc->ctts_data;
3459  int64_t ctts_index_old = 0;
3460  int64_t ctts_sample_old = 0;
3461  int64_t ctts_count_old = msc->ctts_count;
3462  int64_t edit_list_media_time = 0;
3463  int64_t edit_list_duration = 0;
3464  int64_t frame_duration = 0;
3465  int64_t edit_list_dts_counter = 0;
3466  int64_t edit_list_dts_entry_end = 0;
3467  int64_t edit_list_start_ctts_sample = 0;
3468  int64_t curr_cts;
3469  int64_t curr_ctts = 0;
3470  int64_t empty_edits_sum_duration = 0;
3471  int64_t edit_list_index = 0;
3472  int64_t index;
3473  int flags;
3474  int64_t start_dts = 0;
3475  int64_t edit_list_start_encountered = 0;
3476  int64_t search_timestamp = 0;
3477  int64_t* frame_duration_buffer = NULL;
3478  int num_discarded_begin = 0;
3479  int first_non_zero_audio_edit = -1;
3480  int packet_skip_samples = 0;
3481  MOVIndexRange *current_index_range;
3482  int i;
3483  int found_keyframe_after_edit = 0;
3484  int found_non_empty_edit = 0;
3485 
3486  if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
3487  return;
3488  }
3489 
3490  // allocate the index ranges array
3491  msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
3492  if (!msc->index_ranges) {
3493  av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
3494  return;
3495  }
3496  msc->current_index_range = msc->index_ranges;
3497  current_index_range = msc->index_ranges - 1;
3498 
3499  // Clean AVStream from traces of old index
3500  st->index_entries = NULL;
3502  st->nb_index_entries = 0;
3503 
3504  // Clean ctts fields of MOVStreamContext
3505  msc->ctts_data = NULL;
3506  msc->ctts_count = 0;
3507  msc->ctts_index = 0;
3508  msc->ctts_sample = 0;
3509  msc->ctts_allocated_size = 0;
3510 
3511  // Reinitialize min_corrected_pts so that it can be computed again.
3512  msc->min_corrected_pts = -1;
3513 
3514  // If the dts_shift is positive (in case of negative ctts values in mov),
3515  // then negate the DTS by dts_shift
3516  if (msc->dts_shift > 0) {
3517  edit_list_dts_entry_end -= msc->dts_shift;
3518  av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
3519  }
3520 
3521  start_dts = edit_list_dts_entry_end;
3522 
3523  while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
3524  &edit_list_duration, mov->time_scale)) {
3525  av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
3526  st->index, edit_list_index, edit_list_media_time, edit_list_duration);
3527  edit_list_index++;
3528  edit_list_dts_counter = edit_list_dts_entry_end;
3529  edit_list_dts_entry_end += edit_list_duration;
3530  num_discarded_begin = 0;
3531  if (!found_non_empty_edit && edit_list_media_time == -1) {
3532  empty_edits_sum_duration += edit_list_duration;
3533  continue;
3534  }
3535  found_non_empty_edit = 1;
3536 
3537  // If we encounter a non-negative edit list reset the skip_samples/start_pad fields and set them
3538  // according to the edit list below.
3539  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3540  if (first_non_zero_audio_edit < 0) {
3541  first_non_zero_audio_edit = 1;
3542  } else {
3543  first_non_zero_audio_edit = 0;
3544  }
3545 
3546  if (first_non_zero_audio_edit > 0)
3547  st->skip_samples = msc->start_pad = 0;
3548  }
3549 
3550  // While reordering frame index according to edit list we must handle properly
3551  // the scenario when edit list entry starts from none key frame.
3552  // We find closest previous key frame and preserve it and consequent frames in index.
3553  // All frames which are outside edit list entry time boundaries will be dropped after decoding.
3554  search_timestamp = edit_list_media_time;
3555  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3556  // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
3557  // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
3558  // edit_list_media_time to cover the decoder delay.
3559  search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
3560  }
3561 
3562  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, 0,
3563  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3564  av_log(mov->fc, AV_LOG_WARNING,
3565  "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
3566  st->index, edit_list_index, search_timestamp);
3567  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
3568  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3569  av_log(mov->fc, AV_LOG_WARNING,
3570  "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
3571  st->index, edit_list_index, search_timestamp);
3572  index = 0;
3573  ctts_index_old = 0;
3574  ctts_sample_old = 0;
3575  }
3576  }
3577  current = e_old + index;
3578  edit_list_start_ctts_sample = ctts_sample_old;
3579 
3580  // Iterate over index and arrange it according to edit list
3581  edit_list_start_encountered = 0;
3582  found_keyframe_after_edit = 0;
3583  for (; current < e_old_end; current++, index++) {
3584  // check if frame outside edit list mark it for discard
3585  frame_duration = (current + 1 < e_old_end) ?
3586  ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
3587 
3588  flags = current->flags;
3589 
3590  // frames (pts) before or after edit list
3591  curr_cts = current->timestamp + msc->dts_shift;
3592  curr_ctts = 0;
3593 
3594  if (ctts_data_old && ctts_index_old < ctts_count_old) {
3595  curr_ctts = ctts_data_old[ctts_index_old].duration;
3596  av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
3597  curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
3598  curr_cts += curr_ctts;
3599  ctts_sample_old++;
3600  if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
3601  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3602  &msc->ctts_allocated_size,
3603  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3604  ctts_data_old[ctts_index_old].duration) == -1) {
3605  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3606  ctts_index_old,
3607  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3608  ctts_data_old[ctts_index_old].duration);
3609  break;
3610  }
3611  ctts_index_old++;
3612  ctts_sample_old = 0;
3613  edit_list_start_ctts_sample = 0;
3614  }
3615  }
3616 
3617  if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3619  curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3620  first_non_zero_audio_edit > 0) {
3621  packet_skip_samples = edit_list_media_time - curr_cts;
3622  st->skip_samples += packet_skip_samples;
3623 
3624  // Shift the index entry timestamp by packet_skip_samples to be correct.
3625  edit_list_dts_counter -= packet_skip_samples;
3626  if (edit_list_start_encountered == 0) {
3627  edit_list_start_encountered = 1;
3628  // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
3629  // discarded packets.
3630  if (frame_duration_buffer) {
3631  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3632  frame_duration_buffer, num_discarded_begin);
3633  av_freep(&frame_duration_buffer);
3634  }
3635  }
3636 
3637  av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
3638  } else {
3639  flags |= AVINDEX_DISCARD_FRAME;
3640  av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
3641 
3642  if (edit_list_start_encountered == 0) {
3643  num_discarded_begin++;
3644  frame_duration_buffer = av_realloc(frame_duration_buffer,
3645  num_discarded_begin * sizeof(int64_t));
3646  if (!frame_duration_buffer) {
3647  av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
3648  break;
3649  }
3650  frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3651 
3652  // Increment skip_samples for the first non-zero audio edit list
3653  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3654  first_non_zero_audio_edit > 0 && st->codecpar->codec_id != AV_CODEC_ID_VORBIS) {
3655  st->skip_samples += frame_duration;
3656  }
3657  }
3658  }
3659  } else {
3660  if (msc->min_corrected_pts < 0) {
3661  msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
3662  } else {
3663  msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
3664  }
3665  if (edit_list_start_encountered == 0) {
3666  edit_list_start_encountered = 1;
3667  // Make timestamps strictly monotonically increasing by rewriting timestamps for
3668  // discarded packets.
3669  if (frame_duration_buffer) {
3670  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3671  frame_duration_buffer, num_discarded_begin);
3672  av_freep(&frame_duration_buffer);
3673  }
3674  }
3675  }
3676 
3677  if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
3678  current->min_distance, flags) == -1) {
3679  av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
3680  break;
3681  }
3682 
3683  // Update the index ranges array
3684  if (current_index_range < msc->index_ranges || index != current_index_range->end) {
3685  current_index_range++;
3686  current_index_range->start = index;
3687  }
3688  current_index_range->end = index + 1;
3689 
3690  // Only start incrementing DTS in frame_duration amounts, when we encounter a frame in edit list.
3691  if (edit_list_start_encountered > 0) {
3692  edit_list_dts_counter = edit_list_dts_counter + frame_duration;
3693  }
3694 
3695  // Break when found first key frame after edit entry completion
3696  if ((curr_cts + frame_duration >= (edit_list_duration + edit_list_media_time)) &&
3697  ((flags & AVINDEX_KEYFRAME) || ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)))) {
3698  if (ctts_data_old) {
3699  // If we have CTTS and this is the first keyframe after edit elist,
3700  // wait for one more, because there might be trailing B-frames after this I-frame
3701  // that do belong to the edit.
3702  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO && found_keyframe_after_edit == 0) {
3703  found_keyframe_after_edit = 1;
3704  continue;
3705  }
3706  if (ctts_sample_old != 0) {
3707  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3708  &msc->ctts_allocated_size,
3709  ctts_sample_old - edit_list_start_ctts_sample,
3710  ctts_data_old[ctts_index_old].duration) == -1) {
3711  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3712  ctts_index_old, ctts_sample_old - edit_list_start_ctts_sample,
3713  ctts_data_old[ctts_index_old].duration);
3714  break;
3715  }
3716  }
3717  }
3718  break;
3719  }
3720  }
3721  }
3722  // If there are empty edits, then msc->min_corrected_pts might be positive
3723  // intentionally. So we subtract the sum duration of emtpy edits here.
3724  msc->min_corrected_pts -= empty_edits_sum_duration;
3725 
3726  // If the minimum pts turns out to be greater than zero after fixing the index, then we subtract the
3727  // dts by that amount to make the first pts zero.
3728  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3729  if (msc->min_corrected_pts > 0) {
3730  av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by %"PRId64" to make first pts zero.\n", msc->min_corrected_pts);
3731  for (i = 0; i < st->nb_index_entries; ++i) {
3733  }
3734  }
3735  }
3736  // Start time should be equal to zero or the duration of any empty edits.
3737  st->start_time = empty_edits_sum_duration;
3738 
3739  // Update av stream length, if it ends up shorter than the track's media duration
3740  st->duration = FFMIN(st->duration, edit_list_dts_entry_end - start_dts);
3741  msc->start_pad = st->skip_samples;
3742 
3743  // Free the old index and the old CTTS structures
3744  av_free(e_old);
3745  av_free(ctts_data_old);
3746  av_freep(&frame_duration_buffer);
3747 
3748  // Null terminate the index ranges array
3749  current_index_range++;
3750  current_index_range->start = 0;
3751  current_index_range->end = 0;
3752  msc->current_index = msc->index_ranges[0].start;
3753 }
3754 
3755 static void mov_build_index(MOVContext *mov, AVStream *st)
3756 {
3757  MOVStreamContext *sc = st->priv_data;
3758  int64_t current_offset;
3759  int64_t current_dts = 0;
3760  unsigned int stts_index = 0;
3761  unsigned int stsc_index = 0;
3762  unsigned int stss_index = 0;
3763  unsigned int stps_index = 0;
3764  unsigned int i, j;
3765  uint64_t stream_size = 0;
3766  MOVStts *ctts_data_old = sc->ctts_data;
3767  unsigned int ctts_count_old = sc->ctts_count;
3768 
3769  if (sc->elst_count) {
3770  int i, edit_start_index = 0, multiple_edits = 0;
3771  int64_t empty_duration = 0; // empty duration of the first edit list entry
3772  int64_t start_time = 0; // start time of the media
3773 
3774  for (i = 0; i < sc->elst_count; i++) {
3775  const MOVElst *e = &sc->elst_data[i];
3776  if (i == 0 && e->time == -1) {
3777  /* if empty, the first entry is the start time of the stream
3778  * relative to the presentation itself */
3779  empty_duration = e->duration;
3780  edit_start_index = 1;
3781  } else if (i == edit_start_index && e->time >= 0) {
3782  start_time = e->time;
3783  } else {
3784  multiple_edits = 1;
3785  }
3786  }
3787 
3788  if (multiple_edits && !mov->advanced_editlist)
3789  av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
3790  "Use -advanced_editlist to correctly decode otherwise "
3791  "a/v desync might occur\n");
3792 
3793  /* adjust first dts according to edit list */
3794  if ((empty_duration || start_time) && mov->time_scale > 0) {
3795  if (empty_duration)
3796  empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
3797  sc->time_offset = start_time - empty_duration;
3799  if (!mov->advanced_editlist)
3800  current_dts = -sc->time_offset;
3801  }
3802 
3803  if (!multiple_edits && !mov->advanced_editlist &&
3804  st->codecpar->codec_id == AV_CODEC_ID_AAC && start_time > 0)
3805  sc->start_pad = start_time;
3806  }
3807 
3808  /* only use old uncompressed audio chunk demuxing when stts specifies it */
3809  if (!(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3810  sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
3811  unsigned int current_sample = 0;
3812  unsigned int stts_sample = 0;
3813  unsigned int sample_size;
3814  unsigned int distance = 0;
3815  unsigned int rap_group_index = 0;
3816  unsigned int rap_group_sample = 0;
3817  int64_t last_dts = 0;
3818  int64_t dts_correction = 0;
3819  int rap_group_present = sc->rap_group_count && sc->rap_group;
3820  int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
3821 
3822  current_dts -= sc->dts_shift;
3823  last_dts = current_dts;
3824 
3825  if (!sc->sample_count || st->nb_index_entries)
3826  return;
3827  if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
3828  return;
3830  st->nb_index_entries + sc->sample_count,
3831  sizeof(*st->index_entries)) < 0) {
3832  st->nb_index_entries = 0;
3833  return;
3834  }
3836 
3837  if (ctts_data_old) {
3838  // Expand ctts entries such that we have a 1-1 mapping with samples
3839  if (sc->sample_count >= UINT_MAX / sizeof(*sc->ctts_data))
3840  return;
3841  sc->ctts_count = 0;
3842  sc->ctts_allocated_size = 0;
3844  sc->sample_count * sizeof(*sc->ctts_data));
3845  if (!sc->ctts_data) {
3846  av_free(ctts_data_old);
3847  return;
3848  }
3849 
3850  memset((uint8_t*)(sc->ctts_data), 0, sc->ctts_allocated_size);
3851 
3852  for (i = 0; i < ctts_count_old &&
3853  sc->ctts_count < sc->sample_count; i++)
3854  for (j = 0; j < ctts_data_old[i].count &&
3855  sc->ctts_count < sc->sample_count; j++)
3856  add_ctts_entry(&sc->ctts_data, &sc->ctts_count,
3857  &sc->ctts_allocated_size, 1,
3858  ctts_data_old[i].duration);
3859  av_free(ctts_data_old);
3860  }
3861 
3862  for (i = 0; i < sc->chunk_count; i++) {
3863  int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
3864  current_offset = sc->chunk_offsets[i];
3865  while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
3866  i + 1 == sc->stsc_data[stsc_index + 1].first)
3867  stsc_index++;
3868 
3869  if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
3870  sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
3871  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
3872  sc->stsz_sample_size = sc->sample_size;
3873  }
3874  if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
3875  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
3876  sc->stsz_sample_size = sc->sample_size;
3877  }
3878 
3879  for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
3880  int keyframe = 0;
3881  if (current_sample >= sc->sample_count) {
3882  av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
3883  return;
3884  }
3885 
3886  if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
3887  keyframe = 1;
3888  if (stss_index + 1 < sc->keyframe_count)
3889  stss_index++;
3890  } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
3891  keyframe = 1;
3892  if (stps_index + 1 < sc->stps_count)
3893  stps_index++;
3894  }
3895  if (rap_group_present && rap_group_index < sc->rap_group_count) {
3896  if (sc->rap_group[rap_group_index].index > 0)
3897  keyframe = 1;
3898  if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
3899  rap_group_sample = 0;
3900  rap_group_index++;
3901  }
3902  }
3903  if (sc->keyframe_absent
3904  && !sc->stps_count
3905  && !rap_group_present
3906  && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
3907  keyframe = 1;
3908  if (keyframe)
3909  distance = 0;
3910  sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
3911  if (sc->pseudo_stream_id == -1 ||
3912  sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
3913  AVIndexEntry *e;
3914  if (sample_size > 0x3FFFFFFF) {
3915  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", sample_size);
3916  return;
3917  }
3918  e = &st->index_entries[st->nb_index_entries++];
3919  e->pos = current_offset;
3920  e->timestamp = current_dts;
3921  e->size = sample_size;
3922  e->min_distance = distance;
3923  e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
3924  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
3925  "size %u, distance %u, keyframe %d\n", st->index, current_sample,
3926  current_offset, current_dts, sample_size, distance, keyframe);
3927  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
3928  ff_rfps_add_frame(mov->fc, st, current_dts);
3929  }
3930 
3931  current_offset += sample_size;
3932  stream_size += sample_size;
3933 
3934  /* A negative sample duration is invalid based on the spec,
3935  * but some samples need it to correct the DTS. */
3936  if (sc->stts_data[stts_index].duration < 0) {
3937  av_log(mov->fc, AV_LOG_WARNING,
3938  "Invalid SampleDelta %d in STTS, at %d st:%d\n",
3939  sc->stts_data[stts_index].duration, stts_index,
3940  st->index);
3941  dts_correction += sc->stts_data[stts_index].duration - 1;
3942  sc->stts_data[stts_index].duration = 1;
3943  }
3944  current_dts += sc->stts_data[stts_index].duration;
3945  if (!dts_correction || current_dts + dts_correction > last_dts) {
3946  current_dts += dts_correction;
3947  dts_correction = 0;
3948  } else {
3949  /* Avoid creating non-monotonous DTS */
3950  dts_correction += current_dts - last_dts - 1;
3951  current_dts = last_dts + 1;
3952  }
3953  last_dts = current_dts;
3954  distance++;
3955  stts_sample++;
3956  current_sample++;
3957  if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
3958  stts_sample = 0;
3959  stts_index++;
3960  }
3961  }
3962  }
3963  if (st->duration > 0)
3964  st->codecpar->bit_rate = stream_size*8*sc->time_scale/st->duration;
3965  } else {
3966  unsigned chunk_samples, total = 0;
3967 
3968  if (!sc->chunk_count)
3969  return;
3970 
3971  // compute total chunk count
3972  for (i = 0; i < sc->stsc_count; i++) {
3973  unsigned count, chunk_count;
3974 
3975  chunk_samples = sc->stsc_data[i].count;
3976  if (i != sc->stsc_count - 1 &&
3977  sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
3978  av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
3979  return;
3980  }
3981 
3982  if (sc->samples_per_frame >= 160) { // gsm
3983  count = chunk_samples / sc->samples_per_frame;
3984  } else if (sc->samples_per_frame > 1) {
3985  unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
3986  count = (chunk_samples+samples-1) / samples;
3987  } else {
3988  count = (chunk_samples+1023) / 1024;
3989  }
3990 
3991  if (mov_stsc_index_valid(i, sc->stsc_count))
3992  chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
3993  else
3994  chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
3995  total += chunk_count * count;
3996  }
3997 
3998  av_log(mov->fc, AV_LOG_TRACE, "chunk count %u\n", total);
3999  if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
4000  return;
4002  st->nb_index_entries + total,
4003  sizeof(*st->index_entries)) < 0) {
4004  st->nb_index_entries = 0;
4005  return;
4006  }
4007  st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
4008 
4009  // populate index
4010  for (i = 0; i < sc->chunk_count; i++) {
4011  current_offset = sc->chunk_offsets[i];
4012  if (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
4013  i + 1 == sc->stsc_data[stsc_index + 1].first)
4014  stsc_index++;
4015  chunk_samples = sc->stsc_data[stsc_index].count;
4016 
4017  while (chunk_samples > 0) {
4018  AVIndexEntry *e;
4019  unsigned size, samples;
4020 
4021  if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
4023  "Zero bytes per frame, but %d samples per frame",
4024  sc->samples_per_frame);
4025  return;
4026  }
4027 
4028  if (sc->samples_per_frame >= 160) { // gsm
4029  samples = sc->samples_per_frame;
4030  size = sc->bytes_per_frame;
4031  } else {
4032  if (sc->samples_per_frame > 1) {
4033  samples = FFMIN((1024 / sc->samples_per_frame)*
4034  sc->samples_per_frame, chunk_samples);
4035  size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
4036  } else {
4037  samples = FFMIN(1024, chunk_samples);
4038  size = samples * sc->sample_size;
4039  }
4040  }
4041 
4042  if (st->nb_index_entries >= total) {
4043  av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %u\n", total);
4044  return;
4045  }
4046  if (size > 0x3FFFFFFF) {
4047  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", size);
4048  return;
4049  }
4050  e = &st->index_entries[st->nb_index_entries++];
4051  e->pos = current_offset;
4052  e->timestamp = current_dts;
4053  e->size = size;
4054  e->min_distance = 0;
4055  e->flags = AVINDEX_KEYFRAME;
4056  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
4057  "size %u, duration %u\n", st->index, i, current_offset, current_dts,
4058  size, samples);
4059 
4060  current_offset += size;
4061  current_dts += samples;
4062  chunk_samples -= samples;
4063  }
4064  }
4065  }
4066 
4067  if (!mov->ignore_editlist && mov->advanced_editlist) {
4068  // Fix index according to edit lists.
4069  mov_fix_index(mov, st);
4070  }
4071 
4072  // Update start time of the stream.
4074  st->start_time = st->index_entries[0].timestamp + sc->dts_shift;
4075  if (sc->ctts_data) {
4076  st->start_time += sc->ctts_data[0].duration;
4077  }
4078  }
4079 
4080  mov_estimate_video_delay(mov, st);
4081 }
4082 
4083 static int test_same_origin(const char *src, const char *ref) {
4084  char src_proto[64];
4085  char ref_proto[64];
4086  char src_auth[256];
4087  char ref_auth[256];
4088  char src_host[256];
4089  char ref_host[256];
4090  int src_port=-1;
4091  int ref_port=-1;
4092 
4093  av_url_split(src_proto, sizeof(src_proto), src_auth, sizeof(src_auth), src_host, sizeof(src_host), &src_port, NULL, 0, src);
4094  av_url_split(ref_proto, sizeof(ref_proto), ref_auth, sizeof(ref_auth), ref_host, sizeof(ref_host), &ref_port, NULL, 0, ref);
4095 
4096  if (strlen(src) == 0) {
4097  return -1;
4098  } else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
4099  strlen(ref_auth) + 1 >= sizeof(ref_auth) ||
4100  strlen(src_host) + 1 >= sizeof(src_host) ||
4101  strlen(ref_host) + 1 >= sizeof(ref_host)) {
4102  return 0;
4103  } else if (strcmp(src_proto, ref_proto) ||
4104  strcmp(src_auth, ref_auth) ||
4105  strcmp(src_host, ref_host) ||
4106  src_port != ref_port) {
4107  return 0;
4108  } else
4109  return 1;
4110 }
4111 
4112 static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
4113 {
4114  /* try relative path, we do not try the absolute because it can leak information about our
4115  system to an attacker */
4116  if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
4117  char filename[1025];
4118  const char *src_path;
4119  int i, l;
4120 
4121  /* find a source dir */
4122  src_path = strrchr(src, '/');
4123  if (src_path)
4124  src_path++;
4125  else
4126  src_path = src;
4127 
4128  /* find a next level down to target */
4129  for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
4130  if (ref->path[l] == '/') {
4131  if (i == ref->nlvl_to - 1)
4132  break;
4133  else
4134  i++;
4135  }
4136 
4137  /* compose filename if next level down to target was found */
4138  if (i == ref->nlvl_to - 1 && src_path - src < sizeof(filename)) {
4139  memcpy(filename, src, src_path - src);
4140  filename[src_path - src] = 0;
4141 
4142  for (i = 1; i < ref->nlvl_from; i++)
4143  av_strlcat(filename, "../", sizeof(filename));
4144 
4145  av_strlcat(filename, ref->path + l + 1, sizeof(filename));
4146  if (!c->use_absolute_path) {
4147  int same_origin = test_same_origin(src, filename);
4148 
4149  if (!same_origin) {
4150  av_log(c->fc, AV_LOG_ERROR,
4151  "Reference with mismatching origin, %s not tried for security reasons, "
4152  "set demuxer option use_absolute_path to allow it anyway\n",
4153  ref->path);
4154  return AVERROR(ENOENT);
4155  }
4156 
4157  if(strstr(ref->path + l + 1, "..") ||
4158  strstr(ref->path + l + 1, ":") ||
4159  (ref->nlvl_from > 1 && same_origin < 0) ||
4160  (filename[0] == '/' && src_path == src))
4161  return AVERROR(ENOENT);
4162  }
4163 
4164  if (strlen(filename) + 1 == sizeof(filename))
4165  return AVERROR(ENOENT);
4166  if (!c->fc->io_open(c->fc, pb, filename, AVIO_FLAG_READ, NULL))
4167  return 0;
4168  }
4169  } else if (c->use_absolute_path) {
4170  av_log(c->fc, AV_LOG_WARNING, "Using absolute path on user request, "
4171  "this is a possible security issue\n");
4172  if (!c->fc->io_open(c->fc, pb, ref->path, AVIO_FLAG_READ, NULL))
4173  return 0;
4174  } else {
4175  av_log(c->fc, AV_LOG_ERROR,
4176  "Absolute path %s not tried for security reasons, "
4177  "set demuxer option use_absolute_path to allow absolute paths\n",
4178  ref->path);
4179  }
4180 
4181  return AVERROR(ENOENT);
4182 }
4183 
4185 {
4186  if (sc->time_scale <= 0) {
4187  av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
4188  sc->time_scale = c->time_scale;
4189  if (sc->time_scale <= 0)
4190  sc->time_scale = 1;
4191  }
4192 }
4193 
4195 {
4196  AVStream *st;
4197  MOVStreamContext *sc;
4198  int ret;
4199 
4200  st = avformat_new_stream(c->fc, NULL);
4201  if (!st) return AVERROR(ENOMEM);
4202  st->id = -1;
4203  sc = av_mallocz(sizeof(MOVStreamContext));
4204  if (!sc) return AVERROR(ENOMEM);
4205 
4206  st->priv_data = sc;
4208  sc->ffindex = st->index;
4209  c->trak_index = st->index;
4210 
4211  if ((ret = mov_read_default(c, pb, atom)) < 0)
4212  return ret;
4213 
4214  c->trak_index = -1;
4215 
4216  // Here stsc refers to a chunk not described in stco. This is technically invalid,
4217  // but we can overlook it (clearing stsc) whenever stts_count == 0 (indicating no samples).
4218  if (!sc->chunk_count && !sc->stts_count && sc->stsc_count) {
4219  sc->stsc_count = 0;
4220  av_freep(&sc->stsc_data);
4221  }
4222 
4223  /* sanity checks */
4224  if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
4225  (!sc->sample_size && !sc->sample_count))) ||
4226  (!sc->chunk_count && sc->sample_count)) {
4227  av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
4228  st->index);
4229  return 0;
4230  }
4231  if (sc->stsc_count && sc->stsc_data[ sc->stsc_count - 1 ].first > sc->chunk_count) {
4232  av_log(c->fc, AV_LOG_ERROR, "stream %d, contradictionary STSC and STCO\n",
4233  st->index);
4234  return AVERROR_INVALIDDATA;
4235  }
4236 
4237  fix_timescale(c, sc);
4238 
4239  avpriv_set_pts_info(st, 64, 1, sc->time_scale);
4240 
4241  mov_build_index(c, st);
4242 
4243  if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
4244  MOVDref *dref = &sc->drefs[sc->dref_id - 1];
4245  if (c->enable_drefs) {
4246  if (mov_open_dref(c, &sc->pb, c->fc->url, dref) < 0)
4247  av_log(c->fc, AV_LOG_ERROR,
4248  "stream %d, error opening alias: path='%s', dir='%s', "
4249  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
4250  st->index, dref->path, dref->dir, dref->filename,
4251  dref->volume, dref->nlvl_from, dref->nlvl_to);
4252  } else {
4253  av_log(c->fc, AV_LOG_WARNING,
4254  "Skipped opening external track: "
4255  "stream %d, alias: path='%s', dir='%s', "
4256  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
4257  "Set enable_drefs to allow this.\n",
4258  st->index, dref->path, dref->dir, dref->filename,
4259  dref->volume, dref->nlvl_from, dref->nlvl_to);
4260  }
4261  } else {
4262  sc->pb = c->fc->pb;
4263  sc->pb_is_copied = 1;
4264  }
4265 
4266  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
4267  if (!st->sample_aspect_ratio.num && st->codecpar->width && st->codecpar->height &&
4268  sc->height && sc->width &&
4269  (st->codecpar->width != sc->width || st->codecpar->height != sc->height)) {
4270  st->sample_aspect_ratio = av_d2q(((double)st->codecpar->height * sc->width) /
4271  ((double)st->codecpar->width * sc->height), INT_MAX);
4272  }
4273 
4274 #if FF_API_R_FRAME_RATE
4275  if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
4277  sc->time_scale, sc->stts_data[0].duration, INT_MAX);
4278 #endif
4279  }
4280 
4281  // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
4282  if (!st->codecpar->extradata_size && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
4283  TAG_IS_AVCI(st->codecpar->codec_tag)) {
4284  ret = ff_generate_avci_extradata(st);
4285  if (ret < 0)
4286  return ret;
4287  }
4288 
4289  switch (st->codecpar->codec_id) {
4290 #if CONFIG_H261_DECODER
4291  case AV_CODEC_ID_H261:
4292 #endif
4293 #if CONFIG_H263_DECODER
4294  case AV_CODEC_ID_H263:
4295 #endif
4296 #if CONFIG_MPEG4_DECODER
4297  case AV_CODEC_ID_MPEG4:
4298 #endif
4299  st->codecpar->width = 0; /* let decoder init width/height */
4300  st->codecpar->height= 0;
4301  break;
4302  }
4303 
4304  // If the duration of the mp3 packets is not constant, then they could need a parser
4305  if (st->codecpar->codec_id == AV_CODEC_ID_MP3
4306  && sc->stts_count > 3
4307  && sc->stts_count*10 > st->nb_frames
4308  && sc->time_scale == st->codecpar->sample_rate) {
4310  }
4311  /* Do not need those anymore. */
4312  av_freep(&sc->chunk_offsets);
4313  av_freep(&sc->sample_sizes);
4314  av_freep(&sc->keyframes);
4315  av_freep(&sc->stts_data);
4316  av_freep(&sc->stps_data);
4317  av_freep(&sc->elst_data);
4318  av_freep(&sc->rap_group);
4319 
4320  return 0;
4321 }
4322 
4324 {
4325  int ret;
4326  c->itunes_metadata = 1;
4327  ret = mov_read_default(c, pb, atom);
4328  c->itunes_metadata = 0;
4329  return ret;
4330 }
4331 
4333 {
4334  uint32_t count;
4335  uint32_t i;
4336 
4337  if (atom.size < 8)
4338  return 0;
4339 
4340  avio_skip(pb, 4);
4341  count = avio_rb32(pb);
4342  if (count > UINT_MAX / sizeof(*c->meta_keys) - 1) {
4343  av_log(c->fc, AV_LOG_ERROR,
4344  "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
4345  return AVERROR_INVALIDDATA;
4346  }
4347 
4348  c->meta_keys_count = count + 1;
4349  c->meta_keys = av_mallocz(c->meta_keys_count * sizeof(*c->meta_keys));
4350  if (!c->meta_keys)
4351  return AVERROR(ENOMEM);
4352 
4353  for (i = 1; i <= count; ++i) {
4354  uint32_t key_size = avio_rb32(pb);
4355  uint32_t type = avio_rl32(pb);
4356  if (key_size < 8) {
4357  av_log(c->fc, AV_LOG_ERROR,
4358  "The key# %"PRIu32" in meta has invalid size:"
4359  "%"PRIu32"\n", i, key_size);
4360  return AVERROR_INVALIDDATA;
4361  }
4362  key_size -= 8;
4363  if (type != MKTAG('m','d','t','a')) {
4364  avio_skip(pb, key_size);
4365  }
4366  c->meta_keys[i] = av_mallocz(key_size + 1);
4367  if (!c->meta_keys[i])
4368  return AVERROR(ENOMEM);
4369  avio_read(pb, c->meta_keys[i], key_size);
4370  }
4371 
4372  return 0;
4373 }
4374 
4376 {
4377  int64_t end = avio_tell(pb) + atom.size;
4378  uint8_t *key = NULL, *val = NULL, *mean = NULL;
4379  int i;
4380  int ret = 0;
4381  AVStream *st;
4382  MOVStreamContext *sc;
4383 
4384  if (c->fc->nb_streams < 1)
4385  return 0;
4386  st = c->fc->streams[c->fc->nb_streams-1];
4387  sc = st->priv_data;
4388 
4389  for (i = 0; i < 3; i++) {
4390  uint8_t **p;
4391  uint32_t len, tag;
4392 
4393  if (end - avio_tell(pb) <= 12)
4394  break;
4395 
4396  len = avio_rb32(pb);
4397  tag = avio_rl32(pb);
4398  avio_skip(pb, 4); // flags
4399 
4400  if (len < 12 || len - 12 > end - avio_tell(pb))
4401  break;
4402  len -= 12;
4403 
4404  if (tag == MKTAG('m', 'e', 'a', 'n'))
4405  p = &mean;
4406  else if (tag == MKTAG('n', 'a', 'm', 'e'))
4407  p = &key;
4408  else if (tag == MKTAG('d', 'a', 't', 'a') && len > 4) {
4409  avio_skip(pb, 4);
4410  len -= 4;
4411  p = &val;
4412  } else
4413  break;
4414 
4415  *p = av_malloc(len + 1);
4416  if (!*p) {
4417  ret = AVERROR(ENOMEM);
4418  break;
4419  }
4420  ret = ffio_read_size(pb, *p, len);
4421  if (ret < 0) {
4422  av_freep(p);
4423  break;
4424  }
4425  (*p)[len] = 0;
4426  }
4427 
4428  if (mean && key && val) {
4429  if (strcmp(key, "iTunSMPB") == 0) {
4430  int priming, remainder, samples;
4431  if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
4432  if(priming>0 && priming<16384)
4433  sc->start_pad = priming;
4434  }
4435  }
4436  if (strcmp(key, "cdec") != 0) {
4437  av_dict_set(&c->fc->metadata, key, val,
4439  key = val = NULL;
4440  }
4441  } else {
4442  av_log(c->fc, AV_LOG_VERBOSE,
4443  "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
4444  }
4445 
4446  avio_seek(pb, end, SEEK_SET);
4447  av_freep(&key);
4448  av_freep(&val);
4449  av_freep(&mean);
4450  return ret;
4451 }
4452 
4454 {
4455  while (atom.size > 8) {
4456  uint32_t tag;
4457  if (avio_feof(pb))
4458  return AVERROR_EOF;
4459  tag = avio_rl32(pb);
4460  atom.size -= 4;
4461  if (tag == MKTAG('h','d','l','r')) {
4462  avio_seek(pb, -8, SEEK_CUR);
4463  atom.size += 8;
4464  return mov_read_default(c, pb, atom);
4465  }
4466  }
4467  return 0;
4468 }
4469 
4470 // return 1 when matrix is identity, 0 otherwise
4471 #define IS_MATRIX_IDENT(matrix) \
4472  ( (matrix)[0][0] == (1 << 16) && \
4473  (matrix)[1][1] == (1 << 16) && \
4474  (matrix)[2][2] == (1 << 30) && \
4475  !(matrix)[0][1] && !(matrix)[0][2] && \
4476  !(matrix)[1][0] && !(matrix)[1][2] && \
4477  !(matrix)[2][0] && !(matrix)[2][1])
4478 
4480 {
4481  int i, j, e;
4482  int width;
4483  int height;
4484  int display_matrix[3][3];
4485  int res_display_matrix[3][3] = { { 0 } };
4486  AVStream *st;
4487  MOVStreamContext *sc;
4488  int version;
4489  int flags;
4490 
4491  if (c->fc->nb_streams < 1)
4492  return 0;
4493  st = c->fc->streams[c->fc->nb_streams-1];
4494  sc = st->priv_data;
4495 
4496  // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
4497  // avoids corrupting AVStreams mapped to an earlier tkhd.
4498  if (st->id != -1)
4499  return AVERROR_INVALIDDATA;
4500 
4501  version = avio_r8(pb);
4502  flags = avio_rb24(pb);
4504 
4505  if (version == 1) {
4506  avio_rb64(pb);
4507  avio_rb64(pb);
4508  } else {
4509  avio_rb32(pb); /* creation time */
4510  avio_rb32(pb); /* modification time */
4511  }
4512  st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
4513  avio_rb32(pb); /* reserved */
4514 
4515  /* highlevel (considering edits) duration in movie timebase */
4516  (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
4517  avio_rb32(pb); /* reserved */
4518  avio_rb32(pb); /* reserved */
4519 
4520  avio_rb16(pb); /* layer */
4521  avio_rb16(pb); /* alternate group */
4522  avio_rb16(pb); /* volume */
4523  avio_rb16(pb); /* reserved */
4524 
4525  //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
4526  // they're kept in fixed point format through all calculations
4527  // save u,v,z to store the whole matrix in the AV_PKT_DATA_DISPLAYMATRIX
4528  // side data, but the scale factor is not needed to calculate aspect ratio
4529  for (i = 0; i < 3; i++) {
4530  display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
4531  display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
4532  display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
4533  }
4534 
4535  width = avio_rb32(pb); // 16.16 fixed point track width
4536  height = avio_rb32(pb); // 16.16 fixed point track height
4537  sc->width = width >> 16;
4538  sc->height = height >> 16;
4539 
4540  // apply the moov display matrix (after the tkhd one)
4541  for (i = 0; i < 3; i++) {
4542  const int sh[3] = { 16, 16, 30 };
4543  for (j = 0; j < 3; j++) {
4544  for (e = 0; e < 3; e++) {
4545  res_display_matrix[i][j] +=
4546  ((int64_t) display_matrix[i][e] *
4547  c->movie_display_matrix[e][j]) >> sh[e];
4548  }
4549  }
4550  }
4551 
4552  // save the matrix when it is not the default identity
4553  if (!IS_MATRIX_IDENT(res_display_matrix)) {
4554  double rotate;
4555 
4556  av_freep(&sc->display_matrix);
4557  sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
4558  if (!sc->display_matrix)
4559  return AVERROR(ENOMEM);
4560 
4561  for (i = 0; i < 3; i++)
4562  for (j = 0; j < 3; j++)
4563  sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
4564 
4567  if (!isnan(rotate)) {
4568  char rotate_buf[64];
4569  rotate = -rotate;
4570  if (rotate < 0) // for backward compatibility
4571  rotate += 360;
4572  snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
4573  av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
4574  }
4575 #endif
4576  }
4577 
4578  // transform the display width/height according to the matrix
4579  // to keep the same scale, use [width height 1<<16]
4580  if (width && height && sc->display_matrix) {
4581  double disp_transform[2];
4582 
4583  for (i = 0; i < 2; i++)
4584  disp_transform[i] = hypot(sc->display_matrix[0 + i],
4585  sc->display_matrix[3 + i]);
4586 
4587  if (disp_transform[0] > 0 && disp_transform[1] > 0 &&
4588  disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4589  fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4591  disp_transform[0] / disp_transform[1],
4592  INT_MAX);
4593  }
4594  return 0;
4595 }
4596 
4598 {
4599  MOVFragment *frag = &c->fragment;
4600  MOVTrackExt *trex = NULL;
4601  int flags, track_id, i;
4602 
4603  avio_r8(pb); /* version */
4604  flags = avio_rb24(pb);
4605 
4606  track_id = avio_rb32(pb);
4607  if (!track_id)
4608  return AVERROR_INVALIDDATA;
4609  for (i = 0; i < c->trex_count; i++)
4610  if (c->trex_data[i].track_id == track_id) {
4611  trex = &c->trex_data[i];
4612  break;
4613  }
4614  if (!trex) {
4615  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding trex (id %u)\n", track_id);
4616  return 0;
4617  }
4618  c->fragment.found_tfhd = 1;
4619  frag->track_id = track_id;
4620  set_frag_stream(&c->frag_index, track_id);
4621 
4624  frag->moof_offset : frag->implicit_offset;
4625  frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
4626 
4627  frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
4628  avio_rb32(pb) : trex->duration;
4629  frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
4630  avio_rb32(pb) : trex->size;
4631  frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
4632  avio_rb32(pb) : trex->flags;
4633  av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
4634 
4635  return 0;
4636 }
4637 
4639 {
4640  unsigned i, num;
4641  void *new_tracks;
4642 
4643  num = atom.size / 4;
4644  if (!(new_tracks = av_malloc_array(num, sizeof(int))))
4645  return AVERROR(ENOMEM);
4646 
4647  av_free(c->chapter_tracks);
4648  c->chapter_tracks = new_tracks;
4649  c->nb_chapter_tracks = num;
4650 
4651  for (i = 0; i < num && !pb->eof_reached; i++)
4652  c->chapter_tracks[i] = avio_rb32(pb);
4653 
4654  return 0;
4655 }
4656 
4658 {
4659  MOVTrackExt *trex;
4660  int err;
4661 
4662  if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
4663  return AVERROR_INVALIDDATA;
4664  if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
4665  sizeof(*c->trex_data))) < 0) {
4666  c->trex_count = 0;
4667  return err;
4668  }
4669 
4670  c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
4671 
4672  trex = &c->trex_data[c->trex_count++];
4673  avio_r8(pb); /* version */
4674  avio_rb24(pb); /* flags */
4675  trex->track_id = avio_rb32(pb);
4676  trex->stsd_id = avio_rb32(pb);
4677  trex->duration = avio_rb32(pb);
4678  trex->size = avio_rb32(pb);
4679  trex->flags = avio_rb32(pb);
4680  return 0;
4681 }