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