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