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