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