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