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