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