FFmpeg  4.2.2
mov.c
Go to the documentation of this file.
1 /*
2  * MOV demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
5  *
6  * first version by Francois Revol <revol@free.fr>
7  * seek function by Gael Chardon <gael.dev@4now.net>
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include <inttypes.h>
27 #include <limits.h>
28 #include <stdint.h>
29 
30 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/intfloat.h"
35 #include "libavutil/mathematics.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/display.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/aes.h"
43 #include "libavutil/aes_ctr.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/sha.h"
46 #include "libavutil/spherical.h"
47 #include "libavutil/stereo3d.h"
48 #include "libavutil/timecode.h"
49 #include "libavcodec/ac3tab.h"
50 #include "libavcodec/flac.h"
52 #include "avformat.h"
53 #include "internal.h"
54 #include "avio_internal.h"
55 #include "riff.h"
56 #include "isom.h"
57 #include "libavcodec/get_bits.h"
58 #include "id3v1.h"
59 #include "mov_chan.h"
60 #include "replaygain.h"
61 
62 #if CONFIG_ZLIB
63 #include <zlib.h>
64 #endif
65 
66 #include "qtpalette.h"
67 
68 /* those functions parse an atom */
69 /* links atom IDs to parse functions */
70 typedef struct MOVParseTableEntry {
71  uint32_t type;
74 
75 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
76 static int mov_read_mfra(MOVContext *c, AVIOContext *f);
77 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
78  int count, int duration);
79 
81  unsigned len, const char *key)
82 {
83  char buf[16];
84 
85  short current, total = 0;
86  avio_rb16(pb); // unknown
87  current = avio_rb16(pb);
88  if (len >= 6)
89  total = avio_rb16(pb);
90  if (!total)
91  snprintf(buf, sizeof(buf), "%d", current);
92  else
93  snprintf(buf, sizeof(buf), "%d/%d", current, total);
95  av_dict_set(&c->fc->metadata, key, buf, 0);
96 
97  return 0;
98 }
99 
101  unsigned len, const char *key)
102 {
103  /* bypass padding bytes */
104  avio_r8(pb);
105  avio_r8(pb);
106  avio_r8(pb);
107 
109  av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
110 
111  return 0;
112 }
113 
115  unsigned len, const char *key)
116 {
118  av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
119 
120  return 0;
121 }
122 
124  unsigned len, const char *key)
125 {
126  short genre;
127 
128  avio_r8(pb); // unknown
129 
130  genre = avio_r8(pb);
131  if (genre < 1 || genre > ID3v1_GENRE_MAX)
132  return 0;
134  av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
135 
136  return 0;
137 }
138 
139 static const uint32_t mac_to_unicode[128] = {
140  0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
141  0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
142  0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
143  0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
144  0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
145  0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
146  0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
147  0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
148  0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
149  0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
150  0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
151  0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
152  0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
153  0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
154  0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
155  0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
156 };
157 
159  char *dst, int dstlen)
160 {
161  char *p = dst;
162  char *end = dst+dstlen-1;
163  int i;
164 
165  for (i = 0; i < len; i++) {
166  uint8_t t, c = avio_r8(pb);
167 
168  if (p >= end)
169  continue;
170 
171  if (c < 0x80)
172  *p++ = c;
173  else if (p < end)
174  PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
175  }
176  *p = 0;
177  return p - dst;
178 }
179 
180 static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
181 {
182  AVPacket pkt;
183  AVStream *st;
184  MOVStreamContext *sc;
185  enum AVCodecID id;
186  int ret;
187 
188  switch (type) {
189  case 0xd: id = AV_CODEC_ID_MJPEG; break;
190  case 0xe: id = AV_CODEC_ID_PNG; break;
191  case 0x1b: id = AV_CODEC_ID_BMP; break;
192  default:
193  av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
194  avio_skip(pb, len);
195  return 0;
196  }
197 
198  st = avformat_new_stream(c->fc, NULL);
199  if (!st)
200  return AVERROR(ENOMEM);
201  sc = av_mallocz(sizeof(*sc));
202  if (!sc)
203  return AVERROR(ENOMEM);
204  st->priv_data = sc;
205 
206  ret = av_get_packet(pb, &pkt, len);
207  if (ret < 0)
208  return ret;
209 
210  if (pkt.size >= 8 && id != AV_CODEC_ID_BMP) {
211  if (AV_RB64(pkt.data) == 0x89504e470d0a1a0a) {
212  id = AV_CODEC_ID_PNG;
213  } else {
214  id = AV_CODEC_ID_MJPEG;
215  }
216  }
217 
219 
220  st->attached_pic = pkt;
221  st->attached_pic.stream_index = st->index;
223 
225  st->codecpar->codec_id = id;
226 
227  return 0;
228 }
229 
230 // 3GPP TS 26.244
231 static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
232 {
233  char language[4] = { 0 };
234  char buf[200], place[100];
235  uint16_t langcode = 0;
236  double longitude, latitude, altitude;
237  const char *key = "location";
238 
239  if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4) {
240  av_log(c->fc, AV_LOG_ERROR, "loci too short\n");
241  return AVERROR_INVALIDDATA;
242  }
243 
244  avio_skip(pb, 4); // version+flags
245  langcode = avio_rb16(pb);
246  ff_mov_lang_to_iso639(langcode, language);
247  len -= 6;
248 
249  len -= avio_get_str(pb, len, place, sizeof(place));
250  if (len < 1) {
251  av_log(c->fc, AV_LOG_ERROR, "place name too long\n");
252  return AVERROR_INVALIDDATA;
253  }
254  avio_skip(pb, 1); // role
255  len -= 1;
256 
257  if (len < 12) {
258  av_log(c->fc, AV_LOG_ERROR,
259  "loci too short (%u bytes left, need at least %d)\n", len, 12);
260  return AVERROR_INVALIDDATA;
261  }
262  longitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
263  latitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
264  altitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
265 
266  // Try to output in the same format as the ?xyz field
267  snprintf(buf, sizeof(buf), "%+08.4f%+09.4f", latitude, longitude);
268  if (altitude)
269  av_strlcatf(buf, sizeof(buf), "%+f", altitude);
270  av_strlcatf(buf, sizeof(buf), "/%s", place);
271 
272  if (*language && strcmp(language, "und")) {
273  char key2[16];
274  snprintf(key2, sizeof(key2), "%s-%s", key, language);
275  av_dict_set(&c->fc->metadata, key2, buf, 0);
276  }
278  return av_dict_set(&c->fc->metadata, key, buf, 0);
279 }
280 
281 static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
282 {
283  int i, n_hmmt;
284 
285  if (len < 2)
286  return 0;
287  if (c->ignore_chapters)
288  return 0;
289 
290  n_hmmt = avio_rb32(pb);
291  for (i = 0; i < n_hmmt && !pb->eof_reached; i++) {
292  int moment_time = avio_rb32(pb);
293  avpriv_new_chapter(c->fc, i, av_make_q(1, 1000), moment_time, AV_NOPTS_VALUE, NULL);
294  }
295  return 0;
296 }
297 
299 {
300  char tmp_key[5];
301  char key2[32], language[4] = {0};
302  char *str = NULL;
303  const char *key = NULL;
304  uint16_t langcode = 0;
305  uint32_t data_type = 0, str_size, str_size_alloc;
306  int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
307  int raw = 0;
308  int num = 0;
309 
310  switch (atom.type) {
311  case MKTAG( '@','P','R','M'): key = "premiere_version"; raw = 1; break;
312  case MKTAG( '@','P','R','Q'): key = "quicktime_version"; raw = 1; break;
313  case MKTAG( 'X','M','P','_'):
314  if (c->export_xmp) { key = "xmp"; raw = 1; } break;
315  case MKTAG( 'a','A','R','T'): key = "album_artist"; break;
316  case MKTAG( 'a','k','I','D'): key = "account_type";
318  case MKTAG( 'a','p','I','D'): key = "account_id"; break;
319  case MKTAG( 'c','a','t','g'): key = "category"; break;
320  case MKTAG( 'c','p','i','l'): key = "compilation";
322  case MKTAG( 'c','p','r','t'): key = "copyright"; break;
323  case MKTAG( 'd','e','s','c'): key = "description"; break;
324  case MKTAG( 'd','i','s','k'): key = "disc";
326  case MKTAG( 'e','g','i','d'): key = "episode_uid";
328  case MKTAG( 'F','I','R','M'): key = "firmware"; raw = 1; break;
329  case MKTAG( 'g','n','r','e'): key = "genre";
330  parse = mov_metadata_gnre; break;
331  case MKTAG( 'h','d','v','d'): key = "hd_video";
333  case MKTAG( 'H','M','M','T'):
334  return mov_metadata_hmmt(c, pb, atom.size);
335  case MKTAG( 'k','e','y','w'): key = "keywords"; break;
336  case MKTAG( 'l','d','e','s'): key = "synopsis"; break;
337  case MKTAG( 'l','o','c','i'):
338  return mov_metadata_loci(c, pb, atom.size);
339  case MKTAG( 'm','a','n','u'): key = "make"; break;
340  case MKTAG( 'm','o','d','l'): key = "model"; break;
341  case MKTAG( 'p','c','s','t'): key = "podcast";
343  case MKTAG( 'p','g','a','p'): key = "gapless_playback";
345  case MKTAG( 'p','u','r','d'): key = "purchase_date"; break;
346  case MKTAG( 'r','t','n','g'): key = "rating";
348  case MKTAG( 's','o','a','a'): key = "sort_album_artist"; break;
349  case MKTAG( 's','o','a','l'): key = "sort_album"; break;
350  case MKTAG( 's','o','a','r'): key = "sort_artist"; break;
351  case MKTAG( 's','o','c','o'): key = "sort_composer"; break;
352  case MKTAG( 's','o','n','m'): key = "sort_name"; break;
353  case MKTAG( 's','o','s','n'): key = "sort_show"; break;
354  case MKTAG( 's','t','i','k'): key = "media_type";
356  case MKTAG( 't','r','k','n'): key = "track";
358  case MKTAG( 't','v','e','n'): key = "episode_id"; break;
359  case MKTAG( 't','v','e','s'): key = "episode_sort";
361  case MKTAG( 't','v','n','n'): key = "network"; break;
362  case MKTAG( 't','v','s','h'): key = "show"; break;
363  case MKTAG( 't','v','s','n'): key = "season_number";
365  case MKTAG(0xa9,'A','R','T'): key = "artist"; break;
366  case MKTAG(0xa9,'P','R','D'): key = "producer"; break;
367  case MKTAG(0xa9,'a','l','b'): key = "album"; break;
368  case MKTAG(0xa9,'a','u','t'): key = "artist"; break;
369  case MKTAG(0xa9,'c','h','p'): key = "chapter"; break;
370  case MKTAG(0xa9,'c','m','t'): key = "comment"; break;
371  case MKTAG(0xa9,'c','o','m'): key = "composer"; break;
372  case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
373  case MKTAG(0xa9,'d','a','y'): key = "date"; break;
374  case MKTAG(0xa9,'d','i','r'): key = "director"; break;
375  case MKTAG(0xa9,'d','i','s'): key = "disclaimer"; break;
376  case MKTAG(0xa9,'e','d','1'): key = "edit_date"; break;
377  case MKTAG(0xa9,'e','n','c'): key = "encoder"; break;
378  case MKTAG(0xa9,'f','m','t'): key = "original_format"; break;
379  case MKTAG(0xa9,'g','e','n'): key = "genre"; break;
380  case MKTAG(0xa9,'g','r','p'): key = "grouping"; break;
381  case MKTAG(0xa9,'h','s','t'): key = "host_computer"; break;
382  case MKTAG(0xa9,'i','n','f'): key = "comment"; break;
383  case MKTAG(0xa9,'l','y','r'): key = "lyrics"; break;
384  case MKTAG(0xa9,'m','a','k'): key = "make"; break;
385  case MKTAG(0xa9,'m','o','d'): key = "model"; break;
386  case MKTAG(0xa9,'n','a','m'): key = "title"; break;
387  case MKTAG(0xa9,'o','p','e'): key = "original_artist"; break;
388  case MKTAG(0xa9,'p','r','d'): key = "producer"; break;
389  case MKTAG(0xa9,'p','r','f'): key = "performers"; break;
390  case MKTAG(0xa9,'r','e','q'): key = "playback_requirements"; break;
391  case MKTAG(0xa9,'s','r','c'): key = "original_source"; break;
392  case MKTAG(0xa9,'s','t','3'): key = "subtitle"; break;
393  case MKTAG(0xa9,'s','w','r'): key = "encoder"; break;
394  case MKTAG(0xa9,'t','o','o'): key = "encoder"; break;
395  case MKTAG(0xa9,'t','r','k'): key = "track"; break;
396  case MKTAG(0xa9,'u','r','l'): key = "URL"; break;
397  case MKTAG(0xa9,'w','r','n'): key = "warning"; break;
398  case MKTAG(0xa9,'w','r','t'): key = "composer"; break;
399  case MKTAG(0xa9,'x','y','z'): key = "location"; break;
400  }
401 retry:
402  if (c->itunes_metadata && atom.size > 8) {
403  int data_size = avio_rb32(pb);
404  int tag = avio_rl32(pb);
405  if (tag == MKTAG('d','a','t','a') && data_size <= atom.size) {
406  data_type = avio_rb32(pb); // type
407  avio_rb32(pb); // unknown
408  str_size = data_size - 16;
409  atom.size -= 16;
410 
411  if (atom.type == MKTAG('c', 'o', 'v', 'r')) {
412  int ret = mov_read_covr(c, pb, data_type, str_size);
413  if (ret < 0) {
414  av_log(c->fc, AV_LOG_ERROR, "Error parsing cover art.\n");
415  return ret;
416  }
417  atom.size -= str_size;
418  if (atom.size > 8)
419  goto retry;
420  return ret;
421  } else if (!key && c->found_hdlr_mdta && c->meta_keys) {
422  uint32_t index = AV_RB32(&atom.type);
423  if (index < c->meta_keys_count && index > 0) {
424  key = c->meta_keys[index];
425  } else {
427  "The index of 'data' is out of range: %"PRId32" < 1 or >= %d.\n",
428  index, c->meta_keys_count);
429  }
430  }
431  } else return 0;
432  } else if (atom.size > 4 && key && !c->itunes_metadata && !raw) {
433  str_size = avio_rb16(pb); // string length
434  if (str_size > atom.size) {
435  raw = 1;
436  avio_seek(pb, -2, SEEK_CUR);
437  av_log(c->fc, AV_LOG_WARNING, "UDTA parsing failed retrying raw\n");
438  goto retry;
439  }
440  langcode = avio_rb16(pb);
441  ff_mov_lang_to_iso639(langcode, language);
442  atom.size -= 4;
443  } else
444  str_size = atom.size;
445 
446  if (c->export_all && !key) {
447  snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
448  key = tmp_key;
449  }
450 
451  if (!key)
452  return 0;
453  if (atom.size < 0 || str_size >= INT_MAX/2)
454  return AVERROR_INVALIDDATA;
455 
456  // Allocates enough space if data_type is a int32 or float32 number, otherwise
457  // worst-case requirement for output string in case of utf8 coded input
458  num = (data_type >= 21 && data_type <= 23);
459  str_size_alloc = (num ? 512 : (raw ? str_size : str_size * 2)) + 1;
460  str = av_mallocz(str_size_alloc);
461  if (!str)
462  return AVERROR(ENOMEM);
463 
464  if (parse)
465  parse(c, pb, str_size, key);
466  else {
467  if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
468  mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
469  } else if (data_type == 21) { // BE signed integer, variable size
470  int val = 0;
471  if (str_size == 1)
472  val = (int8_t)avio_r8(pb);
473  else if (str_size == 2)
474  val = (int16_t)avio_rb16(pb);
475  else if (str_size == 3)
476  val = ((int32_t)(avio_rb24(pb)<<8))>>8;
477  else if (str_size == 4)
478  val = (int32_t)avio_rb32(pb);
479  if (snprintf(str, str_size_alloc, "%d", val) >= str_size_alloc) {
480  av_log(c->fc, AV_LOG_ERROR,
481  "Failed to store the number (%d) in string.\n", val);
482  av_free(str);
483  return AVERROR_INVALIDDATA;
484  }
485  } else if (data_type == 22) { // BE unsigned integer, variable size
486  unsigned int val = 0;
487  if (str_size == 1)
488  val = avio_r8(pb);
489  else if (str_size == 2)
490  val = avio_rb16(pb);
491  else if (str_size == 3)
492  val = avio_rb24(pb);
493  else if (str_size == 4)
494  val = avio_rb32(pb);
495  if (snprintf(str, str_size_alloc, "%u", val) >= str_size_alloc) {
496  av_log(c->fc, AV_LOG_ERROR,
497  "Failed to store the number (%u) in string.\n", val);
498  av_free(str);
499  return AVERROR_INVALIDDATA;
500  }
501  } else if (data_type == 23 && str_size >= 4) { // BE float32
502  float val = av_int2float(avio_rb32(pb));
503  if (snprintf(str, str_size_alloc, "%f", val) >= str_size_alloc) {
504  av_log(c->fc, AV_LOG_ERROR,
505  "Failed to store the float32 number (%f) in string.\n", val);
506  av_free(str);
507  return AVERROR_INVALIDDATA;
508  }
509  } else {
510  int ret = ffio_read_size(pb, str, str_size);
511  if (ret < 0) {
512  av_free(str);
513  return ret;
514  }
515  str[str_size] = 0;
516  }
518  av_dict_set(&c->fc->metadata, key, str, 0);
519  if (*language && strcmp(language, "und")) {
520  snprintf(key2, sizeof(key2), "%s-%s", key, language);
521  av_dict_set(&c->fc->metadata, key2, str, 0);
522  }
523  if (!strcmp(key, "encoder")) {
524  int major, minor, micro;
525  if (sscanf(str, "HandBrake %d.%d.%d", &major, &minor, &micro) == 3) {
526  c->handbrake_version = 1000000*major + 1000*minor + micro;
527  }
528  }
529  }
530 
531  av_freep(&str);
532  return 0;
533 }
534 
536 {
537  int64_t start;
538  int i, nb_chapters, str_len, version;
539  char str[256+1];
540  int ret;
541 
542  if (c->ignore_chapters)
543  return 0;
544 
545  if ((atom.size -= 5) < 0)
546  return 0;
547 
548  version = avio_r8(pb);
549  avio_rb24(pb);
550  if (version)
551  avio_rb32(pb); // ???
552  nb_chapters = avio_r8(pb);
553 
554  for (i = 0; i < nb_chapters; i++) {
555  if (atom.size < 9)
556  return 0;
557 
558  start = avio_rb64(pb);
559  str_len = avio_r8(pb);
560 
561  if ((atom.size -= 9+str_len) < 0)
562  return 0;
563 
564  ret = ffio_read_size(pb, str, str_len);
565  if (ret < 0)
566  return ret;
567  str[str_len] = 0;
568  avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
569  }
570  return 0;
571 }
572 
573 #define MIN_DATA_ENTRY_BOX_SIZE 12
575 {
576  AVStream *st;
577  MOVStreamContext *sc;
578  int entries, i, j;
579 
580  if (c->fc->nb_streams < 1)
581  return 0;
582  st = c->fc->streams[c->fc->nb_streams-1];
583  sc = st->priv_data;
584 
585  avio_rb32(pb); // version + flags
586  entries = avio_rb32(pb);
587  if (!entries ||
588  entries > (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
589  entries >= UINT_MAX / sizeof(*sc->drefs))
590  return AVERROR_INVALIDDATA;
591  sc->drefs_count = 0;
592  av_free(sc->drefs);
593  sc->drefs_count = 0;
594  sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
595  if (!sc->drefs)
596  return AVERROR(ENOMEM);
597  sc->drefs_count = entries;
598 
599  for (i = 0; i < entries; i++) {
600  MOVDref *dref = &sc->drefs[i];
601  uint32_t size = avio_rb32(pb);
602  int64_t next = avio_tell(pb) + size - 4;
603 
604  if (size < 12)
605  return AVERROR_INVALIDDATA;
606 
607  dref->type = avio_rl32(pb);
608  avio_rb32(pb); // version + flags
609 
610  if (dref->type == MKTAG('a','l','i','s') && size > 150) {
611  /* macintosh alias record */
612  uint16_t volume_len, len;
613  int16_t type;
614  int ret;
615 
616  avio_skip(pb, 10);
617 
618  volume_len = avio_r8(pb);
619  volume_len = FFMIN(volume_len, 27);
620  ret = ffio_read_size(pb, dref->volume, 27);
621  if (ret < 0)
622  return ret;
623  dref->volume[volume_len] = 0;
624  av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
625 
626  avio_skip(pb, 12);
627 
628  len = avio_r8(pb);
629  len = FFMIN(len, 63);
630  ret = ffio_read_size(pb, dref->filename, 63);
631  if (ret < 0)
632  return ret;
633  dref->filename[len] = 0;
634  av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
635 
636  avio_skip(pb, 16);
637 
638  /* read next level up_from_alias/down_to_target */
639  dref->nlvl_from = avio_rb16(pb);
640  dref->nlvl_to = avio_rb16(pb);
641  av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
642  dref->nlvl_from, dref->nlvl_to);
643 
644  avio_skip(pb, 16);
645 
646  for (type = 0; type != -1 && avio_tell(pb) < next; ) {
647  if(avio_feof(pb))
648  return AVERROR_EOF;
649  type = avio_rb16(pb);
650  len = avio_rb16(pb);
651  av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
652  if (len&1)
653  len += 1;
654  if (type == 2) { // absolute path
655  av_free(dref->path);
656  dref->path = av_mallocz(len+1);
657  if (!dref->path)
658  return AVERROR(ENOMEM);
659 
660  ret = ffio_read_size(pb, dref->path, len);
661  if (ret < 0) {
662  av_freep(&dref->path);
663  return ret;
664  }
665  if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
666  len -= volume_len;
667  memmove(dref->path, dref->path+volume_len, len);
668  dref->path[len] = 0;
669  }
670  // trim string of any ending zeros
671  for (j = len - 1; j >= 0; j--) {
672  if (dref->path[j] == 0)
673  len--;
674  else
675  break;
676  }
677  for (j = 0; j < len; j++)
678  if (dref->path[j] == ':' || dref->path[j] == 0)
679  dref->path[j] = '/';
680  av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
681  } else if (type == 0) { // directory name
682  av_free(dref->dir);
683  dref->dir = av_malloc(len+1);
684  if (!dref->dir)
685  return AVERROR(ENOMEM);
686 
687  ret = ffio_read_size(pb, dref->dir, len);
688  if (ret < 0) {
689  av_freep(&dref->dir);
690  return ret;
691  }
692  dref->dir[len] = 0;
693  for (j = 0; j < len; j++)
694  if (dref->dir[j] == ':')
695  dref->dir[j] = '/';
696  av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
697  } else
698  avio_skip(pb, len);
699  }
700  } else {
701  av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x%08"PRIx32" size %"PRIu32"\n",
702  dref->type, size);
703  entries--;
704  i--;
705  }
706  avio_seek(pb, next, SEEK_SET);
707  }
708  return 0;
709 }
710 
712 {
713  AVStream *st;
714  uint32_t type;
715  uint32_t ctype;
716  int64_t title_size;
717  char *title_str;
718  int ret;
719 
720  avio_r8(pb); /* version */
721  avio_rb24(pb); /* flags */
722 
723  /* component type */
724  ctype = avio_rl32(pb);
725  type = avio_rl32(pb); /* component subtype */
726 
727  av_log(c->fc, AV_LOG_TRACE, "ctype=%s\n", av_fourcc2str(ctype));
728  av_log(c->fc, AV_LOG_TRACE, "stype=%s\n", av_fourcc2str(type));
729 
730  if (c->trak_index < 0) { // meta not inside a trak
731  if (type == MKTAG('m','d','t','a')) {
732  c->found_hdlr_mdta = 1;
733  }
734  return 0;
735  }
736 
737  st = c->fc->streams[c->fc->nb_streams-1];
738 
739  if (type == MKTAG('v','i','d','e'))
741  else if (type == MKTAG('s','o','u','n'))
743  else if (type == MKTAG('m','1','a',' '))
745  else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
747 
748  avio_rb32(pb); /* component manufacture */
749  avio_rb32(pb); /* component flags */
750  avio_rb32(pb); /* component flags mask */
751 
752  title_size = atom.size - 24;
753  if (title_size > 0) {
754  if (title_size > FFMIN(INT_MAX, SIZE_MAX-1))
755  return AVERROR_INVALIDDATA;
756  title_str = av_malloc(title_size + 1); /* Add null terminator */
757  if (!title_str)
758  return AVERROR(ENOMEM);
759 
760  ret = ffio_read_size(pb, title_str, title_size);
761  if (ret < 0) {
762  av_freep(&title_str);
763  return ret;
764  }
765  title_str[title_size] = 0;
766  if (title_str[0]) {
767  int off = (!c->isom && title_str[0] == title_size - 1);
768  // flag added so as to not set stream handler name if already set from mdia->hdlr
769  av_dict_set(&st->metadata, "handler_name", title_str + off, AV_DICT_DONT_OVERWRITE);
770  }
771  av_freep(&title_str);
772  }
773 
774  return 0;
775 }
776 
778 {
779  return ff_mov_read_esds(c->fc, pb);
780 }
781 
783 {
784  AVStream *st;
785  enum AVAudioServiceType *ast;
786  int ac3info, acmod, lfeon, bsmod;
787 
788  if (c->fc->nb_streams < 1)
789  return 0;
790  st = c->fc->streams[c->fc->nb_streams-1];
791 
793  sizeof(*ast));
794  if (!ast)
795  return AVERROR(ENOMEM);
796 
797  ac3info = avio_rb24(pb);
798  bsmod = (ac3info >> 14) & 0x7;
799  acmod = (ac3info >> 11) & 0x7;
800  lfeon = (ac3info >> 10) & 0x1;
801  st->codecpar->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
803  if (lfeon)
805  *ast = bsmod;
806  if (st->codecpar->channels > 1 && bsmod == 0x7)
808 
809 #if FF_API_LAVF_AVCTX
811  st->codec->audio_service_type = *ast;
813 #endif
814 
815  return 0;
816 }
817 
819 {
820  AVStream *st;
821  enum AVAudioServiceType *ast;
822  int eac3info, acmod, lfeon, bsmod;
823 
824  if (c->fc->nb_streams < 1)
825  return 0;
826  st = c->fc->streams[c->fc->nb_streams-1];
827 
829  sizeof(*ast));
830  if (!ast)
831  return AVERROR(ENOMEM);
832 
833  /* No need to parse fields for additional independent substreams and its
834  * associated dependent substreams since libavcodec's E-AC-3 decoder
835  * does not support them yet. */
836  avio_rb16(pb); /* data_rate and num_ind_sub */
837  eac3info = avio_rb24(pb);
838  bsmod = (eac3info >> 12) & 0x1f;
839  acmod = (eac3info >> 9) & 0x7;
840  lfeon = (eac3info >> 8) & 0x1;
842  if (lfeon)
845  *ast = bsmod;
846  if (st->codecpar->channels > 1 && bsmod == 0x7)
848 
849 #if FF_API_LAVF_AVCTX
851  st->codec->audio_service_type = *ast;
853 #endif
854 
855  return 0;
856 }
857 
859 {
860  const uint32_t ddts_size = 20;
861  AVStream *st = NULL;
862  uint8_t *buf = NULL;
863  uint32_t frame_duration_code = 0;
864  uint32_t channel_layout_code = 0;
865  GetBitContext gb;
866 
867  buf = av_malloc(ddts_size + AV_INPUT_BUFFER_PADDING_SIZE);
868  if (!buf) {
869  return AVERROR(ENOMEM);
870  }
871  if (avio_read(pb, buf, ddts_size) < ddts_size) {
872  av_free(buf);
873  return AVERROR_INVALIDDATA;
874  }
875 
876  init_get_bits(&gb, buf, 8*ddts_size);
877 
878  if (c->fc->nb_streams < 1) {
879  av_free(buf);
880  return 0;
881  }
882  st = c->fc->streams[c->fc->nb_streams-1];
883 
884  st->codecpar->sample_rate = get_bits_long(&gb, 32);
885  if (st->codecpar->sample_rate <= 0) {
886  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
887  av_free(buf);
888  return AVERROR_INVALIDDATA;
889  }
890  skip_bits_long(&gb, 32); /* max bitrate */
891  st->codecpar->bit_rate = get_bits_long(&gb, 32);
892  st->codecpar->bits_per_coded_sample = get_bits(&gb, 8);
893  frame_duration_code = get_bits(&gb, 2);
894  skip_bits(&gb, 30); /* various fields */
895  channel_layout_code = get_bits(&gb, 16);
896 
897  st->codecpar->frame_size =
898  (frame_duration_code == 0) ? 512 :
899  (frame_duration_code == 1) ? 1024 :
900  (frame_duration_code == 2) ? 2048 :
901  (frame_duration_code == 3) ? 4096 : 0;
902 
903  if (channel_layout_code > 0xff) {
904  av_log(c->fc, AV_LOG_WARNING, "Unsupported DTS audio channel layout");
905  }
906  st->codecpar->channel_layout =
907  ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
908  ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
909  ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
910  ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
911  ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
912  ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0);
913 
915  av_free(buf);
916 
917  return 0;
918 }
919 
921 {
922  AVStream *st;
923 
924  if (c->fc->nb_streams < 1)
925  return 0;
926  st = c->fc->streams[c->fc->nb_streams-1];
927 
928  if (atom.size < 16)
929  return 0;
930 
931  /* skip version and flags */
932  avio_skip(pb, 4);
933 
934  ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
935 
936  return 0;
937 }
938 
940 {
941  AVStream *st;
942  int ret;
943 
944  if (c->fc->nb_streams < 1)
945  return 0;
946  st = c->fc->streams[c->fc->nb_streams-1];
947 
948  if ((ret = ff_get_wav_header(c->fc, pb, st->codecpar, atom.size, 0)) < 0)
949  av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
950 
951  return ret;
952 }
953 
955 {
956  const int num = avio_rb32(pb);
957  const int den = avio_rb32(pb);
958  AVStream *st;
959 
960  if (c->fc->nb_streams < 1)
961  return 0;
962  st = c->fc->streams[c->fc->nb_streams-1];
963 
964  if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
965  (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
967  "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
969  num, den);
970  } else if (den != 0) {
972  num, den, 32767);
973  }
974  return 0;
975 }
976 
977 /* this atom contains actual media data */
979 {
980  if (atom.size == 0) /* wrong one (MP4) */
981  return 0;
982  c->found_mdat=1;
983  return 0; /* now go for moov */
984 }
985 
986 #define DRM_BLOB_SIZE 56
987 
989 {
990  uint8_t intermediate_key[20];
991  uint8_t intermediate_iv[20];
992  uint8_t input[64];
993  uint8_t output[64];
994  uint8_t file_checksum[20];
995  uint8_t calculated_checksum[20];
996  struct AVSHA *sha;
997  int i;
998  int ret = 0;
999  uint8_t *activation_bytes = c->activation_bytes;
1000  uint8_t *fixed_key = c->audible_fixed_key;
1001 
1002  c->aax_mode = 1;
1003 
1004  sha = av_sha_alloc();
1005  if (!sha)
1006  return AVERROR(ENOMEM);
1007  c->aes_decrypt = av_aes_alloc();
1008  if (!c->aes_decrypt) {
1009  ret = AVERROR(ENOMEM);
1010  goto fail;
1011  }
1012 
1013  /* drm blob processing */
1014  avio_read(pb, output, 8); // go to offset 8, absolute position 0x251
1015  avio_read(pb, input, DRM_BLOB_SIZE);
1016  avio_read(pb, output, 4); // go to offset 4, absolute position 0x28d
1017  avio_read(pb, file_checksum, 20);
1018 
1019  av_log(c->fc, AV_LOG_INFO, "[aax] file checksum == "); // required by external tools
1020  for (i = 0; i < 20; i++)
1021  av_log(c->fc, AV_LOG_INFO, "%02x", file_checksum[i]);
1022  av_log(c->fc, AV_LOG_INFO, "\n");
1023 
1024  /* verify activation data */
1025  if (!activation_bytes) {
1026  av_log(c->fc, AV_LOG_WARNING, "[aax] activation_bytes option is missing!\n");
1027  ret = 0; /* allow ffprobe to continue working on .aax files */
1028  goto fail;
1029  }
1030  if (c->activation_bytes_size != 4) {
1031  av_log(c->fc, AV_LOG_FATAL, "[aax] activation_bytes value needs to be 4 bytes!\n");
1032  ret = AVERROR(EINVAL);
1033  goto fail;
1034  }
1035 
1036  /* verify fixed key */
1037  if (c->audible_fixed_key_size != 16) {
1038  av_log(c->fc, AV_LOG_FATAL, "[aax] audible_fixed_key value needs to be 16 bytes!\n");
1039  ret = AVERROR(EINVAL);
1040  goto fail;
1041  }
1042 
1043  /* AAX (and AAX+) key derivation */
1044  av_sha_init(sha, 160);
1045  av_sha_update(sha, fixed_key, 16);
1046  av_sha_update(sha, activation_bytes, 4);
1047  av_sha_final(sha, intermediate_key);
1048  av_sha_init(sha, 160);
1049  av_sha_update(sha, fixed_key, 16);
1050  av_sha_update(sha, intermediate_key, 20);
1051  av_sha_update(sha, activation_bytes, 4);
1052  av_sha_final(sha, intermediate_iv);
1053  av_sha_init(sha, 160);
1054  av_sha_update(sha, intermediate_key, 16);
1055  av_sha_update(sha, intermediate_iv, 16);
1056  av_sha_final(sha, calculated_checksum);
1057  if (memcmp(calculated_checksum, file_checksum, 20)) { // critical error
1058  av_log(c->fc, AV_LOG_ERROR, "[aax] mismatch in checksums!\n");
1059  ret = AVERROR_INVALIDDATA;
1060  goto fail;
1061  }
1062  av_aes_init(c->aes_decrypt, intermediate_key, 128, 1);
1063  av_aes_crypt(c->aes_decrypt, output, input, DRM_BLOB_SIZE >> 4, intermediate_iv, 1);
1064  for (i = 0; i < 4; i++) {
1065  // file data (in output) is stored in big-endian mode
1066  if (activation_bytes[i] != output[3 - i]) { // critical error
1067  av_log(c->fc, AV_LOG_ERROR, "[aax] error in drm blob decryption!\n");
1068  ret = AVERROR_INVALIDDATA;
1069  goto fail;
1070  }
1071  }
1072  memcpy(c->file_key, output + 8, 16);
1073  memcpy(input, output + 26, 16);
1074  av_sha_init(sha, 160);
1075  av_sha_update(sha, input, 16);
1076  av_sha_update(sha, c->file_key, 16);
1077  av_sha_update(sha, fixed_key, 16);
1078  av_sha_final(sha, c->file_iv);
1079 
1080 fail:
1081  av_free(sha);
1082 
1083  return ret;
1084 }
1085 
1086 // Audible AAX (and AAX+) bytestream decryption
1087 static int aax_filter(uint8_t *input, int size, MOVContext *c)
1088 {
1089  int blocks = 0;
1090  unsigned char iv[16];
1091 
1092  memcpy(iv, c->file_iv, 16); // iv is overwritten
1093  blocks = size >> 4; // trailing bytes are not encrypted!
1094  av_aes_init(c->aes_decrypt, c->file_key, 128, 1);
1095  av_aes_crypt(c->aes_decrypt, input, input, blocks, iv, 1);
1096 
1097  return 0;
1098 }
1099 
1100 /* read major brand, minor version and compatible brands and store them as metadata */
1102 {
1103  uint32_t minor_ver;
1104  int comp_brand_size;
1105  char* comp_brands_str;
1106  uint8_t type[5] = {0};
1107  int ret = ffio_read_size(pb, type, 4);
1108  if (ret < 0)
1109  return ret;
1110 
1111  if (strcmp(type, "qt "))
1112  c->isom = 1;
1113  av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
1114  av_dict_set(&c->fc->metadata, "major_brand", type, 0);
1115  minor_ver = avio_rb32(pb); /* minor version */
1116  av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
1117 
1118  comp_brand_size = atom.size - 8;
1119  if (comp_brand_size < 0)
1120  return AVERROR_INVALIDDATA;
1121  comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
1122  if (!comp_brands_str)
1123  return AVERROR(ENOMEM);
1124 
1125  ret = ffio_read_size(pb, comp_brands_str, comp_brand_size);
1126  if (ret < 0) {
1127  av_freep(&comp_brands_str);
1128  return ret;
1129  }
1130  comp_brands_str[comp_brand_size] = 0;
1131  av_dict_set(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
1132  av_freep(&comp_brands_str);
1133 
1134  return 0;
1135 }
1136 
1137 /* this atom should contain all header atoms */
1139 {
1140  int ret;
1141 
1142  if (c->found_moov) {
1143  av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
1144  avio_skip(pb, atom.size);
1145  return 0;
1146  }
1147 
1148  if ((ret = mov_read_default(c, pb, atom)) < 0)
1149  return ret;
1150  /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
1151  /* so we don't parse the whole file if over a network */
1152  c->found_moov=1;
1153  return 0; /* now go for mdat */
1154 }
1155 
1157  MOVFragmentIndex *frag_index,
1158  int index,
1159  int id)
1160 {
1161  int i;
1162  MOVFragmentIndexItem * item;
1163 
1164  if (index < 0 || index >= frag_index->nb_items)
1165  return NULL;
1166  item = &frag_index->item[index];
1167  for (i = 0; i < item->nb_stream_info; i++)
1168  if (item->stream_info[i].id == id)
1169  return &item->stream_info[i];
1170 
1171  // This shouldn't happen
1172  return NULL;
1173 }
1174 
1175 static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
1176 {
1177  int i;
1178  MOVFragmentIndexItem * item;
1179 
1180  if (frag_index->current < 0 ||
1181  frag_index->current >= frag_index->nb_items)
1182  return;
1183 
1184  item = &frag_index->item[frag_index->current];
1185  for (i = 0; i < item->nb_stream_info; i++)
1186  if (item->stream_info[i].id == id) {
1187  item->current = i;
1188  return;
1189  }
1190 
1191  // id not found. This shouldn't happen.
1192  item->current = -1;
1193 }
1194 
1196  MOVFragmentIndex *frag_index)
1197 {
1198  MOVFragmentIndexItem *item;
1199  if (frag_index->current < 0 ||
1200  frag_index->current >= frag_index->nb_items)
1201  return NULL;
1202 
1203  item = &frag_index->item[frag_index->current];
1204  if (item->current >= 0 && item->current < item->nb_stream_info)
1205  return &item->stream_info[item->current];
1206 
1207  // This shouldn't happen
1208  return NULL;
1209 }
1210 
1211 static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
1212 {
1213  int a, b, m;
1214  int64_t moof_offset;
1215 
1216  // Optimize for appending new entries
1217  if (!frag_index->nb_items ||
1218  frag_index->item[frag_index->nb_items - 1].moof_offset < offset)
1219  return frag_index->nb_items;
1220 
1221  a = -1;
1222  b = frag_index->nb_items;
1223 
1224  while (b - a > 1) {
1225  m = (a + b) >> 1;
1226  moof_offset = frag_index->item[m].moof_offset;
1227  if (moof_offset >= offset)
1228  b = m;
1229  if (moof_offset <= offset)
1230  a = m;
1231  }
1232  return b;
1233 }
1234 
1235 static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
1236 {
1237  av_assert0(frag_stream_info);
1238  if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1239  return frag_stream_info->sidx_pts;
1240  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1241  return frag_stream_info->first_tfra_pts;
1242  return frag_stream_info->tfdt_dts;
1243 }
1244 
1245 static int64_t get_frag_time(MOVFragmentIndex *frag_index,
1246  int index, int track_id)
1247 {
1248  MOVFragmentStreamInfo * frag_stream_info;
1249  int64_t timestamp;
1250  int i;
1251 
1252  if (track_id >= 0) {
1253  frag_stream_info = get_frag_stream_info(frag_index, index, track_id);
1254  return frag_stream_info->sidx_pts;
1255  }
1256 
1257  for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
1258  frag_stream_info = &frag_index->item[index].stream_info[i];
1259  timestamp = get_stream_info_time(frag_stream_info);
1260  if (timestamp != AV_NOPTS_VALUE)
1261  return timestamp;
1262  }
1263  return AV_NOPTS_VALUE;
1264 }
1265 
1267  AVStream *st, int64_t timestamp)
1268 {
1269  int a, b, m, m0;
1270  int64_t frag_time;
1271  int id = -1;
1272 
1273  if (st) {
1274  // If the stream is referenced by any sidx, limit the search
1275  // to fragments that referenced this stream in the sidx
1276  MOVStreamContext *sc = st->priv_data;
1277  if (sc->has_sidx)
1278  id = st->id;
1279  }
1280 
1281  a = -1;
1282  b = frag_index->nb_items;
1283 
1284  while (b - a > 1) {
1285  m0 = m = (a + b) >> 1;
1286 
1287  while (m < b &&
1288  (frag_time = get_frag_time(frag_index, m, id)) == AV_NOPTS_VALUE)
1289  m++;
1290 
1291  if (m < b && frag_time <= timestamp)
1292  a = m;
1293  else
1294  b = m0;
1295  }
1296 
1297  return a;
1298 }
1299 
1300 static int update_frag_index(MOVContext *c, int64_t offset)
1301 {
1302  int index, i;
1303  MOVFragmentIndexItem * item;
1304  MOVFragmentStreamInfo * frag_stream_info;
1305 
1306  // If moof_offset already exists in frag_index, return index to it
1307  index = search_frag_moof_offset(&c->frag_index, offset);
1308  if (index < c->frag_index.nb_items &&
1309  c->frag_index.item[index].moof_offset == offset)
1310  return index;
1311 
1312  // offset is not yet in frag index.
1313  // Insert new item at index (sorted by moof offset)
1314  item = av_fast_realloc(c->frag_index.item,
1316  (c->frag_index.nb_items + 1) *
1317  sizeof(*c->frag_index.item));
1318  if(!item)
1319  return -1;
1320  c->frag_index.item = item;
1321 
1322  frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
1323  sizeof(*item->stream_info));
1324  if (!frag_stream_info)
1325  return -1;
1326 
1327  for (i = 0; i < c->fc->nb_streams; i++) {
1328  // Avoid building frag index if streams lack track id.
1329  if (c->fc->streams[i]->id < 0)
1330  return AVERROR_INVALIDDATA;
1331 
1332  frag_stream_info[i].id = c->fc->streams[i]->id;
1333  frag_stream_info[i].sidx_pts = AV_NOPTS_VALUE;
1334  frag_stream_info[i].tfdt_dts = AV_NOPTS_VALUE;
1335  frag_stream_info[i].first_tfra_pts = AV_NOPTS_VALUE;
1336  frag_stream_info[i].index_entry = -1;
1337  frag_stream_info[i].encryption_index = NULL;
1338  }
1339 
1340  if (index < c->frag_index.nb_items)
1341  memmove(c->frag_index.item + index + 1, c->frag_index.item + index,
1342  (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
1343 
1344  item = &c->frag_index.item[index];
1345  item->headers_read = 0;
1346  item->current = 0;
1347  item->nb_stream_info = c->fc->nb_streams;
1348  item->moof_offset = offset;
1349  item->stream_info = frag_stream_info;
1350  c->frag_index.nb_items++;
1351 
1352  return index;
1353 }
1354 
1355 static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
1356  int id, int entries)
1357 {
1358  int i;
1359  MOVFragmentStreamInfo * frag_stream_info;
1360 
1361  if (index < 0)
1362  return;
1363  for (i = index; i < frag_index->nb_items; i++) {
1364  frag_stream_info = get_frag_stream_info(frag_index, i, id);
1365  if (frag_stream_info && frag_stream_info->index_entry >= 0)
1366  frag_stream_info->index_entry += entries;
1367  }
1368 }
1369 
1371 {
1372  // Set by mov_read_tfhd(). mov_read_trun() will reject files missing tfhd.
1373  c->fragment.found_tfhd = 0;
1374 
1375  if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
1376  c->has_looked_for_mfra = 1;
1377  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1378  int ret;
1379  av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
1380  "for a mfra\n");
1381  if ((ret = mov_read_mfra(c, pb)) < 0) {
1382  av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
1383  "read the mfra (may be a live ismv)\n");
1384  }
1385  } else {
1386  av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
1387  "seekable, can not look for mfra\n");
1388  }
1389  }
1391  av_log(c->fc, AV_LOG_TRACE, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
1393  return mov_read_default(c, pb, atom);
1394 }
1395 
1396 static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
1397 {
1398  if (time) {
1399  if(time >= 2082844800)
1400  time -= 2082844800; /* seconds between 1904-01-01 and Epoch */
1401 
1402  if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
1403  av_log(NULL, AV_LOG_DEBUG, "creation_time is not representable\n");
1404  return;
1405  }
1406 
1407  avpriv_dict_set_timestamp(metadata, "creation_time", time * 1000000);
1408  }
1409 }
1410 
1412 {
1413  AVStream *st;
1414  MOVStreamContext *sc;
1415  int version;
1416  char language[4] = {0};
1417  unsigned lang;
1418  int64_t creation_time;
1419 
1420  if (c->fc->nb_streams < 1)
1421  return 0;
1422  st = c->fc->streams[c->fc->nb_streams-1];
1423  sc = st->priv_data;
1424 
1425  if (sc->time_scale) {
1426  av_log(c->fc, AV_LOG_ERROR, "Multiple mdhd?\n");
1427  return AVERROR_INVALIDDATA;
1428  }
1429 
1430  version = avio_r8(pb);
1431  if (version > 1) {
1432  avpriv_request_sample(c->fc, "Version %d", version);
1433  return AVERROR_PATCHWELCOME;
1434  }
1435  avio_rb24(pb); /* flags */
1436  if (version == 1) {
1437  creation_time = avio_rb64(pb);
1438  avio_rb64(pb);
1439  } else {
1440  creation_time = avio_rb32(pb);
1441  avio_rb32(pb); /* modification time */
1442  }
1443  mov_metadata_creation_time(&st->metadata, creation_time);
1444 
1445  sc->time_scale = avio_rb32(pb);
1446  if (sc->time_scale <= 0) {
1447  av_log(c->fc, AV_LOG_ERROR, "Invalid mdhd time scale %d, defaulting to 1\n", sc->time_scale);
1448  sc->time_scale = 1;
1449  }
1450  st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1451 
1452  lang = avio_rb16(pb); /* language */
1453  if (ff_mov_lang_to_iso639(lang, language))
1454  av_dict_set(&st->metadata, "language", language, 0);
1455  avio_rb16(pb); /* quality */
1456 
1457  return 0;
1458 }
1459 
1461 {
1462  int i;
1463  int64_t creation_time;
1464  int version = avio_r8(pb); /* version */
1465  avio_rb24(pb); /* flags */
1466 
1467  if (version == 1) {
1468  creation_time = avio_rb64(pb);
1469  avio_rb64(pb);
1470  } else {
1471  creation_time = avio_rb32(pb);
1472  avio_rb32(pb); /* modification time */
1473  }
1474  mov_metadata_creation_time(&c->fc->metadata, creation_time);
1475  c->time_scale = avio_rb32(pb); /* time scale */
1476  if (c->time_scale <= 0) {
1477  av_log(c->fc, AV_LOG_ERROR, "Invalid mvhd time scale %d, defaulting to 1\n", c->time_scale);
1478  c->time_scale = 1;
1479  }
1480  av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale);
1481 
1482  c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1483  // set the AVCodecContext duration because the duration of individual tracks
1484  // may be inaccurate
1485  if (c->time_scale > 0 && !c->trex_data)
1487  avio_rb32(pb); /* preferred scale */
1488 
1489  avio_rb16(pb); /* preferred volume */
1490 
1491  avio_skip(pb, 10); /* reserved */
1492 
1493  /* movie display matrix, store it in main context and use it later on */
1494  for (i = 0; i < 3; i++) {
1495  c->movie_display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
1496  c->movie_display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
1497  c->movie_display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
1498  }
1499 
1500  avio_rb32(pb); /* preview time */
1501  avio_rb32(pb); /* preview duration */
1502  avio_rb32(pb); /* poster time */
1503  avio_rb32(pb); /* selection time */
1504  avio_rb32(pb); /* selection duration */
1505  avio_rb32(pb); /* current time */
1506  avio_rb32(pb); /* next track ID */
1507 
1508  return 0;
1509 }
1510 
1512 {
1513  AVStream *st;
1514  int little_endian;
1515 
1516  if (c->fc->nb_streams < 1)
1517  return 0;
1518  st = c->fc->streams[c->fc->nb_streams-1];
1519 
1520  little_endian = avio_rb16(pb) & 0xFF;
1521  av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian);
1522  if (little_endian == 1) {
1523  switch (st->codecpar->codec_id) {
1524  case AV_CODEC_ID_PCM_S24BE:
1526  break;
1527  case AV_CODEC_ID_PCM_S32BE:
1529  break;
1530  case AV_CODEC_ID_PCM_F32BE:
1532  break;
1533  case AV_CODEC_ID_PCM_F64BE:
1535  break;
1536  default:
1537  break;
1538  }
1539  }
1540  return 0;
1541 }
1542 
1544 {
1545  AVStream *st;
1546  char color_parameter_type[5] = { 0 };
1547  uint16_t color_primaries, color_trc, color_matrix;
1548  int ret;
1549 
1550  if (c->fc->nb_streams < 1)
1551  return 0;
1552  st = c->fc->streams[c->fc->nb_streams - 1];
1553 
1554  ret = ffio_read_size(pb, color_parameter_type, 4);
1555  if (ret < 0)
1556  return ret;
1557  if (strncmp(color_parameter_type, "nclx", 4) &&
1558  strncmp(color_parameter_type, "nclc", 4)) {
1559  av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
1560  color_parameter_type);
1561  return 0;
1562  }
1563 
1564  color_primaries = avio_rb16(pb);
1565  color_trc = avio_rb16(pb);
1566  color_matrix = avio_rb16(pb);
1567 
1568  av_log(c->fc, AV_LOG_TRACE,
1569  "%s: pri %d trc %d matrix %d",
1570  color_parameter_type, color_primaries, color_trc, color_matrix);
1571 
1572  if (!strncmp(color_parameter_type, "nclx", 4)) {
1573  uint8_t color_range = avio_r8(pb) >> 7;
1574  av_log(c->fc, AV_LOG_TRACE, " full %"PRIu8"", color_range);
1575  if (color_range)
1577  else
1579  }
1580 
1581  if (!av_color_primaries_name(color_primaries))
1582  color_primaries = AVCOL_PRI_UNSPECIFIED;
1583  if (!av_color_transfer_name(color_trc))
1584  color_trc = AVCOL_TRC_UNSPECIFIED;
1585  if (!av_color_space_name(color_matrix))
1586  color_matrix = AVCOL_SPC_UNSPECIFIED;
1587 
1589  st->codecpar->color_trc = color_trc;
1590  st->codecpar->color_space = color_matrix;
1591  av_log(c->fc, AV_LOG_TRACE, "\n");
1592 
1593  return 0;
1594 }
1595 
1597 {
1598  AVStream *st;
1599  unsigned mov_field_order;
1600  enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
1601 
1602  if (c->fc->nb_streams < 1) // will happen with jp2 files
1603  return 0;
1604  st = c->fc->streams[c->fc->nb_streams-1];
1605  if (atom.size < 2)
1606  return AVERROR_INVALIDDATA;
1607  mov_field_order = avio_rb16(pb);
1608  if ((mov_field_order & 0xFF00) == 0x0100)
1609  decoded_field_order = AV_FIELD_PROGRESSIVE;
1610  else if ((mov_field_order & 0xFF00) == 0x0200) {
1611  switch (mov_field_order & 0xFF) {
1612  case 0x01: decoded_field_order = AV_FIELD_TT;
1613  break;
1614  case 0x06: decoded_field_order = AV_FIELD_BB;
1615  break;
1616  case 0x09: decoded_field_order = AV_FIELD_TB;
1617  break;
1618  case 0x0E: decoded_field_order = AV_FIELD_BT;
1619  break;
1620  }
1621  }
1622  if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
1623  av_log(NULL, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
1624  }
1625  st->codecpar->field_order = decoded_field_order;
1626 
1627  return 0;
1628 }
1629 
1631 {
1632  int err = 0;
1633  uint64_t size = (uint64_t)par->extradata_size + atom.size + 8 + AV_INPUT_BUFFER_PADDING_SIZE;
1634  if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
1635  return AVERROR_INVALIDDATA;
1636  if ((err = av_reallocp(&par->extradata, size)) < 0) {
1637  par->extradata_size = 0;
1638  return err;
1639  }
1641  return 0;
1642 }
1643 
1644 /* Read a whole atom into the extradata return the size of the atom read, possibly truncated if != atom.size */
1646  AVCodecParameters *par, uint8_t *buf)
1647 {
1648  int64_t result = atom.size;
1649  int err;
1650 
1651  AV_WB32(buf , atom.size + 8);
1652  AV_WL32(buf + 4, atom.type);
1653  err = ffio_read_size(pb, buf + 8, atom.size);
1654  if (err < 0) {
1655  par->extradata_size -= atom.size;
1656  return err;
1657  } else if (err < atom.size) {
1658  av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
1659  par->extradata_size -= atom.size - err;
1660  result = err;
1661  }
1662  memset(buf + 8 + err, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1663  return result;
1664 }
1665 
1666 /* FIXME modify QDM2/SVQ3/H.264 decoders to take full atom as extradata */
1668  enum AVCodecID codec_id)
1669 {
1670  AVStream *st;
1671  uint64_t original_size;
1672  int err;
1673 
1674  if (c->fc->nb_streams < 1) // will happen with jp2 files
1675  return 0;
1676  st = c->fc->streams[c->fc->nb_streams-1];
1677 
1678  if (st->codecpar->codec_id != codec_id)
1679  return 0; /* unexpected codec_id - don't mess with extradata */
1680 
1681  original_size = st->codecpar->extradata_size;
1682  err = mov_realloc_extradata(st->codecpar, atom);
1683  if (err)
1684  return err;
1685 
1686  err = mov_read_atom_into_extradata(c, pb, atom, st->codecpar, st->codecpar->extradata + original_size);
1687  if (err < 0)
1688  return err;
1689  return 0; // Note: this is the original behavior to ignore truncation.
1690 }
1691 
1692 /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
1694 {
1695  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
1696 }
1697 
1699 {
1700  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
1701 }
1702 
1704 {
1705  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
1706 }
1707 
1709 {
1710  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
1711 }
1712 
1714 {
1715  int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
1716  if(ret == 0)
1717  ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_DNXHD);
1718  return ret;
1719 }
1720 
1722 {
1723  int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
1724 
1725  if (!ret && c->fc->nb_streams >= 1) {
1726  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1727  if (par->extradata_size >= 40) {
1728  par->height = AV_RB16(&par->extradata[36]);
1729  par->width = AV_RB16(&par->extradata[38]);
1730  }
1731  }
1732  return ret;
1733 }
1734 
1736 {
1737  if (c->fc->nb_streams >= 1) {
1738  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1739  if (par->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
1740  par->codec_id == AV_CODEC_ID_H264 &&
1741  atom.size > 11) {
1742  int cid;
1743  avio_skip(pb, 10);
1744  cid = avio_rb16(pb);
1745  /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
1746  if (cid == 0xd4d || cid == 0xd4e)
1747  par->width = 1440;
1748  return 0;
1749  } else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
1750  par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
1751  par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
1752  atom.size >= 24) {
1753  int num, den;
1754  avio_skip(pb, 12);
1755  num = avio_rb32(pb);
1756  den = avio_rb32(pb);
1757  if (num <= 0 || den <= 0)
1758  return 0;
1759  switch (avio_rb32(pb)) {
1760  case 2:
1761  if (den >= INT_MAX / 2)
1762  return 0;
1763  den *= 2;
1764  case 1:
1765  c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.num = num;
1766  c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.den = den;
1767  default:
1768  return 0;
1769  }
1770  }
1771  }
1772 
1773  return mov_read_avid(c, pb, atom);
1774 }
1775 
1777 {
1778  int ret = 0;
1779  int length = 0;
1780  uint64_t original_size;
1781  if (c->fc->nb_streams >= 1) {
1782  AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1783  if (par->codec_id == AV_CODEC_ID_H264)
1784  return 0;
1785  if (atom.size == 16) {
1786  original_size = par->extradata_size;
1787  ret = mov_realloc_extradata(par, atom);
1788  if (!ret) {
1789  length = mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
1790  if (length == atom.size) {
1791  const uint8_t range_value = par->extradata[original_size + 19];
1792  switch (range_value) {
1793  case 1:
1795  break;
1796  case 2:
1798  break;
1799  default:
1800  av_log(c, AV_LOG_WARNING, "ignored unknown aclr value (%d)\n", range_value);
1801  break;
1802  }
1803  ff_dlog(c, "color_range: %d\n", par->color_range);
1804  } else {
1805  /* For some reason the whole atom was not added to the extradata */
1806  av_log(c, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
1807  }
1808  } else {
1809  av_log(c, AV_LOG_ERROR, "aclr not decoded - unable to add atom to extradata\n");
1810  }
1811  } else {
1812  av_log(c, AV_LOG_WARNING, "aclr not decoded - unexpected size %"PRId64"\n", atom.size);
1813  }
1814  }
1815 
1816  return ret;
1817 }
1818 
1820 {
1821  return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
1822 }
1823 
1825 {
1826  AVStream *st;
1827  int ret;
1828 
1829  if (c->fc->nb_streams < 1)
1830  return 0;
1831  st = c->fc->streams[c->fc->nb_streams-1];
1832 
1833  if ((uint64_t)atom.size > (1<<30))
1834  return AVERROR_INVALIDDATA;
1835 
1836  if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
1839  // pass all frma atom to codec, needed at least for QDMC and QDM2
1840  av_freep(&st->codecpar->extradata);
1841  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1842  if (ret < 0)
1843  return ret;
1844  } else if (atom.size > 8) { /* to read frma, esds atoms */
1845  if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
1846  uint64_t buffer;
1847  ret = ffio_ensure_seekback(pb, 8);
1848  if (ret < 0)
1849  return ret;
1850  buffer = avio_rb64(pb);
1851  atom.size -= 8;
1852  if ( (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
1853  && buffer >> 32 <= atom.size
1854  && buffer >> 32 >= 8) {
1855  avio_skip(pb, -8);
1856  atom.size += 8;
1857  } else if (!st->codecpar->extradata_size) {
1858 #define ALAC_EXTRADATA_SIZE 36
1860  if (!st->codecpar->extradata)
1861  return AVERROR(ENOMEM);
1864  AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
1865  AV_WB64(st->codecpar->extradata + 12, buffer);
1866  avio_read(pb, st->codecpar->extradata + 20, 16);
1867  avio_skip(pb, atom.size - 24);
1868  return 0;
1869  }
1870  }
1871  if ((ret = mov_read_default(c, pb, atom)) < 0)
1872  return ret;
1873  } else
1874  avio_skip(pb, atom.size);
1875  return 0;
1876 }
1877 
1878 /**
1879  * This function reads atom content and puts data in extradata without tag
1880  * nor size unlike mov_read_extradata.
1881  */
1883 {
1884  AVStream *st;
1885  int ret;
1886 
1887  if (c->fc->nb_streams < 1)
1888  return 0;
1889  st = c->fc->streams[c->fc->nb_streams-1];
1890 
1891  if ((uint64_t)atom.size > (1<<30))
1892  return AVERROR_INVALIDDATA;
1893 
1894  if (atom.size >= 10) {
1895  // Broken files created by legacy versions of libavformat will
1896  // wrap a whole fiel atom inside of a glbl atom.
1897  unsigned size = avio_rb32(pb);
1898  unsigned type = avio_rl32(pb);
1899  avio_seek(pb, -8, SEEK_CUR);
1900  if (type == MKTAG('f','i','e','l') && size == atom.size)
1901  return mov_read_default(c, pb, atom);
1902  }
1903  if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
1904  av_log(c, AV_LOG_WARNING, "ignoring multiple glbl\n");
1905  return 0;
1906  }
1907  av_freep(&st->codecpar->extradata);
1908  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1909  if (ret < 0)
1910  return ret;
1911  if (atom.type == MKTAG('h','v','c','C') && st->codecpar->codec_tag == MKTAG('d','v','h','1'))
1912  /* HEVC-based Dolby Vision derived from hvc1.
1913  Happens to match with an identifier
1914  previously utilized for DV. Thus, if we have
1915  the hvcC extradata box available as specified,
1916  set codec to HEVC */
1918 
1919  return 0;
1920 }
1921 
1923 {
1924  AVStream *st;
1925  uint8_t profile_level;
1926  int ret;
1927 
1928  if (c->fc->nb_streams < 1)
1929  return 0;
1930  st = c->fc->streams[c->fc->nb_streams-1];
1931 
1932  if (atom.size >= (1<<28) || atom.size < 7)
1933  return AVERROR_INVALIDDATA;
1934 
1935  profile_level = avio_r8(pb);
1936  if ((profile_level & 0xf0) != 0xc0)
1937  return 0;
1938 
1939  avio_seek(pb, 6, SEEK_CUR);
1940  av_freep(&st->codecpar->extradata);
1941  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 7);
1942  if (ret < 0)
1943  return ret;
1944 
1945  return 0;
1946 }
1947 
1948 /**
1949  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
1950  * but can have extradata appended at the end after the 40 bytes belonging
1951  * to the struct.
1952  */
1954 {
1955  AVStream *st;
1956  int ret;
1957 
1958  if (c->fc->nb_streams < 1)
1959  return 0;
1960  if (atom.size <= 40)
1961  return 0;
1962  st = c->fc->streams[c->fc->nb_streams-1];
1963 
1964  if ((uint64_t)atom.size > (1<<30))
1965  return AVERROR_INVALIDDATA;
1966 
1967  avio_skip(pb, 40);
1968  av_freep(&st->codecpar->extradata);
1969  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 40);
1970  if (ret < 0)
1971  return ret;
1972 
1973  return 0;
1974 }
1975 
1977 {
1978  AVStream *st;
1979  MOVStreamContext *sc;
1980  unsigned int i, entries;
1981 
1982  if (c->fc->nb_streams < 1)
1983  return 0;
1984  st = c->fc->streams[c->fc->nb_streams-1];
1985  sc = st->priv_data;
1986 
1987  avio_r8(pb); /* version */
1988  avio_rb24(pb); /* flags */
1989 
1990  entries = avio_rb32(pb);
1991 
1992  if (!entries)
1993  return 0;
1994 
1995  if (sc->chunk_offsets)
1996  av_log(c->fc, AV_LOG_WARNING, "Duplicated STCO atom\n");
1997  av_free(sc->chunk_offsets);
1998  sc->chunk_count = 0;
1999  sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2000  if (!sc->chunk_offsets)
2001  return AVERROR(ENOMEM);
2002  sc->chunk_count = entries;
2003 
2004  if (atom.type == MKTAG('s','t','c','o'))
2005  for (i = 0; i < entries && !pb->eof_reached; i++)
2006  sc->chunk_offsets[i] = avio_rb32(pb);
2007  else if (atom.type == MKTAG('c','o','6','4'))
2008  for (i = 0; i < entries && !pb->eof_reached; i++)
2009  sc->chunk_offsets[i] = avio_rb64(pb);
2010  else
2011  return AVERROR_INVALIDDATA;
2012 
2013  sc->chunk_count = i;
2014 
2015  if (pb->eof_reached) {
2016  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STCO atom\n");
2017  return AVERROR_EOF;
2018  }
2019 
2020  return 0;
2021 }
2022 
2023 static int mov_codec_id(AVStream *st, uint32_t format)
2024 {
2025  int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
2026 
2027  if (id <= 0 &&
2028  ((format & 0xFFFF) == 'm' + ('s' << 8) ||
2029  (format & 0xFFFF) == 'T' + ('S' << 8)))
2030  id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
2031 
2032  if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
2034  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
2035  /* skip old ASF MPEG-4 tag */
2036  format && format != MKTAG('m','p','4','s')) {
2038  if (id <= 0)
2039  id = ff_codec_get_id(ff_codec_bmp_tags, format);
2040  if (id > 0)
2042  else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
2044  st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
2046  if (id > 0)
2048  else
2049  id = ff_codec_get_id(ff_codec_movdata_tags, format);
2050  }
2051  }
2052 
2053  st->codecpar->codec_tag = format;
2054 
2055  return id;
2056 }
2057 
2059  AVStream *st, MOVStreamContext *sc)
2060 {
2061  uint8_t codec_name[32] = { 0 };
2062  int64_t stsd_start;
2063  unsigned int len;
2064 
2065  /* The first 16 bytes of the video sample description are already
2066  * read in ff_mov_read_stsd_entries() */
2067  stsd_start = avio_tell(pb) - 16;
2068 
2069  avio_rb16(pb); /* version */
2070  avio_rb16(pb); /* revision level */
2071  avio_rb32(pb); /* vendor */
2072  avio_rb32(pb); /* temporal quality */
2073  avio_rb32(pb); /* spatial quality */
2074 
2075  st->codecpar->width = avio_rb16(pb); /* width */
2076  st->codecpar->height = avio_rb16(pb); /* height */
2077 
2078  avio_rb32(pb); /* horiz resolution */
2079  avio_rb32(pb); /* vert resolution */
2080  avio_rb32(pb); /* data size, always 0 */
2081  avio_rb16(pb); /* frames per samples */
2082 
2083  len = avio_r8(pb); /* codec name, pascal string */
2084  if (len > 31)
2085  len = 31;
2086  mov_read_mac_string(c, pb, len, codec_name, sizeof(codec_name));
2087  if (len < 31)
2088  avio_skip(pb, 31 - len);
2089 
2090  if (codec_name[0])
2091  av_dict_set(&st->metadata, "encoder", codec_name, 0);
2092 
2093  /* codec_tag YV12 triggers an UV swap in rawdec.c */
2094  if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
2095  st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
2096  st->codecpar->width &= ~1;
2097  st->codecpar->height &= ~1;
2098  }
2099  /* Flash Media Server uses tag H.263 with Sorenson Spark */
2100  if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
2101  !strncmp(codec_name, "Sorenson H263", 13))
2103 
2104  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
2105 
2106  avio_seek(pb, stsd_start, SEEK_SET);
2107 
2108  if (ff_get_qtpalette(st->codecpar->codec_id, pb, sc->palette)) {
2109  st->codecpar->bits_per_coded_sample &= 0x1F;
2110  sc->has_palette = 1;
2111  }
2112 }
2113 
2115  AVStream *st, MOVStreamContext *sc)
2116 {
2117  int bits_per_sample, flags;
2118  uint16_t version = avio_rb16(pb);
2119  AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
2120 
2121  avio_rb16(pb); /* revision level */
2122  avio_rb32(pb); /* vendor */
2123 
2124  st->codecpar->channels = avio_rb16(pb); /* channel count */
2125  st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* sample size */
2126  av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codecpar->channels);
2127 
2128  sc->audio_cid = avio_rb16(pb);
2129  avio_rb16(pb); /* packet size = 0 */
2130 
2131  st->codecpar->sample_rate = ((avio_rb32(pb) >> 16));
2132 
2133  // Read QT version 1 fields. In version 0 these do not exist.
2134  av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom);
2135  if (!c->isom ||
2136  (compatible_brands && strstr(compatible_brands->value, "qt ")) ||
2137  (sc->stsd_version == 0 && version > 0)) {
2138  if (version == 1) {
2139  sc->samples_per_frame = avio_rb32(pb);
2140  avio_rb32(pb); /* bytes per packet */
2141  sc->bytes_per_frame = avio_rb32(pb);
2142  avio_rb32(pb); /* bytes per sample */
2143  } else if (version == 2) {
2144  avio_rb32(pb); /* sizeof struct only */
2146  st->codecpar->channels = avio_rb32(pb);
2147  avio_rb32(pb); /* always 0x7F000000 */
2149 
2150  flags = avio_rb32(pb); /* lpcm format specific flag */
2151  sc->bytes_per_frame = avio_rb32(pb);
2152  sc->samples_per_frame = avio_rb32(pb);
2153  if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
2154  st->codecpar->codec_id =
2156  flags);
2157  }
2158  if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
2159  /* can't correctly handle variable sized packet as audio unit */
2160  switch (st->codecpar->codec_id) {
2161  case AV_CODEC_ID_MP2:
2162  case AV_CODEC_ID_MP3:
2164  break;
2165  }
2166  }
2167  }
2168 
2169  if (sc->format == 0) {
2170  if (st->codecpar->bits_per_coded_sample == 8)
2171  st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
2172  else if (st->codecpar->bits_per_coded_sample == 16)
2173  st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
2174  }
2175 
2176  switch (st->codecpar->codec_id) {
2177  case AV_CODEC_ID_PCM_S8:
2178  case AV_CODEC_ID_PCM_U8:
2179  if (st->codecpar->bits_per_coded_sample == 16)
2181  break;
2182  case AV_CODEC_ID_PCM_S16LE:
2183  case AV_CODEC_ID_PCM_S16BE:
2184  if (st->codecpar->bits_per_coded_sample == 8)
2186  else if (st->codecpar->bits_per_coded_sample == 24)
2187  st->codecpar->codec_id =
2190  else if (st->codecpar->bits_per_coded_sample == 32)
2191  st->codecpar->codec_id =
2194  break;
2195  /* set values for old format before stsd version 1 appeared */
2196  case AV_CODEC_ID_MACE3:
2197  sc->samples_per_frame = 6;
2198  sc->bytes_per_frame = 2 * st->codecpar->channels;
2199  break;
2200  case AV_CODEC_ID_MACE6:
2201  sc->samples_per_frame = 6;
2202  sc->bytes_per_frame = 1 * st->codecpar->channels;
2203  break;
2205  sc->samples_per_frame = 64;
2206  sc->bytes_per_frame = 34 * st->codecpar->channels;
2207  break;
2208  case AV_CODEC_ID_GSM:
2209  sc->samples_per_frame = 160;
2210  sc->bytes_per_frame = 33;
2211  break;
2212  default:
2213  break;
2214  }
2215 
2216  bits_per_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2217  if (bits_per_sample) {
2218  st->codecpar->bits_per_coded_sample = bits_per_sample;
2219  sc->sample_size = (bits_per_sample >> 3) * st->codecpar->channels;
2220  }
2221 }
2222 
2224  AVStream *st, MOVStreamContext *sc,
2225  int64_t size)
2226 {
2227  // ttxt stsd contains display flags, justification, background
2228  // color, fonts, and default styles, so fake an atom to read it
2229  MOVAtom fake_atom = { .size = size };
2230  // mp4s contains a regular esds atom
2231  if (st->codecpar->codec_tag != AV_RL32("mp4s"))
2232  mov_read_glbl(c, pb, fake_atom);
2233  st->codecpar->width = sc->width;
2234  st->codecpar->height = sc->height;
2235 }
2236 
2237 static uint32_t yuv_to_rgba(uint32_t ycbcr)
2238 {
2239  uint8_t r, g, b;
2240  int y, cb, cr;
2241 
2242  y = (ycbcr >> 16) & 0xFF;
2243  cr = (ycbcr >> 8) & 0xFF;
2244  cb = ycbcr & 0xFF;
2245 
2246  b = av_clip_uint8((1164 * (y - 16) + 2018 * (cb - 128)) / 1000);
2247  g = av_clip_uint8((1164 * (y - 16) - 813 * (cr - 128) - 391 * (cb - 128)) / 1000);
2248  r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128) ) / 1000);
2249 
2250  return (r << 16) | (g << 8) | b;
2251 }
2252 
2254 {
2255  char buf[256] = {0};
2256  uint8_t *src = st->codecpar->extradata;
2257  int i;
2258 
2259  if (st->codecpar->extradata_size != 64)
2260  return 0;
2261 
2262  if (st->codecpar->width > 0 && st->codecpar->height > 0)
2263  snprintf(buf, sizeof(buf), "size: %dx%d\n",
2264  st->codecpar->width, st->codecpar->height);
2265  av_strlcat(buf, "palette: ", sizeof(buf));
2266 
2267  for (i = 0; i < 16; i++) {
2268  uint32_t yuv = AV_RB32(src + i * 4);
2269  uint32_t rgba = yuv_to_rgba(yuv);
2270 
2271  av_strlcatf(buf, sizeof(buf), "%06"PRIx32"%s", rgba, i != 15 ? ", " : "");
2272  }
2273 
2274  if (av_strlcat(buf, "\n", sizeof(buf)) >= sizeof(buf))
2275  return 0;
2276 
2277  av_freep(&st->codecpar->extradata);
2278  st->codecpar->extradata_size = 0;
2280  if (!st->codecpar->extradata)
2281  return AVERROR(ENOMEM);
2282  st->codecpar->extradata_size = strlen(buf);
2283  memcpy(st->codecpar->extradata, buf, st->codecpar->extradata_size);
2284 
2285  return 0;
2286 }
2287 
2289  AVStream *st, MOVStreamContext *sc,
2290  int64_t size)
2291 {
2292  int ret;
2293 
2294  if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
2295  if ((int)size != size)
2296  return AVERROR(ENOMEM);
2297 
2298  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
2299  if (ret < 0)
2300  return ret;
2301  if (size > 16) {
2302  MOVStreamContext *tmcd_ctx = st->priv_data;
2303  int val;
2304  val = AV_RB32(st->codecpar->extradata + 4);
2305  tmcd_ctx->tmcd_flags = val;
2306  st->avg_frame_rate.num = st->codecpar->extradata[16]; /* number of frame */
2307  st->avg_frame_rate.den = 1;
2308 #if FF_API_LAVF_AVCTX
2310  st->codec->time_base = av_inv_q(st->avg_frame_rate);
2312 #endif
2313  /* adjust for per frame dur in counter mode */
2314  if (tmcd_ctx->tmcd_flags & 0x0008) {
2315  int timescale = AV_RB32(st->codecpar->extradata + 8);
2316  int framedur = AV_RB32(st->codecpar->extradata + 12);
2317  st->avg_frame_rate.num *= timescale;
2318  st->avg_frame_rate.den *= framedur;
2319 #if FF_API_LAVF_AVCTX
2321  st->codec->time_base.den *= timescale;
2322  st->codec->time_base.num *= framedur;
2324 #endif
2325  }
2326  if (size > 30) {
2327  uint32_t len = AV_RB32(st->codecpar->extradata + 18); /* name atom length */
2328  uint32_t format = AV_RB32(st->codecpar->extradata + 22);
2329  if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
2330  uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
2331  if (str_size > 0 && size >= (int)str_size + 26) {
2332  char *reel_name = av_malloc(str_size + 1);
2333  if (!reel_name)
2334  return AVERROR(ENOMEM);
2335  memcpy(reel_name, st->codecpar->extradata + 30, str_size);
2336  reel_name[str_size] = 0; /* Add null terminator */
2337  /* don't add reel_name if emtpy string */
2338  if (*reel_name == 0) {
2339  av_free(reel_name);
2340  } else {
2341  av_dict_set(&st->metadata, "reel_name", reel_name, AV_DICT_DONT_STRDUP_VAL);
2342  }
2343  }
2344  }
2345  }
2346  }
2347  } else {
2348  /* other codec type, just skip (rtp, mp4s ...) */
2349  avio_skip(pb, size);
2350  }
2351  return 0;
2352 }
2353 
2355  AVStream *st, MOVStreamContext *sc)
2356 {
2357  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2358  !st->codecpar->sample_rate && sc->time_scale > 1)
2359  st->codecpar->sample_rate = sc->time_scale;
2360 
2361  /* special codec parameters handling */
2362  switch (st->codecpar->codec_id) {
2363 #if CONFIG_DV_DEMUXER
2364  case AV_CODEC_ID_DVAUDIO:
2366  if (!c->dv_fctx) {
2367  av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
2368  return AVERROR(ENOMEM);
2369  }
2371  if (!c->dv_demux) {
2372  av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
2373  return AVERROR(ENOMEM);
2374  }
2375  sc->dv_audio_container = 1;
2377  break;
2378 #endif
2379  /* no ifdef since parameters are always those */
2380  case AV_CODEC_ID_QCELP:
2381  st->codecpar->channels = 1;
2382  // force sample rate for qcelp when not stored in mov
2383  if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
2384  st->codecpar->sample_rate = 8000;
2385  // FIXME: Why is the following needed for some files?
2386  sc->samples_per_frame = 160;
2387  if (!sc->bytes_per_frame)
2388  sc->bytes_per_frame = 35;
2389  break;
2390  case AV_CODEC_ID_AMR_NB:
2391  st->codecpar->channels = 1;
2392  /* force sample rate for amr, stsd in 3gp does not store sample rate */
2393  st->codecpar->sample_rate = 8000;
2394  break;
2395  case AV_CODEC_ID_AMR_WB:
2396  st->codecpar->channels = 1;
2397  st->codecpar->sample_rate = 16000;
2398  break;
2399  case AV_CODEC_ID_MP2:
2400  case AV_CODEC_ID_MP3:
2401  /* force type after stsd for m1a hdlr */
2403  break;
2404  case AV_CODEC_ID_GSM:
2405  case AV_CODEC_ID_ADPCM_MS:
2407  case AV_CODEC_ID_ILBC:
2408  case AV_CODEC_ID_MACE3:
2409  case AV_CODEC_ID_MACE6:
2410  case AV_CODEC_ID_QDM2:
2412  break;
2413  case AV_CODEC_ID_ALAC:
2414  if (st->codecpar->extradata_size == 36) {
2415  st->codecpar->channels = AV_RB8 (st->codecpar->extradata + 21);
2416  st->codecpar->sample_rate = AV_RB32(st->codecpar->extradata + 32);
2417  }
2418  break;
2419  case AV_CODEC_ID_AC3:
2420  case AV_CODEC_ID_EAC3:
2422  case AV_CODEC_ID_VC1:
2423  case AV_CODEC_ID_VP8:
2424  case AV_CODEC_ID_VP9:
2426  break;
2427  default:
2428  break;
2429  }
2430  return 0;
2431 }
2432 
2434  int codec_tag, int format,
2435  int64_t size)
2436 {
2437  int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2438 
2439  if (codec_tag &&
2440  (codec_tag != format &&
2441  // AVID 1:1 samples with differing data format and codec tag exist
2442  (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
2443  // prores is allowed to have differing data format and codec tag
2444  codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
2445  // so is dv (sigh)
2446  codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
2447  (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
2448  : codec_tag != MKTAG('j','p','e','g')))) {
2449  /* Multiple fourcc, we skip JPEG. This is not correct, we should
2450  * export it as a separate AVStream but this needs a few changes
2451  * in the MOV demuxer, patch welcome. */
2452 
2453  av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
2454  avio_skip(pb, size);
2455  return 1;
2456  }
2457 
2458  return 0;
2459 }
2460 
2462 {
2463  AVStream *st;
2464  MOVStreamContext *sc;
2465  int pseudo_stream_id;
2466 
2467  av_assert0 (c->fc->nb_streams >= 1);
2468  st = c->fc->streams[c->fc->nb_streams-1];
2469  sc = st->priv_data;
2470 
2471  for (pseudo_stream_id = 0;
2472  pseudo_stream_id < entries && !pb->eof_reached;
2473  pseudo_stream_id++) {
2474  //Parsing Sample description table
2475  enum AVCodecID id;
2476  int ret, dref_id = 1;
2477  MOVAtom a = { AV_RL32("stsd") };
2478  int64_t start_pos = avio_tell(pb);
2479  int64_t size = avio_rb32(pb); /* size */
2480  uint32_t format = avio_rl32(pb); /* data format */
2481 
2482  if (size >= 16) {
2483  avio_rb32(pb); /* reserved */
2484  avio_rb16(pb); /* reserved */
2485  dref_id = avio_rb16(pb);
2486  } else if (size <= 7) {
2487  av_log(c->fc, AV_LOG_ERROR,
2488  "invalid size %"PRId64" in stsd\n", size);
2489  return AVERROR_INVALIDDATA;
2490  }
2491 
2492  if (mov_skip_multiple_stsd(c, pb, st->codecpar->codec_tag, format,
2493  size - (avio_tell(pb) - start_pos))) {
2494  sc->stsd_count++;
2495  continue;
2496  }
2497 
2498  sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
2499  sc->dref_id= dref_id;
2500  sc->format = format;
2501 
2502  id = mov_codec_id(st, format);
2503 
2504  av_log(c->fc, AV_LOG_TRACE,
2505  "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
2506  av_fourcc2str(format), st->codecpar->codec_type);
2507 
2508  st->codecpar->codec_id = id;
2510  mov_parse_stsd_video(c, pb, st, sc);
2511  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
2512  mov_parse_stsd_audio(c, pb, st, sc);
2513  if (st->codecpar->sample_rate < 0) {
2514  av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
2515  return AVERROR_INVALIDDATA;
2516  }
2517  } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
2518  mov_parse_stsd_subtitle(c, pb, st, sc,
2519  size - (avio_tell(pb) - start_pos));
2520  } else {
2521  ret = mov_parse_stsd_data(c, pb, st, sc,
2522  size - (avio_tell(pb) - start_pos));
2523  if (ret < 0)
2524  return ret;
2525  }
2526  /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
2527  a.size = size - (avio_tell(pb) - start_pos);
2528  if (a.size > 8) {
2529  if ((ret = mov_read_default(c, pb, a)) < 0)
2530  return ret;
2531  } else if (a.size > 0)
2532  avio_skip(pb, a.size);
2533 
2534  if (sc->extradata && st->codecpar->extradata) {
2535  int extra_size = st->codecpar->extradata_size;
2536 
2537  /* Move the current stream extradata to the stream context one. */
2538  sc->extradata_size[pseudo_stream_id] = extra_size;
2539  sc->extradata[pseudo_stream_id] = av_malloc(extra_size + AV_INPUT_BUFFER_PADDING_SIZE);
2540  if (!sc->extradata[pseudo_stream_id])
2541  return AVERROR(ENOMEM);
2542  memcpy(sc->extradata[pseudo_stream_id], st->codecpar->extradata, extra_size);
2543  av_freep(&st->codecpar->extradata);
2544  st->codecpar->extradata_size = 0;
2545  }
2546  sc->stsd_count++;
2547  }
2548 
2549  if (pb->eof_reached) {
2550  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSD atom\n");
2551  return AVERROR_EOF;
2552  }
2553 
2554  return 0;
2555 }
2556 
2558 {
2559  AVStream *st;
2560  MOVStreamContext *sc;
2561  int ret, entries;
2562 
2563  if (c->fc->nb_streams < 1)
2564  return 0;
2565  st = c->fc->streams[c->fc->nb_streams - 1];
2566  sc = st->priv_data;
2567 
2568  sc->stsd_version = avio_r8(pb);
2569  avio_rb24(pb); /* flags */
2570  entries = avio_rb32(pb);
2571 
2572  /* Each entry contains a size (4 bytes) and format (4 bytes). */
2573  if (entries <= 0 || entries > atom.size / 8) {
2574  av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2575  return AVERROR_INVALIDDATA;
2576  }
2577 
2578  if (sc->extradata) {
2579  av_log(c->fc, AV_LOG_ERROR,
2580  "Duplicate stsd found in this track.\n");
2581  return AVERROR_INVALIDDATA;
2582  }
2583 
2584  /* Prepare space for hosting multiple extradata. */
2585  sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
2586  if (!sc->extradata)
2587  return AVERROR(ENOMEM);
2588 
2589  sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
2590  if (!sc->extradata_size) {
2591  ret = AVERROR(ENOMEM);
2592  goto fail;
2593  }
2594 
2595  ret = ff_mov_read_stsd_entries(c, pb, entries);
2596  if (ret < 0)
2597  goto fail;
2598 
2599  /* Restore back the primary extradata. */
2600  av_freep(&st->codecpar->extradata);
2601  st->codecpar->extradata_size = sc->extradata_size[0];
2602  if (sc->extradata_size[0]) {
2604  if (!st->codecpar->extradata)
2605  return AVERROR(ENOMEM);
2606  memcpy(st->codecpar->extradata, sc->extradata[0], sc->extradata_size[0]);
2607  }
2608 
2609  return mov_finalize_stsd_codec(c, pb, st, sc);
2610 fail:
2611  if (sc->extradata) {
2612  int j;
2613  for (j = 0; j < sc->stsd_count; j++)
2614  av_freep(&sc->extradata[j]);
2615  }
2616 
2617  av_freep(&sc->extradata);
2618  av_freep(&sc->extradata_size);
2619  return ret;
2620 }
2621 
2623 {
2624  AVStream *st;
2625  MOVStreamContext *sc;
2626  unsigned int i, entries;
2627 
2628  if (c->fc->nb_streams < 1)
2629  return 0;
2630  st = c->fc->streams[c->fc->nb_streams-1];
2631  sc = st->priv_data;
2632 
2633  avio_r8(pb); /* version */
2634  avio_rb24(pb); /* flags */
2635 
2636  entries = avio_rb32(pb);
2637  if ((uint64_t)entries * 12 + 4 > atom.size)
2638  return AVERROR_INVALIDDATA;
2639 
2640  av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2641 
2642  if (!entries)
2643  return 0;
2644  if (sc->stsc_data)
2645  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSC atom\n");
2646  av_free(sc->stsc_data);
2647  sc->stsc_count = 0;
2648  sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2649  if (!sc->stsc_data)
2650  return AVERROR(ENOMEM);
2651 
2652  for (i = 0; i < entries && !pb->eof_reached; i++) {
2653  sc->stsc_data[i].first = avio_rb32(pb);
2654  sc->stsc_data[i].count = avio_rb32(pb);
2655  sc->stsc_data[i].id = avio_rb32(pb);
2656  }
2657 
2658  sc->stsc_count = i;
2659  for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
2660  int64_t first_min = i + 1;
2661  if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
2662  (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
2663  sc->stsc_data[i].first < first_min ||
2664  sc->stsc_data[i].count < 1 ||
2665  sc->stsc_data[i].id < 1) {
2666  av_log(c->fc, AV_LOG_WARNING, "STSC entry %d is invalid (first=%d count=%d id=%d)\n", i, sc->stsc_data[i].first, sc->stsc_data[i].count, sc->stsc_data[i].id);
2667  if (i+1 >= sc->stsc_count) {
2668  sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
2669  if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
2670  sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
2671  sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
2672  sc->stsc_data[i].id = FFMAX(sc->stsc_data[i].id, 1);
2673  continue;
2674  }
2675  av_assert0(sc->stsc_data[i+1].first >= 2);
2676  // We replace this entry by the next valid
2677  sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
2678  sc->stsc_data[i].count = sc->stsc_data[i+1].count;
2679  sc->stsc_data[i].id = sc->stsc_data[i+1].id;
2680  }
2681  }
2682 
2683  if (pb->eof_reached) {
2684  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSC atom\n");
2685  return AVERROR_EOF;
2686  }
2687 
2688  return 0;
2689 }
2690 
2691 static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
2692 {
2693  return index < count - 1;
2694 }
2695 
2696 /* Compute the samples value for the stsc entry at the given index. */
2697 static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
2698 {
2699  int chunk_count;
2700 
2701  if (mov_stsc_index_valid(index, sc->stsc_count))
2702  chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
2703  else {
2704  // Validation for stsc / stco happens earlier in mov_read_stsc + mov_read_trak.
2705  av_assert0(sc->stsc_data[index].first <= sc->chunk_count);
2706  chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
2707  }
2708 
2709  return sc->stsc_data[index].count * (int64_t)chunk_count;
2710 }
2711 
2713 {
2714  AVStream *st;
2715  MOVStreamContext *sc;
2716  unsigned i, entries;
2717 
2718  if (c->fc->nb_streams < 1)
2719  return 0;
2720  st = c->fc->streams[c->fc->nb_streams-1];
2721  sc = st->priv_data;
2722 
2723  avio_rb32(pb); // version + flags
2724 
2725  entries = avio_rb32(pb);
2726  if (sc->stps_data)
2727  av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
2728  av_free(sc->stps_data);
2729  sc->stps_count = 0;
2730  sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2731  if (!sc->stps_data)
2732  return AVERROR(ENOMEM);
2733 
2734  for (i = 0; i < entries && !pb->eof_reached; i++) {
2735  sc->stps_data[i] = avio_rb32(pb);
2736  }
2737 
2738  sc->stps_count = i;
2739 
2740  if (pb->eof_reached) {
2741  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STPS atom\n");
2742  return AVERROR_EOF;
2743  }
2744 
2745  return 0;
2746 }
2747 
2749 {
2750  AVStream *st;
2751  MOVStreamContext *sc;
2752  unsigned int i, entries;
2753 
2754  if (c->fc->nb_streams < 1)
2755  return 0;
2756  st = c->fc->streams[c->fc->nb_streams-1];
2757  sc = st->priv_data;
2758 
2759  avio_r8(pb); /* version */
2760  avio_rb24(pb); /* flags */
2761 
2762  entries = avio_rb32(pb);
2763 
2764  av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
2765 
2766  if (!entries)
2767  {
2768  sc->keyframe_absent = 1;
2769  if (!st->need_parsing && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2771  return 0;
2772  }
2773  if (sc->keyframes)
2774  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
2775  if (entries >= UINT_MAX / sizeof(int))
2776  return AVERROR_INVALIDDATA;
2777  av_freep(&sc->keyframes);
2778  sc->keyframe_count = 0;
2779  sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
2780  if (!sc->keyframes)
2781  return AVERROR(ENOMEM);
2782 
2783  for (i = 0; i < entries && !pb->eof_reached; i++) {
2784  sc->keyframes[i] = avio_rb32(pb);
2785  }
2786 
2787  sc->keyframe_count = i;
2788 
2789  if (pb->eof_reached) {
2790  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSS atom\n");
2791  return AVERROR_EOF;
2792  }
2793 
2794  return 0;
2795 }
2796 
2798 {
2799  AVStream *st;
2800  MOVStreamContext *sc;
2801  unsigned int i, entries, sample_size, field_size, num_bytes;
2802  GetBitContext gb;
2803  unsigned char* buf;
2804  int ret;
2805 
2806  if (c->fc->nb_streams < 1)
2807  return 0;
2808  st = c->fc->streams[c->fc->nb_streams-1];
2809  sc = st->priv_data;
2810 
2811  avio_r8(pb); /* version */
2812  avio_rb24(pb); /* flags */
2813 
2814  if (atom.type == MKTAG('s','t','s','z')) {
2815  sample_size = avio_rb32(pb);
2816  if (!sc->sample_size) /* do not overwrite value computed in stsd */
2817  sc->sample_size = sample_size;
2818  sc->stsz_sample_size = sample_size;
2819  field_size = 32;
2820  } else {
2821  sample_size = 0;
2822  avio_rb24(pb); /* reserved */
2823  field_size = avio_r8(pb);
2824  }
2825  entries = avio_rb32(pb);
2826 
2827  av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
2828 
2829  sc->sample_count = entries;
2830  if (sample_size)
2831  return 0;
2832 
2833  if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2834  av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
2835  return AVERROR_INVALIDDATA;
2836  }
2837 
2838  if (!entries)
2839  return 0;
2840  if (entries >= (UINT_MAX - 4) / field_size)
2841  return AVERROR_INVALIDDATA;
2842  if (sc->sample_sizes)
2843  av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
2844  av_free(sc->sample_sizes);
2845  sc->sample_count = 0;
2846  sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
2847  if (!sc->sample_sizes)
2848  return AVERROR(ENOMEM);
2849 
2850  num_bytes = (entries*field_size+4)>>3;
2851 
2852  buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
2853  if (!buf) {
2854  av_freep(&sc->sample_sizes);
2855  return AVERROR(ENOMEM);
2856  }
2857 
2858  ret = ffio_read_size(pb, buf, num_bytes);
2859  if (ret < 0) {
2860  av_freep(&sc->sample_sizes);
2861  av_free(buf);
2862  av_log(c->fc, AV_LOG_WARNING, "STSZ atom truncated\n");
2863  return 0;
2864  }
2865 
2866  init_get_bits(&gb, buf, 8*num_bytes);
2867 
2868  for (i = 0; i < entries && !pb->eof_reached; i++) {
2869  sc->sample_sizes[i] = get_bits_long(&gb, field_size);
2870  sc->data_size += sc->sample_sizes[i];
2871  }
2872 
2873  sc->sample_count = i;
2874 
2875  av_free(buf);
2876 
2877  if (pb->eof_reached) {
2878  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSZ atom\n");
2879  return AVERROR_EOF;
2880  }
2881 
2882  return 0;
2883 }
2884 
2886 {
2887  AVStream *st;
2888  MOVStreamContext *sc;
2889  unsigned int i, entries, alloc_size = 0;
2890  int64_t duration=0;
2891  int64_t total_sample_count=0;
2892 
2893  if (c->fc->nb_streams < 1)
2894  return 0;
2895  st = c->fc->streams[c->fc->nb_streams-1];
2896  sc = st->priv_data;
2897 
2898  avio_r8(pb); /* version */
2899  avio_rb24(pb); /* flags */
2900  entries = avio_rb32(pb);
2901 
2902  av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
2903  c->fc->nb_streams-1, entries);
2904 
2905  if (sc->stts_data)
2906  av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
2907  av_freep(&sc->stts_data);
2908  sc->stts_count = 0;
2909  if (entries >= INT_MAX / sizeof(*sc->stts_data))
2910  return AVERROR(ENOMEM);
2911 
2912  for (i = 0; i < entries && !pb->eof_reached; i++) {
2913  int sample_duration;
2914  unsigned int sample_count;
2915  unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
2916  MOVStts *stts_data = av_fast_realloc(sc->stts_data, &alloc_size,
2917  min_entries * sizeof(*sc->stts_data));
2918  if (!stts_data) {
2919  av_freep(&sc->stts_data);
2920  sc->stts_count = 0;
2921  return AVERROR(ENOMEM);
2922  }
2923  sc->stts_count = min_entries;
2924  sc->stts_data = stts_data;
2925 
2926  sample_count=avio_rb32(pb);
2927  sample_duration = avio_rb32(pb);
2928 
2929  sc->stts_data[i].count= sample_count;
2930  sc->stts_data[i].duration= sample_duration;
2931 
2932  av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n",
2933  sample_count, sample_duration);
2934 
2935  duration+=(int64_t)sample_duration*(uint64_t)sample_count;
2936  total_sample_count+=sample_count;
2937  }
2938 
2939  sc->stts_count = i;
2940 
2941  if (duration > 0 &&
2942  duration <= INT64_MAX - sc->duration_for_fps &&
2943  total_sample_count <= INT_MAX - sc->nb_frames_for_fps
2944  ) {
2945  sc->duration_for_fps += duration;
2946  sc->nb_frames_for_fps += total_sample_count;
2947  }
2948 
2949  if (pb->eof_reached) {
2950  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STTS atom\n");
2951  return AVERROR_EOF;
2952  }
2953 
2954  st->nb_frames= total_sample_count;
2955  if (duration)
2956  st->duration= FFMIN(st->duration, duration);
2957  sc->track_end = duration;
2958  return 0;
2959 }
2960 
2962 {
2963  if (duration < 0) {
2964  if (duration == INT_MIN) {
2965  av_log(NULL, AV_LOG_WARNING, "mov_update_dts_shift(): dts_shift set to %d\n", INT_MAX);
2966  duration++;
2967  }
2968  sc->dts_shift = FFMAX(sc->dts_shift, -duration);
2969  }
2970 }
2971 
2973 {
2974  AVStream *st;
2975  MOVStreamContext *sc;
2976  unsigned int i, entries, ctts_count = 0;
2977 
2978  if (c->fc->nb_streams < 1)
2979  return 0;
2980  st = c->fc->streams[c->fc->nb_streams-1];
2981  sc = st->priv_data;
2982 
2983  avio_r8(pb); /* version */
2984  avio_rb24(pb); /* flags */
2985  entries = avio_rb32(pb);
2986 
2987  av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
2988 
2989  if (!entries)
2990  return 0;
2991  if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
2992  return AVERROR_INVALIDDATA;
2993  av_freep(&sc->ctts_data);
2994  sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
2995  if (!sc->ctts_data)
2996  return AVERROR(ENOMEM);
2997 
2998  for (i = 0; i < entries && !pb->eof_reached; i++) {
2999  int count =avio_rb32(pb);
3000  int duration =avio_rb32(pb);
3001 
3002  if (count <= 0) {
3003  av_log(c->fc, AV_LOG_TRACE,
3004  "ignoring CTTS entry with count=%d duration=%d\n",
3005  count, duration);
3006  continue;
3007  }
3008 
3009  add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
3010  count, duration);
3011 
3012  av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
3013  count, duration);
3014 
3015  if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3016  av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
3017  av_freep(&sc->ctts_data);
3018  sc->ctts_count = 0;
3019  return 0;
3020  }
3021 
3022  if (i+2<entries)
3023  mov_update_dts_shift(sc, duration);
3024  }
3025 
3026  sc->ctts_count = ctts_count;
3027 
3028  if (pb->eof_reached) {
3029  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted CTTS atom\n");
3030  return AVERROR_EOF;
3031  }
3032 
3033  av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift);
3034 
3035  return 0;
3036 }
3037 
3039 {
3040  AVStream *st;
3041  MOVStreamContext *sc;
3042  unsigned int i, entries;
3043  uint8_t version;
3044  uint32_t grouping_type;
3045 
3046  if (c->fc->nb_streams < 1)
3047  return 0;
3048  st = c->fc->streams[c->fc->nb_streams-1];
3049  sc = st->priv_data;
3050 
3051  version = avio_r8(pb); /* version */
3052  avio_rb24(pb); /* flags */
3053  grouping_type = avio_rl32(pb);
3054  if (grouping_type != MKTAG( 'r','a','p',' '))
3055  return 0; /* only support 'rap ' grouping */
3056  if (version == 1)
3057  avio_rb32(pb); /* grouping_type_parameter */
3058 
3059  entries = avio_rb32(pb);
3060  if (!entries)
3061  return 0;
3062  if (sc->rap_group)
3063  av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
3064  av_free(sc->rap_group);
3065  sc->rap_group_count = 0;
3066  sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
3067  if (!sc->rap_group)
3068  return AVERROR(ENOMEM);
3069 
3070  for (i = 0; i < entries && !pb->eof_reached; i++) {
3071  sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
3072  sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
3073  }
3074 
3075  sc->rap_group_count = i;
3076 
3077  if (pb->eof_reached) {
3078  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted SBGP atom\n");
3079  return AVERROR_EOF;
3080  }
3081 
3082  return 0;
3083 }
3084 
3085 /**
3086  * Get ith edit list entry (media time, duration).
3087  */
3089  const MOVStreamContext *msc,
3090  unsigned int edit_list_index,
3091  int64_t *edit_list_media_time,
3092  int64_t *edit_list_duration,
3093  int64_t global_timescale)
3094 {
3095  if (edit_list_index == msc->elst_count) {
3096  return 0;
3097  }
3098  *edit_list_media_time = msc->elst_data[edit_list_index].time;
3099  *edit_list_duration = msc->elst_data[edit_list_index].duration;
3100 
3101  /* duration is in global timescale units;convert to msc timescale */
3102  if (global_timescale == 0) {
3103  avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
3104  return 0;
3105  }
3106  *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
3107  global_timescale);
3108  return 1;
3109 }
3110 
3111 /**
3112  * Find the closest previous frame to the timestamp_pts, in e_old index
3113  * entries. Searching for just any frame / just key frames can be controlled by
3114  * last argument 'flag'.
3115  * Note that if ctts_data is not NULL, we will always search for a key frame
3116  * irrespective of the value of 'flag'. If we don't find any keyframe, we will
3117  * return the first frame of the video.
3118  *
3119  * Here the timestamp_pts is considered to be a presentation timestamp and
3120  * the timestamp of index entries are considered to be decoding timestamps.
3121  *
3122  * Returns 0 if successful in finding a frame, else returns -1.
3123  * Places the found index corresponding output arg.
3124  *
3125  * If ctts_old is not NULL, then refines the searched entry by searching
3126  * backwards from the found timestamp, to find the frame with correct PTS.
3127  *
3128  * Places the found ctts_index and ctts_sample in corresponding output args.
3129  */
3131  AVIndexEntry *e_old,
3132  int nb_old,
3133  MOVStts* ctts_data,
3134  int64_t ctts_count,
3135  int64_t timestamp_pts,
3136  int flag,
3137  int64_t* index,
3138  int64_t* ctts_index,
3139  int64_t* ctts_sample)
3140 {
3141  MOVStreamContext *msc = st->priv_data;
3142  AVIndexEntry *e_keep = st->index_entries;
3143  int nb_keep = st->nb_index_entries;
3144  int64_t i = 0;
3145  int64_t index_ctts_count;
3146 
3147  av_assert0(index);
3148 
3149  // If dts_shift > 0, then all the index timestamps will have to be offset by
3150  // at least dts_shift amount to obtain PTS.
3151  // Hence we decrement the searched timestamp_pts by dts_shift to find the closest index element.
3152  if (msc->dts_shift > 0) {
3153  timestamp_pts -= msc->dts_shift;
3154  }
3155 
3156  st->index_entries = e_old;
3157  st->nb_index_entries = nb_old;
3158  *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
3159 
3160  // Keep going backwards in the index entries until the timestamp is the same.
3161  if (*index >= 0) {
3162  for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
3163  i--) {
3164  if ((flag & AVSEEK_FLAG_ANY) ||
3165  (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
3166  *index = i - 1;
3167  }
3168  }
3169  }
3170 
3171  // If we have CTTS then refine the search, by searching backwards over PTS
3172  // computed by adding corresponding CTTS durations to index timestamps.
3173  if (ctts_data && *index >= 0) {
3174  av_assert0(ctts_index);
3175  av_assert0(ctts_sample);
3176  // Find out the ctts_index for the found frame.
3177  *ctts_index = 0;
3178  *ctts_sample = 0;
3179  for (index_ctts_count = 0; index_ctts_count < *index; index_ctts_count++) {
3180  if (*ctts_index < ctts_count) {
3181  (*ctts_sample)++;
3182  if (ctts_data[*ctts_index].count == *ctts_sample) {
3183  (*ctts_index)++;
3184  *ctts_sample = 0;
3185  }
3186  }
3187  }
3188 
3189  while (*index >= 0 && (*ctts_index) >= 0 && (*ctts_index) < ctts_count) {
3190  // Find a "key frame" with PTS <= timestamp_pts (So that we can decode B-frames correctly).
3191  // No need to add dts_shift to the timestamp here becase timestamp_pts has already been
3192  // compensated by dts_shift above.
3193  if ((e_old[*index].timestamp + ctts_data[*ctts_index].duration) <= timestamp_pts &&
3194  (e_old[*index].flags & AVINDEX_KEYFRAME)) {
3195  break;
3196  }
3197 
3198  (*index)--;
3199  if (*ctts_sample == 0) {
3200  (*ctts_index)--;
3201  if (*ctts_index >= 0)
3202  *ctts_sample = ctts_data[*ctts_index].count - 1;
3203  } else {
3204  (*ctts_sample)--;
3205  }
3206  }
3207  }
3208 
3209  /* restore AVStream state*/
3210  st->index_entries = e_keep;
3211  st->nb_index_entries = nb_keep;
3212  return *index >= 0 ? 0 : -1;
3213 }
3214 
3215 /**
3216  * Add index entry with the given values, to the end of st->index_entries.
3217  * Returns the new size st->index_entries if successful, else returns -1.
3218  *
3219  * This function is similar to ff_add_index_entry in libavformat/utils.c
3220  * except that here we are always unconditionally adding an index entry to
3221  * the end, instead of searching the entries list and skipping the add if
3222  * there is an existing entry with the same timestamp.
3223  * This is needed because the mov_fix_index calls this func with the same
3224  * unincremented timestamp for successive discarded frames.
3225  */
3226 static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
3227  int size, int distance, int flags)
3228 {
3229  AVIndexEntry *entries, *ie;
3230  int64_t index = -1;
3231  const size_t min_size_needed = (st->nb_index_entries + 1) * sizeof(AVIndexEntry);
3232 
3233  // Double the allocation each time, to lower memory fragmentation.
3234  // Another difference from ff_add_index_entry function.
3235  const size_t requested_size =
3236  min_size_needed > st->index_entries_allocated_size ?
3237  FFMAX(min_size_needed, 2 * st->index_entries_allocated_size) :
3238  min_size_needed;
3239 
3240  if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
3241  return -1;
3242 
3243  entries = av_fast_realloc(st->index_entries,
3245  requested_size);
3246  if(!entries)
3247  return -1;
3248 
3249  st->index_entries= entries;
3250 
3251  index= st->nb_index_entries++;
3252  ie= &entries[index];
3253 
3254  ie->pos = pos;
3255  ie->timestamp = timestamp;
3256  ie->min_distance= distance;
3257  ie->size= size;
3258  ie->flags = flags;
3259  return index;
3260 }
3261 
3262 /**
3263  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3264  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
3265  */
3266 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
3267  int64_t* frame_duration_buffer,
3268  int frame_duration_buffer_size) {
3269  int i = 0;
3270  av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
3271  for (i = 0; i < frame_duration_buffer_size; i++) {
3272  end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
3273  st->index_entries[end_index - 1 - i].timestamp = end_ts;
3274  }
3275 }
3276 
3277 /**
3278  * Append a new ctts entry to ctts_data.
3279  * Returns the new ctts_count if successful, else returns -1.
3280  */
3281 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
3282  int count, int duration)
3283 {
3284  MOVStts *ctts_buf_new;
3285  const size_t min_size_needed = (*ctts_count + 1) * sizeof(MOVStts);
3286  const size_t requested_size =
3287  min_size_needed > *allocated_size ?
3288  FFMAX(min_size_needed, 2 * (*allocated_size)) :
3289  min_size_needed;
3290 
3291  if((unsigned)(*ctts_count) >= UINT_MAX / sizeof(MOVStts) - 1)
3292  return -1;
3293 
3294  ctts_buf_new = av_fast_realloc(*ctts_data, allocated_size, requested_size);
3295 
3296  if(!ctts_buf_new)
3297  return -1;
3298 
3299  *ctts_data = ctts_buf_new;
3300 
3301  ctts_buf_new[*ctts_count].count = count;
3302  ctts_buf_new[*ctts_count].duration = duration;
3303 
3304  *ctts_count = (*ctts_count) + 1;
3305  return *ctts_count;
3306 }
3307 
3308 #define MAX_REORDER_DELAY 16
3310  MOVStreamContext *msc = st->priv_data;
3311  int ind;
3312  int ctts_ind = 0;
3313  int ctts_sample = 0;
3314  int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
3315  int buf_start = 0;
3316  int j, r, num_swaps;
3317 
3318  for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
3319  pts_buf[j] = INT64_MIN;
3320 
3321  if (st->codecpar->video_delay <= 0 && msc->ctts_data &&
3323  st->codecpar->video_delay = 0;
3324  for(ind = 0; ind < st->nb_index_entries && ctts_ind < msc->ctts_count; ++ind) {
3325  // Point j to the last elem of the buffer and insert the current pts there.
3326  j = buf_start;
3327  buf_start = (buf_start + 1);
3328  if (buf_start == MAX_REORDER_DELAY + 1)
3329  buf_start = 0;
3330 
3331  pts_buf[j] = st->index_entries[ind].timestamp + msc->ctts_data[ctts_ind].duration;
3332 
3333  // The timestamps that are already in the sorted buffer, and are greater than the
3334  // current pts, are exactly the timestamps that need to be buffered to output PTS
3335  // in correct sorted order.
3336  // Hence the video delay (which is the buffer size used to sort DTS and output PTS),
3337  // can be computed as the maximum no. of swaps any particular timestamp needs to
3338  // go through, to keep this buffer in sorted order.
3339  num_swaps = 0;
3340  while (j != buf_start) {
3341  r = j - 1;
3342  if (r < 0) r = MAX_REORDER_DELAY;
3343  if (pts_buf[j] < pts_buf[r]) {
3344  FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
3345  ++num_swaps;
3346  } else {
3347  break;
3348  }
3349  j = r;
3350  }
3351  st->codecpar->video_delay = FFMAX(st->codecpar->video_delay, num_swaps);
3352 
3353  ctts_sample++;
3354  if (ctts_sample == msc->ctts_data[ctts_ind].count) {
3355  ctts_ind++;
3356  ctts_sample = 0;
3357  }
3358  }
3359  av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
3360  st->codecpar->video_delay, st->index);
3361  }
3362 }
3363 
3365 {
3366  sc->current_sample++;
3367  sc->current_index++;
3368  if (sc->index_ranges &&
3369  sc->current_index >= sc->current_index_range->end &&
3370  sc->current_index_range->end) {
3371  sc->current_index_range++;
3373  }
3374 }
3375 
3377 {
3378  sc->current_sample--;
3379  sc->current_index--;
3380  if (sc->index_ranges &&
3382  sc->current_index_range > sc->index_ranges) {
3383  sc->current_index_range--;
3384  sc->current_index = sc->current_index_range->end - 1;
3385  }
3386 }
3387 
3388 static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
3389 {
3390  int64_t range_size;
3391 
3392  sc->current_sample = current_sample;
3393  sc->current_index = current_sample;
3394  if (!sc->index_ranges) {
3395  return;
3396  }
3397 
3398  for (sc->current_index_range = sc->index_ranges;
3399  sc->current_index_range->end;
3400  sc->current_index_range++) {
3401  range_size = sc->current_index_range->end - sc->current_index_range->start;
3402  if (range_size > current_sample) {
3403  sc->current_index = sc->current_index_range->start + current_sample;
3404  break;
3405  }
3406  current_sample -= range_size;
3407  }
3408 }
3409 
3410 /**
3411  * Fix st->index_entries, so that it contains only the entries (and the entries
3412  * which are needed to decode them) that fall in the edit list time ranges.
3413  * Also fixes the timestamps of the index entries to match the timeline
3414  * specified the edit lists.
3415  */
3416 static void mov_fix_index(MOVContext *mov, AVStream *st)
3417 {
3418  MOVStreamContext *msc = st->priv_data;
3419  AVIndexEntry *e_old = st->index_entries;
3420  int nb_old = st->nb_index_entries;
3421  const AVIndexEntry *e_old_end = e_old + nb_old;
3422  const AVIndexEntry *current = NULL;
3423  MOVStts *ctts_data_old = msc->ctts_data;
3424  int64_t ctts_index_old = 0;
3425  int64_t ctts_sample_old = 0;
3426  int64_t ctts_count_old = msc->ctts_count;
3427  int64_t edit_list_media_time = 0;
3428  int64_t edit_list_duration = 0;
3429  int64_t frame_duration = 0;
3430  int64_t edit_list_dts_counter = 0;
3431  int64_t edit_list_dts_entry_end = 0;
3432  int64_t edit_list_start_ctts_sample = 0;
3433  int64_t curr_cts;
3434  int64_t curr_ctts = 0;
3435  int64_t empty_edits_sum_duration = 0;
3436  int64_t edit_list_index = 0;
3437  int64_t index;
3438  int flags;
3439  int64_t start_dts = 0;
3440  int64_t edit_list_start_encountered = 0;
3441  int64_t search_timestamp = 0;
3442  int64_t* frame_duration_buffer = NULL;
3443  int num_discarded_begin = 0;
3444  int first_non_zero_audio_edit = -1;
3445  int packet_skip_samples = 0;
3446  MOVIndexRange *current_index_range;
3447  int i;
3448  int found_keyframe_after_edit = 0;
3449  int found_non_empty_edit = 0;
3450 
3451  if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
3452  return;
3453  }
3454 
3455  // allocate the index ranges array
3456  msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
3457  if (!msc->index_ranges) {
3458  av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
3459  return;
3460  }
3461  msc->current_index_range = msc->index_ranges;
3462  current_index_range = msc->index_ranges - 1;
3463 
3464  // Clean AVStream from traces of old index
3465  st->index_entries = NULL;
3467  st->nb_index_entries = 0;
3468 
3469  // Clean ctts fields of MOVStreamContext
3470  msc->ctts_data = NULL;
3471  msc->ctts_count = 0;
3472  msc->ctts_index = 0;
3473  msc->ctts_sample = 0;
3474  msc->ctts_allocated_size = 0;
3475 
3476  // Reinitialize min_corrected_pts so that it can be computed again.
3477  msc->min_corrected_pts = -1;
3478 
3479  // If the dts_shift is positive (in case of negative ctts values in mov),
3480  // then negate the DTS by dts_shift
3481  if (msc->dts_shift > 0) {
3482  edit_list_dts_entry_end -= msc->dts_shift;
3483  av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
3484  }
3485 
3486  start_dts = edit_list_dts_entry_end;
3487 
3488  while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
3489  &edit_list_duration, mov->time_scale)) {
3490  av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
3491  st->index, edit_list_index, edit_list_media_time, edit_list_duration);
3492  edit_list_index++;
3493  edit_list_dts_counter = edit_list_dts_entry_end;
3494  edit_list_dts_entry_end += edit_list_duration;
3495  num_discarded_begin = 0;
3496  if (!found_non_empty_edit && edit_list_media_time == -1) {
3497  empty_edits_sum_duration += edit_list_duration;
3498  continue;
3499  }
3500  found_non_empty_edit = 1;
3501 
3502  // If we encounter a non-negative edit list reset the skip_samples/start_pad fields and set them
3503  // according to the edit list below.
3504  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3505  if (first_non_zero_audio_edit < 0) {
3506  first_non_zero_audio_edit = 1;
3507  } else {
3508  first_non_zero_audio_edit = 0;
3509  }
3510 
3511  if (first_non_zero_audio_edit > 0)
3512  st->skip_samples = msc->start_pad = 0;
3513  }
3514 
3515  // While reordering frame index according to edit list we must handle properly
3516  // the scenario when edit list entry starts from none key frame.
3517  // We find closest previous key frame and preserve it and consequent frames in index.
3518  // All frames which are outside edit list entry time boundaries will be dropped after decoding.
3519  search_timestamp = edit_list_media_time;
3520  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3521  // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
3522  // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
3523  // edit_list_media_time to cover the decoder delay.
3524  search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
3525  }
3526 
3527  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, 0,
3528  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3529  av_log(mov->fc, AV_LOG_WARNING,
3530  "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
3531  st->index, edit_list_index, search_timestamp);
3532  if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
3533  &index, &ctts_index_old, &ctts_sample_old) < 0) {
3534  av_log(mov->fc, AV_LOG_WARNING,
3535  "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
3536  st->index, edit_list_index, search_timestamp);
3537  index = 0;
3538  ctts_index_old = 0;
3539  ctts_sample_old = 0;
3540  }
3541  }
3542  current = e_old + index;
3543  edit_list_start_ctts_sample = ctts_sample_old;
3544 
3545  // Iterate over index and arrange it according to edit list
3546  edit_list_start_encountered = 0;
3547  found_keyframe_after_edit = 0;
3548  for (; current < e_old_end; current++, index++) {
3549  // check if frame outside edit list mark it for discard
3550  frame_duration = (current + 1 < e_old_end) ?
3551  ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
3552 
3553  flags = current->flags;
3554 
3555  // frames (pts) before or after edit list
3556  curr_cts = current->timestamp + msc->dts_shift;
3557  curr_ctts = 0;
3558 
3559  if (ctts_data_old && ctts_index_old < ctts_count_old) {
3560  curr_ctts = ctts_data_old[ctts_index_old].duration;
3561  av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
3562  curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
3563  curr_cts += curr_ctts;
3564  ctts_sample_old++;
3565  if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
3566  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3567  &msc->ctts_allocated_size,
3568  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3569  ctts_data_old[ctts_index_old].duration) == -1) {
3570  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3571  ctts_index_old,
3572  ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3573  ctts_data_old[ctts_index_old].duration);
3574  break;
3575  }
3576  ctts_index_old++;
3577  ctts_sample_old = 0;
3578  edit_list_start_ctts_sample = 0;
3579  }
3580  }
3581 
3582  if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3584  curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3585  first_non_zero_audio_edit > 0) {
3586  packet_skip_samples = edit_list_media_time - curr_cts;
3587  st->skip_samples += packet_skip_samples;
3588 
3589  // Shift the index entry timestamp by packet_skip_samples to be correct.
3590  edit_list_dts_counter -= packet_skip_samples;
3591  if (edit_list_start_encountered == 0) {
3592  edit_list_start_encountered = 1;
3593  // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
3594  // discarded packets.
3595  if (frame_duration_buffer) {
3596  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3597  frame_duration_buffer, num_discarded_begin);
3598  av_freep(&frame_duration_buffer);
3599  }
3600  }
3601 
3602  av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
3603  } else {
3604  flags |= AVINDEX_DISCARD_FRAME;
3605  av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
3606 
3607  if (edit_list_start_encountered == 0) {
3608  num_discarded_begin++;
3609  frame_duration_buffer = av_realloc(frame_duration_buffer,
3610  num_discarded_begin * sizeof(int64_t));
3611  if (!frame_duration_buffer) {
3612  av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
3613  break;
3614  }
3615  frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3616 
3617  // Increment skip_samples for the first non-zero audio edit list
3618  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3619  first_non_zero_audio_edit > 0 && st->codecpar->codec_id != AV_CODEC_ID_VORBIS) {
3620  st->skip_samples += frame_duration;
3621  }
3622  }
3623  }
3624  } else {
3625  if (msc->min_corrected_pts < 0) {
3626  msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
3627  } else {
3628  msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
3629  }
3630  if (edit_list_start_encountered == 0) {
3631  edit_list_start_encountered = 1;
3632  // Make timestamps strictly monotonically increasing by rewriting timestamps for
3633  // discarded packets.
3634  if (frame_duration_buffer) {
3635  fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3636  frame_duration_buffer, num_discarded_begin);
3637  av_freep(&frame_duration_buffer);
3638  }
3639  }
3640  }
3641 
3642  if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
3643  current->min_distance, flags) == -1) {
3644  av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
3645  break;
3646  }
3647 
3648  // Update the index ranges array
3649  if (current_index_range < msc->index_ranges || index != current_index_range->end) {
3650  current_index_range++;
3651  current_index_range->start = index;
3652  }
3653  current_index_range->end = index + 1;
3654 
3655  // Only start incrementing DTS in frame_duration amounts, when we encounter a frame in edit list.
3656  if (edit_list_start_encountered > 0) {
3657  edit_list_dts_counter = edit_list_dts_counter + frame_duration;
3658  }
3659 
3660  // Break when found first key frame after edit entry completion
3661  if ((curr_cts + frame_duration >= (edit_list_duration + edit_list_media_time)) &&
3662  ((flags & AVINDEX_KEYFRAME) || ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)))) {
3663  if (ctts_data_old) {
3664  // If we have CTTS and this is the first keyframe after edit elist,
3665  // wait for one more, because there might be trailing B-frames after this I-frame
3666  // that do belong to the edit.
3667  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO && found_keyframe_after_edit == 0) {
3668  found_keyframe_after_edit = 1;
3669  continue;
3670  }
3671  if (ctts_sample_old != 0) {
3672  if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3673  &msc->ctts_allocated_size,
3674  ctts_sample_old - edit_list_start_ctts_sample,
3675  ctts_data_old[ctts_index_old].duration) == -1) {
3676  av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3677  ctts_index_old, ctts_sample_old - edit_list_start_ctts_sample,
3678  ctts_data_old[ctts_index_old].duration);
3679  break;
3680  }
3681  }
3682  }
3683  break;
3684  }
3685  }
3686  }
3687  // If there are empty edits, then msc->min_corrected_pts might be positive
3688  // intentionally. So we subtract the sum duration of emtpy edits here.
3689  msc->min_corrected_pts -= empty_edits_sum_duration;
3690 
3691  // If the minimum pts turns out to be greater than zero after fixing the index, then we subtract the
3692  // dts by that amount to make the first pts zero.
3693  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3694  if (msc->min_corrected_pts > 0) {
3695  av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by %"PRId64" to make first pts zero.\n", msc->min_corrected_pts);
3696  for (i = 0; i < st->nb_index_entries; ++i) {
3698  }
3699  }
3700  }
3701  // Start time should be equal to zero or the duration of any empty edits.
3702  st->start_time = empty_edits_sum_duration;
3703 
3704  // Update av stream length, if it ends up shorter than the track's media duration
3705  st->duration = FFMIN(st->duration, edit_list_dts_entry_end - start_dts);
3706  msc->start_pad = st->skip_samples;
3707 
3708  // Free the old index and the old CTTS structures
3709  av_free(e_old);
3710  av_free(ctts_data_old);
3711  av_freep(&frame_duration_buffer);
3712 
3713  // Null terminate the index ranges array
3714  current_index_range++;
3715  current_index_range->start = 0;
3716  current_index_range->end = 0;
3717  msc->current_index = msc->index_ranges[0].start;
3718 }
3719 
3720 static void mov_build_index(MOVContext *mov, AVStream *st)
3721 {
3722  MOVStreamContext *sc = st->priv_data;
3723  int64_t current_offset;
3724  int64_t current_dts = 0;
3725  unsigned int stts_index = 0;
3726  unsigned int stsc_index = 0;
3727  unsigned int stss_index = 0;
3728  unsigned int stps_index = 0;
3729  unsigned int i, j;
3730  uint64_t stream_size = 0;
3731  MOVStts *ctts_data_old = sc->ctts_data;
3732  unsigned int ctts_count_old = sc->ctts_count;
3733 
3734  if (sc->elst_count) {
3735  int i, edit_start_index = 0, multiple_edits = 0;
3736  int64_t empty_duration = 0; // empty duration of the first edit list entry
3737  int64_t start_time = 0; // start time of the media
3738 
3739  for (i = 0; i < sc->elst_count; i++) {
3740  const MOVElst *e = &sc->elst_data[i];
3741  if (i == 0 && e->time == -1) {
3742  /* if empty, the first entry is the start time of the stream
3743  * relative to the presentation itself */
3744  empty_duration = e->duration;
3745  edit_start_index = 1;
3746  } else if (i == edit_start_index && e->time >= 0) {
3747  start_time = e->time;
3748  } else {
3749  multiple_edits = 1;
3750  }
3751  }
3752 
3753  if (multiple_edits && !mov->advanced_editlist)
3754  av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
3755  "Use -advanced_editlist to correctly decode otherwise "
3756  "a/v desync might occur\n");
3757 
3758  /* adjust first dts according to edit list */
3759  if ((empty_duration || start_time) && mov->time_scale > 0) {
3760  if (empty_duration)
3761  empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
3762  sc->time_offset = start_time - empty_duration;
3764  if (!mov->advanced_editlist)
3765  current_dts = -sc->time_offset;
3766  }
3767 
3768  if (!multiple_edits && !mov->advanced_editlist &&
3769  st->codecpar->codec_id == AV_CODEC_ID_AAC && start_time > 0)
3770  sc->start_pad = start_time;
3771  }
3772 
3773  /* only use old uncompressed audio chunk demuxing when stts specifies it */
3774  if (!(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3775  sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
3776  unsigned int current_sample = 0;
3777  unsigned int stts_sample = 0;
3778  unsigned int sample_size;
3779  unsigned int distance = 0;
3780  unsigned int rap_group_index = 0;
3781  unsigned int rap_group_sample = 0;
3782  int64_t last_dts = 0;
3783  int64_t dts_correction = 0;
3784  int rap_group_present = sc->rap_group_count && sc->rap_group;
3785  int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
3786 
3787  current_dts -= sc->dts_shift;
3788  last_dts = current_dts;
3789 
3790  if (!sc->sample_count || st->nb_index_entries)
3791  return;
3792  if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
3793  return;
3795  st->nb_index_entries + sc->sample_count,
3796  sizeof(*st->index_entries)) < 0) {
3797  st->nb_index_entries = 0;
3798  return;
3799  }
3801 
3802  if (ctts_data_old) {
3803  // Expand ctts entries such that we have a 1-1 mapping with samples
3804  if (sc->sample_count >= UINT_MAX / sizeof(*sc->ctts_data))
3805  return;
3806  sc->ctts_count = 0;
3807  sc->ctts_allocated_size = 0;
3809  sc->sample_count * sizeof(*sc->ctts_data));
3810  if (!sc->ctts_data) {
3811  av_free(ctts_data_old);
3812  return;
3813  }
3814 
3815  memset((uint8_t*)(sc->ctts_data), 0, sc->ctts_allocated_size);
3816 
3817  for (i = 0; i < ctts_count_old &&
3818  sc->ctts_count < sc->sample_count; i++)
3819  for (j = 0; j < ctts_data_old[i].count &&
3820  sc->ctts_count < sc->sample_count; j++)
3821  add_ctts_entry(&sc->ctts_data, &sc->ctts_count,
3822  &sc->ctts_allocated_size, 1,
3823  ctts_data_old[i].duration);
3824  av_free(ctts_data_old);
3825  }
3826 
3827  for (i = 0; i < sc->chunk_count; i++) {
3828  int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
3829  current_offset = sc->chunk_offsets[i];
3830  while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
3831  i + 1 == sc->stsc_data[stsc_index + 1].first)
3832  stsc_index++;
3833 
3834  if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
3835  sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
3836  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
3837  sc->stsz_sample_size = sc->sample_size;
3838  }
3839  if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
3840  av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
3841  sc->stsz_sample_size = sc->sample_size;
3842  }
3843 
3844  for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
3845  int keyframe = 0;
3846  if (current_sample >= sc->sample_count) {
3847  av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
3848  return;
3849  }
3850 
3851  if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
3852  keyframe = 1;
3853  if (stss_index + 1 < sc->keyframe_count)
3854  stss_index++;
3855  } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
3856  keyframe = 1;
3857  if (stps_index + 1 < sc->stps_count)
3858  stps_index++;
3859  }
3860  if (rap_group_present && rap_group_index < sc->rap_group_count) {
3861  if (sc->rap_group[rap_group_index].index > 0)
3862  keyframe = 1;
3863  if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
3864  rap_group_sample = 0;
3865  rap_group_index++;
3866  }
3867  }
3868  if (sc->keyframe_absent
3869  && !sc->stps_count
3870  && !rap_group_present
3871  && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
3872  keyframe = 1;
3873  if (keyframe)
3874  distance = 0;
3875  sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
3876  if (sc->pseudo_stream_id == -1 ||
3877  sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
3878  AVIndexEntry *e;
3879  if (sample_size > 0x3FFFFFFF) {
3880  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", sample_size);
3881  return;
3882  }
3883  e = &st->index_entries[st->nb_index_entries++];
3884  e->pos = current_offset;
3885  e->timestamp = current_dts;
3886  e->size = sample_size;
3887  e->min_distance = distance;
3888  e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
3889  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
3890  "size %u, distance %u, keyframe %d\n", st->index, current_sample,
3891  current_offset, current_dts, sample_size, distance, keyframe);
3892  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
3893  ff_rfps_add_frame(mov->fc, st, current_dts);
3894  }
3895 
3896  current_offset += sample_size;
3897  stream_size += sample_size;
3898 
3899  /* A negative sample duration is invalid based on the spec,
3900  * but some samples need it to correct the DTS. */
3901  if (sc->stts_data[stts_index].duration < 0) {
3902  av_log(mov->fc, AV_LOG_WARNING,
3903  "Invalid SampleDelta %d in STTS, at %d st:%d\n",
3904  sc->stts_data[stts_index].duration, stts_index,
3905  st->index);
3906  dts_correction += sc->stts_data[stts_index].duration - 1;
3907  sc->stts_data[stts_index].duration = 1;
3908  }
3909  current_dts += sc->stts_data[stts_index].duration;
3910  if (!dts_correction || current_dts + dts_correction > last_dts) {
3911  current_dts += dts_correction;
3912  dts_correction = 0;
3913  } else {
3914  /* Avoid creating non-monotonous DTS */
3915  dts_correction += current_dts - last_dts - 1;
3916  current_dts = last_dts + 1;
3917  }
3918  last_dts = current_dts;
3919  distance++;
3920  stts_sample++;
3921  current_sample++;
3922  if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
3923  stts_sample = 0;
3924  stts_index++;
3925  }
3926  }
3927  }
3928  if (st->duration > 0)
3929  st->codecpar->bit_rate = stream_size*8*sc->time_scale/st->duration;
3930  } else {
3931  unsigned chunk_samples, total = 0;
3932 
3933  if (!sc->chunk_count)
3934  return;
3935 
3936  // compute total chunk count
3937  for (i = 0; i < sc->stsc_count; i++) {
3938  unsigned count, chunk_count;
3939 
3940  chunk_samples = sc->stsc_data[i].count;
3941  if (i != sc->stsc_count - 1 &&
3942  sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
3943  av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
3944  return;
3945  }
3946 
3947  if (sc->samples_per_frame >= 160) { // gsm
3948  count = chunk_samples / sc->samples_per_frame;
3949  } else if (sc->samples_per_frame > 1) {
3950  unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
3951  count = (chunk_samples+samples-1) / samples;
3952  } else {
3953  count = (chunk_samples+1023) / 1024;
3954  }
3955 
3956  if (mov_stsc_index_valid(i, sc->stsc_count))
3957  chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
3958  else
3959  chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
3960  total += chunk_count * count;
3961  }
3962 
3963  av_log(mov->fc, AV_LOG_TRACE, "chunk count %u\n", total);
3964  if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
3965  return;
3967  st->nb_index_entries + total,
3968  sizeof(*st->index_entries)) < 0) {
3969  st->nb_index_entries = 0;
3970  return;
3971  }
3972  st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
3973 
3974  // populate index
3975  for (i = 0; i < sc->chunk_count; i++) {
3976  current_offset = sc->chunk_offsets[i];
3977  if (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
3978  i + 1 == sc->stsc_data[stsc_index + 1].first)
3979  stsc_index++;
3980  chunk_samples = sc->stsc_data[stsc_index].count;
3981 
3982  while (chunk_samples > 0) {
3983  AVIndexEntry *e;
3984  unsigned size, samples;
3985 
3986  if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
3988  "Zero bytes per frame, but %d samples per frame",
3989  sc->samples_per_frame);
3990  return;
3991  }
3992 
3993  if (sc->samples_per_frame >= 160) { // gsm
3994  samples = sc->samples_per_frame;
3995  size = sc->bytes_per_frame;
3996  } else {
3997  if (sc->samples_per_frame > 1) {
3998  samples = FFMIN((1024 / sc->samples_per_frame)*
3999  sc->samples_per_frame, chunk_samples);
4000  size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
4001  } else {
4002  samples = FFMIN(1024, chunk_samples);
4003  size = samples * sc->sample_size;
4004  }
4005  }
4006 
4007  if (st->nb_index_entries >= total) {
4008  av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %u\n", total);
4009  return;
4010  }
4011  if (size > 0x3FFFFFFF) {
4012  av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", size);
4013  return;
4014  }
4015  e = &st->index_entries[st->nb_index_entries++];
4016  e->pos = current_offset;
4017  e->timestamp = current_dts;
4018  e->size = size;
4019  e->min_distance = 0;
4020  e->flags = AVINDEX_KEYFRAME;
4021  av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
4022  "size %u, duration %u\n", st->index, i, current_offset, current_dts,
4023  size, samples);
4024 
4025  current_offset += size;
4026  current_dts += samples;
4027  chunk_samples -= samples;
4028  }
4029  }
4030  }
4031 
4032  if (!mov->ignore_editlist && mov->advanced_editlist) {
4033  // Fix index according to edit lists.
4034  mov_fix_index(mov, st);
4035  }
4036 
4037  // Update start time of the stream.
4039  st->start_time = st->index_entries[0].timestamp + sc->dts_shift;
4040  if (sc->ctts_data) {
4041  st->start_time += sc->ctts_data[0].duration;
4042  }
4043  }
4044 
4045  mov_estimate_video_delay(mov, st);
4046 }
4047 
4048 static int test_same_origin(const char *src, const char *ref) {
4049  char src_proto[64];
4050  char ref_proto[64];
4051  char src_auth[256];
4052  char ref_auth[256];
4053  char src_host[256];
4054  char ref_host[256];
4055  int src_port=-1;
4056  int ref_port=-1;
4057 
4058  av_url_split(src_proto, sizeof(src_proto), src_auth, sizeof(src_auth), src_host, sizeof(src_host), &src_port, NULL, 0, src);
4059  av_url_split(ref_proto, sizeof(ref_proto), ref_auth, sizeof(ref_auth), ref_host, sizeof(ref_host), &ref_port, NULL, 0, ref);
4060 
4061  if (strlen(src) == 0) {
4062  return -1;
4063  } else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
4064  strlen(ref_auth) + 1 >= sizeof(ref_auth) ||
4065  strlen(src_host) + 1 >= sizeof(src_host) ||
4066  strlen(ref_host) + 1 >= sizeof(ref_host)) {
4067  return 0;
4068  } else if (strcmp(src_proto, ref_proto) ||
4069  strcmp(src_auth, ref_auth) ||
4070  strcmp(src_host, ref_host) ||
4071  src_port != ref_port) {
4072  return 0;
4073  } else
4074  return 1;
4075 }
4076 
4077 static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
4078 {
4079  /* try relative path, we do not try the absolute because it can leak information about our
4080  system to an attacker */
4081  if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
4082  char filename[1025];
4083  const char *src_path;
4084  int i, l;
4085 
4086  /* find a source dir */
4087  src_path = strrchr(src, '/');
4088  if (src_path)
4089  src_path++;
4090  else
4091  src_path = src;
4092 
4093  /* find a next level down to target */
4094  for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
4095  if (ref->path[l] == '/') {
4096  if (i == ref->nlvl_to - 1)
4097  break;
4098  else
4099  i++;
4100  }
4101 
4102  /* compose filename if next level down to target was found */
4103  if (i == ref->nlvl_to - 1 && src_path - src < sizeof(filename)) {
4104  memcpy(filename, src, src_path - src);
4105  filename[src_path - src] = 0;
4106 
4107  for (i = 1; i < ref->nlvl_from; i++)
4108  av_strlcat(filename, "../", sizeof(filename));
4109 
4110  av_strlcat(filename, ref->path + l + 1, sizeof(filename));
4111  if (!c->use_absolute_path) {
4112  int same_origin = test_same_origin(src, filename);
4113 
4114  if (!same_origin) {
4115  av_log(c->fc, AV_LOG_ERROR,
4116  "Reference with mismatching origin, %s not tried for security reasons, "
4117  "set demuxer option use_absolute_path to allow it anyway\n",
4118  ref->path);
4119  return AVERROR(ENOENT);
4120  }
4121 
4122  if(strstr(ref->path + l + 1, "..") ||
4123  strstr(ref->path + l + 1, ":") ||
4124  (ref->nlvl_from > 1 && same_origin < 0) ||
4125  (filename[0] == '/' && src_path == src))
4126  return AVERROR(ENOENT);
4127  }
4128 
4129  if (strlen(filename) + 1 == sizeof(filename))
4130  return AVERROR(ENOENT);
4131  if (!c->fc->io_open(c->fc, pb, filename, AVIO_FLAG_READ, NULL))
4132  return 0;
4133  }
4134  } else if (c->use_absolute_path) {
4135  av_log(c->fc, AV_LOG_WARNING, "Using absolute path on user request, "
4136  "this is a possible security issue\n");
4137  if (!c->fc->io_open(c->fc, pb, ref->path, AVIO_FLAG_READ, NULL))
4138  return 0;
4139  } else {
4140  av_log(c->fc, AV_LOG_ERROR,
4141  "Absolute path %s not tried for security reasons, "
4142  "set demuxer option use_absolute_path to allow absolute paths\n",
4143  ref->path);
4144  }
4145 
4146  return AVERROR(ENOENT);
4147 }
4148 
4150 {
4151  if (sc->time_scale <= 0) {
4152  av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
4153  sc->time_scale = c->time_scale;
4154  if (sc->time_scale <= 0)
4155  sc->time_scale = 1;
4156  }
4157 }
4158 
4160 {
4161  AVStream *st;
4162  MOVStreamContext *sc;
4163  int ret;
4164 
4165  st = avformat_new_stream(c->fc, NULL);
4166  if (!st) return AVERROR(ENOMEM);
4167  st->id = -1;
4168  sc = av_mallocz(sizeof(MOVStreamContext));
4169  if (!sc) return AVERROR(ENOMEM);
4170 
4171  st->priv_data = sc;
4173  sc->ffindex = st->index;
4174  c->trak_index = st->index;
4175 
4176  if ((ret = mov_read_default(c, pb, atom)) < 0)
4177  return ret;
4178 
4179  c->trak_index = -1;
4180 
4181  // Here stsc refers to a chunk not described in stco. This is technically invalid,
4182  // but we can overlook it (clearing stsc) whenever stts_count == 0 (indicating no samples).
4183  if (!sc->chunk_count && !sc->stts_count && sc->stsc_count) {
4184  sc->stsc_count = 0;
4185  av_freep(&sc->stsc_data);
4186  }
4187 
4188  /* sanity checks */
4189  if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
4190  (!sc->sample_size && !sc->sample_count))) ||
4191  (!sc->chunk_count && sc->sample_count)) {
4192  av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
4193  st->index);
4194  return 0;
4195  }
4196  if (sc->stsc_count && sc->stsc_data[ sc->stsc_count - 1 ].first > sc->chunk_count) {
4197  av_log(c->fc, AV_LOG_ERROR, "stream %d, contradictionary STSC and STCO\n",
4198  st->index);
4199  return AVERROR_INVALIDDATA;
4200  }
4201 
4202  fix_timescale(c, sc);
4203 
4204  avpriv_set_pts_info(st, 64, 1, sc->time_scale);
4205 
4206  mov_build_index(c, st);
4207 
4208  if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
4209  MOVDref *dref = &sc->drefs[sc->dref_id - 1];
4210  if (c->enable_drefs) {
4211  if (mov_open_dref(c, &sc->pb, c->fc->url, dref) < 0)
4212  av_log(c->fc, AV_LOG_ERROR,
4213  "stream %d, error opening alias: path='%s', dir='%s', "
4214  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
4215  st->index, dref->path, dref->dir, dref->filename,
4216  dref->volume, dref->nlvl_from, dref->nlvl_to);
4217  } else {
4218  av_log(c->fc, AV_LOG_WARNING,
4219  "Skipped opening external track: "
4220  "stream %d, alias: path='%s', dir='%s', "
4221  "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
4222  "Set enable_drefs to allow this.\n",
4223  st->index, dref->path, dref->dir, dref->filename,
4224  dref->volume, dref->nlvl_from, dref->nlvl_to);
4225  }
4226  } else {
4227  sc->pb = c->fc->pb;
4228  sc->pb_is_copied = 1;
4229  }
4230 
4231  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
4232  if (!st->sample_aspect_ratio.num && st->codecpar->width && st->codecpar->height &&
4233  sc->height && sc->width &&
4234  (st->codecpar->width != sc->width || st->codecpar->height != sc->height)) {
4235  st->sample_aspect_ratio = av_d2q(((double)st->codecpar->height * sc->width) /
4236  ((double)st->codecpar->width * sc->height), INT_MAX);
4237  }
4238 
4239 #if FF_API_R_FRAME_RATE
4240  if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
4242  sc->time_scale, sc->stts_data[0].duration, INT_MAX);
4243 #endif
4244  }
4245 
4246  // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
4247  if (!st->codecpar->extradata_size && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
4248  TAG_IS_AVCI(st->codecpar->codec_tag)) {
4249  ret = ff_generate_avci_extradata(st);
4250  if (ret < 0)
4251  return ret;
4252  }
4253 
4254  switch (st->codecpar->codec_id) {
4255 #if CONFIG_H261_DECODER
4256  case AV_CODEC_ID_H261:
4257 #endif
4258 #if CONFIG_H263_DECODER
4259  case AV_CODEC_ID_H263:
4260 #endif
4261 #if CONFIG_MPEG4_DECODER
4262  case AV_CODEC_ID_MPEG4:
4263 #endif
4264  st->codecpar->width = 0; /* let decoder init width/height */
4265  st->codecpar->height= 0;
4266  break;
4267  }
4268 
4269  // If the duration of the mp3 packets is not constant, then they could need a parser
4270  if (st->codecpar->codec_id == AV_CODEC_ID_MP3
4271  && sc->stts_count > 3
4272  && sc->stts_count*10 > st->nb_frames
4273  && sc->time_scale == st->codecpar->sample_rate) {
4275  }
4276  /* Do not need those anymore. */
4277  av_freep(&sc->chunk_offsets);
4278  av_freep(&sc->sample_sizes);
4279  av_freep(&sc->keyframes);
4280  av_freep(&sc->stts_data);
4281  av_freep(&sc->stps_data);
4282  av_freep(&sc->elst_data);
4283  av_freep(&sc->rap_group);
4284 
4285  return 0;
4286 }
4287 
4289 {
4290  int ret;
4291  c->itunes_metadata = 1;
4292  ret = mov_read_default(c, pb, atom);
4293  c->itunes_metadata = 0;
4294  return ret;
4295 }
4296 
4298 {
4299  uint32_t count;
4300  uint32_t i;
4301 
4302  if (atom.size < 8)
4303  return 0;
4304 
4305  avio_skip(pb, 4);
4306  count = avio_rb32(pb);
4307  if (count > UINT_MAX / sizeof(*c->meta_keys) - 1) {
4308  av_log(c->fc, AV_LOG_ERROR,
4309  "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
4310  return AVERROR_INVALIDDATA;
4311  }
4312 
4313  c->meta_keys_count = count + 1;
4314  c->meta_keys = av_mallocz(c->meta_keys_count * sizeof(*c->meta_keys));
4315  if (!c->meta_keys)
4316  return AVERROR(ENOMEM);
4317 
4318  for (i = 1; i <= count; ++i) {
4319  uint32_t key_size = avio_rb32(pb);
4320  uint32_t type = avio_rl32(pb);
4321  if (key_size < 8) {
4322  av_log(c->fc, AV_LOG_ERROR,
4323  "The key# %"PRIu32" in meta has invalid size:"
4324  "%"PRIu32"\n", i, key_size);
4325  return AVERROR_INVALIDDATA;
4326  }
4327  key_size -= 8;
4328  if (type != MKTAG('m','d','t','a')) {
4329  avio_skip(pb, key_size);
4330  }
4331  c->meta_keys[i] = av_mallocz(key_size + 1);
4332  if (!c->meta_keys[i])
4333  return AVERROR(ENOMEM);
4334  avio_read(pb, c->meta_keys[i], key_size);
4335  }
4336 
4337  return 0;
4338 }
4339 
4341 {
4342  int64_t end = avio_tell(pb) + atom.size;
4343  uint8_t *key = NULL, *val = NULL, *mean = NULL;
4344  int i;
4345  int ret = 0;
4346  AVStream *st;
4347  MOVStreamContext *sc;
4348 
4349  if (c->fc->nb_streams < 1)
4350  return 0;
4351  st = c->fc->streams[c->fc->nb_streams-1];
4352  sc = st->priv_data;
4353 
4354  for (i = 0; i < 3; i++) {
4355  uint8_t **p;
4356  uint32_t len, tag;
4357 
4358  if (end - avio_tell(pb) <= 12)
4359  break;
4360 
4361  len = avio_rb32(pb);
4362  tag = avio_rl32(pb);
4363  avio_skip(pb, 4); // flags
4364 
4365  if (len < 12 || len - 12 > end - avio_tell(pb))
4366  break;
4367  len -= 12;
4368 
4369  if (tag == MKTAG('m', 'e', 'a', 'n'))
4370  p = &mean;
4371  else if (tag == MKTAG('n', 'a', 'm', 'e'))
4372  p = &key;
4373  else if (tag == MKTAG('d', 'a', 't', 'a') && len > 4) {
4374  avio_skip(pb, 4);
4375  len -= 4;
4376  p = &val;
4377  } else
4378  break;
4379 
4380  *p = av_malloc(len + 1);
4381  if (!*p) {
4382  ret = AVERROR(ENOMEM);
4383  break;
4384  }
4385  ret = ffio_read_size(pb, *p, len);
4386  if (ret < 0) {
4387  av_freep(p);
4388  break;
4389  }
4390  (*p)[len] = 0;
4391  }
4392 
4393  if (mean && key && val) {
4394  if (strcmp(key, "iTunSMPB") == 0) {
4395  int priming, remainder, samples;
4396  if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
4397  if(priming>0 && priming<16384)
4398  sc->start_pad = priming;
4399  }
4400  }
4401  if (strcmp(key, "cdec") != 0) {
4402  av_dict_set(&c->fc->metadata, key, val,
4404  key = val = NULL;
4405  }
4406  } else {
4407  av_log(c->fc, AV_LOG_VERBOSE,
4408  "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
4409  }
4410 
4411  avio_seek(pb, end, SEEK_SET);
4412  av_freep(&key);
4413  av_freep(&val);
4414  av_freep(&mean);
4415  return ret;
4416 }
4417 
4419 {
4420  while (atom.size > 8) {
4421  uint32_t tag;
4422  if (avio_feof(pb))
4423  return AVERROR_EOF;
4424  tag = avio_rl32(pb);
4425  atom.size -= 4;
4426  if (tag == MKTAG('h','d','l','r')) {
4427  avio_seek(pb, -8, SEEK_CUR);
4428  atom.size += 8;
4429  return mov_read_default(c, pb, atom);
4430  }
4431  }
4432  return 0;
4433 }
4434 
4435 // return 1 when matrix is identity, 0 otherwise
4436 #define IS_MATRIX_IDENT(matrix) \
4437  ( (matrix)[0][0] == (1 << 16) && \
4438  (matrix)[1][1] == (1 << 16) && \
4439  (matrix)[2][2] == (1 << 30) && \
4440  !(matrix)[0][1] && !(matrix)[0][2] && \
4441  !(matrix)[1][0] && !(matrix)[1][2] && \
4442  !(matrix)[2][0] && !(matrix)[2][1])
4443 
4445 {
4446  int i, j, e;
4447  int width;
4448  int height;
4449  int display_matrix[3][3];
4450  int res_display_matrix[3][3] = { { 0 } };
4451  AVStream *st;
4452  MOVStreamContext *sc;
4453  int version;
4454  int flags;
4455 
4456  if (c->fc->nb_streams < 1)
4457  return 0;
4458  st = c->fc->streams[c->fc->nb_streams-1];
4459  sc = st->priv_data;
4460 
4461  // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
4462  // avoids corrupting AVStreams mapped to an earlier tkhd.
4463  if (st->id != -1)
4464  return AVERROR_INVALIDDATA;
4465 
4466  version = avio_r8(pb);
4467  flags = avio_rb24(pb);
4469 
4470  if (version == 1) {
4471  avio_rb64(pb);
4472  avio_rb64(pb);
4473  } else {
4474  avio_rb32(pb); /* creation time */
4475  avio_rb32(pb); /* modification time */
4476  }
4477  st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
4478  avio_rb32(pb); /* reserved */
4479 
4480  /* highlevel (considering edits) duration in movie timebase */
4481  (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
4482  avio_rb32(pb); /* reserved */
4483  avio_rb32(pb); /* reserved */
4484 
4485  avio_rb16(pb); /* layer */
4486  avio_rb16(pb); /* alternate group */
4487  avio_rb16(pb); /* volume */
4488  avio_rb16(pb); /* reserved */
4489 
4490  //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
4491  // they're kept in fixed point format through all calculations
4492  // save u,v,z to store the whole matrix in the AV_PKT_DATA_DISPLAYMATRIX
4493  // side data, but the scale factor is not needed to calculate aspect ratio
4494  for (i = 0; i < 3; i++) {
4495  display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
4496  display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
4497  display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
4498  }
4499 
4500  width = avio_rb32(pb); // 16.16 fixed point track width
4501  height = avio_rb32(pb); // 16.16 fixed point track height
4502  sc->width = width >> 16;
4503  sc->height = height >> 16;
4504 
4505  // apply the moov display matrix (after the tkhd one)
4506  for (i = 0; i < 3; i++) {
4507  const int sh[3] = { 16, 16, 30 };
4508  for (j = 0; j < 3; j++) {
4509  for (e = 0; e < 3; e++) {
4510  res_display_matrix[i][j] +=
4511  ((int64_t) display_matrix[i][e] *
4512  c->movie_display_matrix[e][j]) >> sh[e];
4513  }
4514  }
4515  }
4516 
4517  // save the matrix when it is not the default identity
4518  if (!IS_MATRIX_IDENT(res_display_matrix)) {
4519  double rotate;
4520 
4521  av_freep(&sc->display_matrix);
4522  sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
4523  if (!sc->display_matrix)
4524  return AVERROR(ENOMEM);
4525 
4526  for (i = 0; i < 3; i++)
4527  for (j = 0; j < 3; j++)
4528  sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
4529 
4532  if (!isnan(rotate)) {
4533  char rotate_buf[64];
4534  rotate = -rotate;
4535  if (rotate < 0) // for backward compatibility
4536  rotate += 360;
4537  snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
4538  av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
4539  }
4540 #endif
4541  }
4542 
4543  // transform the display width/height according to the matrix
4544  // to keep the same scale, use [width height 1<<16]
4545  if (width && height && sc->display_matrix) {
4546  double disp_transform[2];
4547 
4548  for (i = 0; i < 2; i++)
4549  disp_transform[i] = hypot(sc->display_matrix[0 + i],
4550  sc->display_matrix[3 + i]);
4551 
4552  if (disp_transform[0] > 0 && disp_transform[1] > 0 &&
4553  disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4554  fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4556  disp_transform[0] / disp_transform[1],
4557  INT_MAX);
4558  }
4559  return 0;
4560 }
4561 
4563 {
4564  MOVFragment *frag = &c->fragment;
4565  MOVTrackExt *trex = NULL;
4566  int flags, track_id, i;
4567 
4568  avio_r8(pb); /* version */
4569  flags = avio_rb24(pb);
4570 
4571  track_id = avio_rb32(pb);
4572  if (!track_id)
4573  return AVERROR_INVALIDDATA;
4574  for (i = 0; i < c->trex_count; i++)
4575  if (c->trex_data[i].track_id == track_id) {
4576  trex = &c->trex_data[i];
4577  break;
4578  }
4579  if (!trex) {
4580  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding trex (id %u)\n", track_id);
4581  return 0;
4582  }
4583  c->fragment.found_tfhd = 1;
4584  frag->track_id = track_id;
4585  set_frag_stream(&c->frag_index, track_id);
4586 
4589  frag->moof_offset : frag->implicit_offset;
4590  frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
4591 
4592  frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
4593  avio_rb32(pb) : trex->duration;
4594  frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
4595  avio_rb32(pb) : trex->size;
4596  frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
4597  avio_rb32(pb) : trex->flags;
4598  av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
4599 
4600  return 0;
4601 }
4602 
4604 {
4605  unsigned i, num;
4606  void *new_tracks;
4607 
4608  num = atom.size / 4;
4609  if (!(new_tracks = av_malloc_array(num, sizeof(int))))
4610  return AVERROR(ENOMEM);
4611 
4612  av_free(c->chapter_tracks);
4613  c->chapter_tracks = new_tracks;
4614  c->nb_chapter_tracks = num;
4615 
4616  for (i = 0; i < num && !pb->eof_reached; i++)
4617  c->chapter_tracks[i] = avio_rb32(pb);
4618 
4619  return 0;
4620 }
4621 
4623 {
4624  MOVTrackExt *trex;
4625  int err;
4626 
4627  if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
4628  return AVERROR_INVALIDDATA;
4629  if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
4630  sizeof(*c->trex_data))) < 0) {
4631  c->trex_count = 0;
4632  return err;
4633  }
4634 
4635  c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
4636 
4637  trex = &c->trex_data[c->trex_count++];
4638  avio_r8(pb); /* version */
4639  avio_rb24(pb); /* flags */
4640  trex->track_id = avio_rb32(pb);
4641  trex->stsd_id = avio_rb32(pb);
4642  trex->duration = avio_rb32(pb);
4643  trex->size = avio_rb32(pb);
4644  trex->flags = avio_rb32(pb);
4645  return 0;
4646 }
4647 
4649 {
4650  MOVFragment *frag = &c->fragment;
4651  AVStream *st = NULL;
4652  MOVStreamContext *sc;
4653  int version, i;
4654  MOVFragmentStreamInfo * frag_stream_info;
4655  int64_t base_media_decode_time;
4656 
4657  for (i = 0; i < c->fc->nb_streams; i++) {
4658  if (c->fc->streams[i]->id == frag->track_id) {
4659  st = c->fc->streams[i];
4660  break;
4661  }
4662  }
4663  if (!st) {
4664  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4665  return 0;
4666  }
4667  sc = st->priv_data;
4668  if (sc->pseudo_stream_id + 1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4669  return 0;
4670  version = avio_r8(pb);
4671  avio_rb24(pb); /* flags */
4672  if (version) {
4673  base_media_decode_time = avio_rb64(pb);
4674  } else {
4675  base_media_decode_time = avio_rb32(pb);
4676  }
4677 
4678  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4679  if (frag_stream_info)
4680  frag_stream_info->tfdt_dts = base_media_decode_time;
4681  sc->track_end = base_media_decode_time;
4682 
4683  return 0;
4684 }
4685 
4687 {
4688  MOVFragment *frag = &c->fragment;
4689  AVStream *st = NULL;
4690  MOVStreamContext *sc;
4691  MOVStts *ctts_data;
4692  uint64_t offset;
4693  int64_t dts, pts = AV_NOPTS_VALUE;
4694  int data_offset = 0;
4695  unsigned entries, first_sample_flags = frag->flags;
4696  int flags, distance, i;
4697  int64_t prev_dts = AV_NOPTS_VALUE;
4698  int next_frag_index = -1, index_entry_pos;
4699  size_t requested_size;
4700  size_t old_ctts_allocated_size;
4701  AVIndexEntry *new_entries;
4702  MOVFragmentStreamInfo * frag_stream_info;
4703 
4704  if (!frag->found_tfhd) {
4705  av_log(c->fc, AV_LOG_ERROR, "trun track id unknown, no tfhd was found\n");
4706  return AVERROR_INVALIDDATA;
4707  }
4708 
4709  for (i = 0; i < c->fc->nb_streams; i++) {
4710  if (c->fc->streams[i]->id == frag->track_id) {
4711  st = c->fc->streams[i];
4712  break;
4713  }
4714  }
4715  if (!st) {
4716  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4717  return 0;
4718  }
4719  sc = st->priv_data;
4720  if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4721  return 0;
4722 
4723  // Find the next frag_index index that has a valid index_entry for
4724  // the current track_id.
4725  //
4726  // A valid index_entry means the trun for the fragment was read
4727  // and it's samples are in index_entries at the given position.
4728  // New index entries will be inserted before the index_entry found.
4729  index_entry_pos = st->nb_index_entries;
4730  for (i = c->frag_index.current + 1; i < c->frag_index.nb_items; i++) {
4731  frag_stream_info = get_frag_stream_info(&c->frag_index, i, frag->track_id);
4732  if (frag_stream_info && frag_stream_info->index_entry >= 0) {
4733  next_frag_index = i;
4734  index_entry_pos = frag_stream_info->index_entry;
4735  break;
4736  }
4737  }
4738  av_assert0(index_entry_pos <= st->nb_index_entries);
4739 
4740  avio_r8(pb); /* version */
4741  flags = avio_rb24(pb);
4742  entries = avio_rb32(pb);
4743  av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
4744 
4745  if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
4746  return AVERROR_INVALIDDATA;
4747  if (flags & MOV_TRUN_DATA_OFFSET) data_offset = avio_rb32(pb);
4748  if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
4749 
4750  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4751  if (frag_stream_info)
4752  {
4753  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
4755  pts = frag_stream_info->first_tfra_pts;
4756  av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
4757  ", using it for pts\n", pts);
4758  } else if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE) {
4759  // FIXME: sidx earliest_presentation_time is *PTS*, s.b.
4760  // pts = frag_stream_info->sidx_pts;
4761  dts = frag_stream_info->sidx_pts - sc->time_offset;
4762  av_log(c->fc, AV_LOG_DEBUG, "found sidx time %"PRId64
4763  ", using it for pts\n", pts);
4764  } else if (frag_stream_info->tfdt_dts != AV_NOPTS_VALUE) {
4765  dts = frag_stream_info->tfdt_dts - sc->time_offset;
4766  av_log(c->fc, AV_LOG_DEBUG, "found tfdt time %"PRId64
4767  ", using it for dts\n", dts);
4768  } else {
4769  dts = sc->track_end - sc->time_offset;
4770  av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4771  ", using it for dts\n", dts);
4772  }
4773  } else {
4774  dts = sc->track_end - sc->time_offset;
4775  av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4776  ", using it for dts\n", dts);
4777  }
4778  offset = frag->base_data_offset + data_offset;
4779  distance = 0;
4780  av_log(c->fc, AV_LOG_TRACE, "first sample flags 0x%x\n", first_sample_flags);
4781 
4782  // realloc space for new index entries
4783  if((uint64_t)st->nb_index_entries + entries >= UINT_MAX / sizeof(AVIndexEntry)) {
4784  entries = UINT_MAX / sizeof(AVIndexEntry) - st->nb_index_entries;
4785  av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n");
4786  }
4787  if (entries <= 0)
4788  return -1;
4789 
4790  requested_size = (st->nb_index_entries + entries) * sizeof(AVIndexEntry);
4791  new_entries = av_fast_realloc(st->index_entries,
4793  requested_size);
4794  if(!new_entries)
4795  return AVERROR(ENOMEM);
4796  st->index_entries= new_entries;
4797 
4798  requested_size = (st->nb_index_entries + entries) * sizeof(*sc->ctts_data);
4799  old_ctts_allocated_size = sc->ctts_allocated_size;
4800  ctts_data = av_fast_realloc(sc->ctts_data, &sc->ctts_allocated_size,
4801  requested_size);
4802  if (!ctts_data)
4803  return AVERROR(ENOMEM);
4804  sc->ctts_data = ctts_data;
4805 
4806  // In case there were samples without ctts entries, ensure they get
4807  // zero valued entries. This ensures clips which mix boxes with and
4808  // without ctts entries don't pickup uninitialized data.
4809  memset((uint8_t*)(sc->ctts_data) + old_ctts_allocated_size, 0,
4810  sc->ctts_allocated_size - old_ctts_allocated_size);
4811 
4812  if (index_entry_pos < st->nb_index_entries) {
4813  // Make hole in index_entries and ctts_data for new samples
4814  memmove(st->index_entries + index_entry_pos + entries,
4815  st->index_entries + index_entry_pos,
4816  sizeof(*st->index_entries) *
4817  (st->nb_index_entries - index_entry_pos));
4818  memmove(sc->ctts_data + index_entry_pos + entries,
4819  sc->ctts_data + index_entry_pos,
4820  sizeof(*sc->ctts_data) * (sc->ctts_count - index_entry_pos));
4821  if (index_entry_pos < sc->current_sample) {
4822  sc->current_sample += entries;
4823  }
4824  }
4825 
4826  st->nb_index_entries += entries;
4827  sc->ctts_count = st->nb_index_entries;
4828 
4829  // Record the index_entry position in frag_index of this fragment
4830  if (frag_stream_info)
4831  frag_stream_info->index_entry = index_entry_pos;
4832 
4833  if (index_entry_pos > 0)
4834  prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4835 
4836  for (i = 0; i < entries && !pb->eof_reached; i++) {
4837  unsigned sample_size = frag->size;
4838  int sample_flags = i ? frag->flags : first_sample_flags;
4839  unsigned sample_duration = frag->duration;
4840  unsigned ctts_duration = 0;
4841  int keyframe = 0;
4842  int index_entry_flags = 0;
4843 
4844  if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
4845  if (flags & MOV_TRUN_SAMPLE_SIZE) sample_size = avio_rb32(pb);
4846  if (flags & MOV_TRUN_SAMPLE_FLAGS) sample_flags = avio_rb32(pb);
4847  if (flags & MOV_TRUN_SAMPLE_CTS) ctts_duration = avio_rb32(pb);
4848 
4849  mov_update_dts_shift(sc, ctts_duration);
4850  if (pts != AV_NOPTS_VALUE) {
4851  dts = pts - sc->dts_shift;
4852  if (flags & MOV_TRUN_SAMPLE_CTS) {
4853  dts -= ctts_duration;
4854  } else {
4855  dts -= sc->time_offset;
4856  }
4857  av_log(c->fc, AV_LOG_DEBUG,
4858  "pts %"PRId64" calculated dts %"PRId64
4859  " sc->dts_shift %d ctts.duration %d"
4860  " sc->time_offset %"PRId64
4861  " flags & MOV_TRUN_SAMPLE_CTS %d\n",
4862  pts, dts,
4863  sc->dts_shift, ctts_duration,
4864  sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
4865  pts = AV_NOPTS_VALUE;
4866  }
4867 
4869  keyframe = 1;
4870  else
4871  keyframe =
4872  !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
4874  if (keyframe) {
4875  distance = 0;
4876  index_entry_flags |= AVINDEX_KEYFRAME;
4877  }
4878  // Fragments can overlap in time. Discard overlapping frames after
4879  // decoding.
4880  if (prev_dts >= dts)
4881  index_entry_flags |= AVINDEX_DISCARD_FRAME;
4882 
4883  st->index_entries[index_entry_pos].pos = offset;
4884  st->index_entries[index_entry_pos].timestamp = dts;
4885  st->index_entries[index_entry_pos].size= sample_size;
4886  st->index_entries[index_entry_pos].min_distance= distance;
4887  st->index_entries[index_entry_pos].flags = index_entry_flags;
4888 
4889  sc->ctts_data[index_entry_pos].count = 1;
4890  sc->ctts_data[index_entry_pos].duration = ctts_duration;
4891  index_entry_pos++;
4892 
4893  av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
4894  "size %u, distance %d, keyframe %d\n", st->index,
4895  index_entry_pos, offset, dts, sample_size, distance, keyframe);
4896  distance++;
4897  dts += sample_duration;
4898  offset += sample_size;
4899  sc->data_size += sample_size;
4900 
4901  if (sample_duration <= INT64_MAX - sc->duration_for_fps &&
4902  1 <= INT_MAX - sc->nb_frames_for_fps
4903  ) {
4904  sc->duration_for_fps += sample_duration;
4905  sc->nb_frames_for_fps ++;
4906  }
4907  }
4908  if (i < entries) {
4909  // EOF found before reading all entries. Fix the hole this would
4910  // leave in index_entries and ctts_data
4911  int gap = entries - i;
4912  memmove(st->index_entries + index_entry_pos,
4913  st->index_entries + index_entry_pos + gap,
4914  sizeof(*st->index_entries) *
4915  (st->nb_index_entries - (index_entry_pos + gap)));
4916  memmove(sc->ctts_data + index_entry_pos,
4917  sc->ctts_data + index_entry_pos + gap,
4918  sizeof(*sc->ctts_data) *
4919  (sc->ctts_count - (index_entry_pos + gap)));
4920 
4921  st->nb_index_entries -= gap;
4922  sc->ctts_count -= gap;
4923  if (index_entry_pos < sc->current_sample) {
4924  sc->current_sample -= gap;
4925  }
4926  entries = i;
4927  }
4928 
4929  // The end of this new fragment may overlap in time with the start
4930  // of the next fragment in index_entries. Mark the samples in the next
4931  // fragment that overlap with AVINDEX_DISCARD_FRAME
4932  prev_dts = AV_NOPTS_VALUE;
4933  if (index_entry_pos > 0)
4934  prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4935  for (i = index_entry_pos; i < st->nb_index_entries; i++) {
4936  if (prev_dts < st->index_entries[i].timestamp)
4937  break;
4939  }
4940 
4941  // If a hole was created to insert the new index_entries into,
4942  // the index_entry recorded for all subsequent moof must
4943  // be incremented by the number of entries inserted.
4944  fix_frag_index_entries(&c->frag_index, next_frag_index,
4945  frag->track_id, entries);
4946 
4947  if (pb->eof_reached) {
4948  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted TRUN atom\n");
4949  return AVERROR_EOF;
4950  }
4951 
4952  frag->implicit_offset = offset;
4953 
4954  sc->track_end = dts + sc->time_offset;
4955  if (st->duration < sc->track_end)
4956  st->duration = sc->track_end;
4957 
4958  return 0;
4959 }
4960 
4962 {
4963  int64_t offset = avio_tell(pb) + atom.size, pts, timestamp;
4964  uint8_t version;
4965  unsigned i, j, track_id, item_count;
4966  AVStream *st = NULL;
4967  AVStream *ref_st = NULL;
4968  MOVStreamContext *sc, *ref_sc = NULL;
4969  AVRational timescale;
4970 
4971  version = avio_r8(pb);
4972  if (version > 1) {
4973  avpriv_request_sample(c->fc, "sidx version %u", version);
4974  return 0;
4975  }
4976 
4977  avio_rb24(pb); // flags
4978 
4979  track_id = avio_rb32(pb); // Reference ID
4980  for (i = 0; i < c->fc->nb_streams; i++) {
4981  if (c->fc->streams[i]->id == track_id) {
4982  st = c->fc->streams[i];
4983  break;
4984  }
4985  }
4986  if (!st) {
4987  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %d\n", track_id);
4988  return 0;
4989  }
4990 
4991  sc = st->priv_data;
4992 
4993  timescale = av_make_q(1, avio_rb32(pb));
4994 
4995  if (timescale.den <= 0) {
4996  av_log(c->fc, AV_LOG_ERROR, "Invalid sidx timescale 1/%d\n", timescale.den);
4997  return AVERROR_INVALIDDATA;
4998  }
4999 
5000  if (version == 0) {
5001  pts = avio_rb32(pb);
5002  offset += avio_rb32(pb);
5003  } else {
5004  pts = avio_rb64(pb);
5005  offset += avio_rb64(pb);
5006  }
5007 
5008  avio_rb16(pb); // reserved
5009 
5010  item_count = avio_rb16(pb);
5011 
5012  for (i = 0; i < item_count; i++) {
5013  int index;
5014  MOVFragmentStreamInfo * frag_stream_info;
5015  uint32_t size = avio_rb32(pb);
5016  uint32_t duration = avio_rb32(pb);
5017  if (size & 0x80000000) {
5018  avpriv_request_sample(c->fc, "sidx reference_type 1");
5019  return AVERROR_PATCHWELCOME;
5020  }
5021  avio_rb32(pb); // sap_flags
5022  timestamp = av_rescale_q(pts, st->time_base, timescale);
5023 
5024  index = update_frag_index(c, offset);
5025  frag_stream_info = get_frag_stream_info(&c->frag_index, index, track_id);
5026  if (frag_stream_info)
5027  frag_stream_info->sidx_pts = timestamp;
5028 
5029  offset += size;
5030  pts += duration;
5031  }
5032 
5033  st->duration = sc->track_end = pts;
5034 
5035  sc->has_sidx = 1;
5036 
5037  if (offset == avio_size(pb)) {
5038  // Find first entry in fragment index that came from an sidx.
5039  // This will pretty much always be the first entry.
5040  for (i = 0; i < c->frag_index.nb_items; i++) {
5041  MOVFragmentIndexItem * item = &c->frag_index.item[i];
5042  for (j = 0; ref_st == NULL && j < item->nb_stream_info; j++) {
5043  MOVFragmentStreamInfo * si;
5044  si = &item->stream_info[j];
5045  if (si->sidx_pts != AV_NOPTS_VALUE) {
5046  ref_st = c->fc->streams[j];
5047  ref_sc = ref_st->priv_data;
5048  break;
5049  }
5050  }
5051  }
5052  if (ref_st) for (i = 0; i < c->fc->nb_streams; i++) {
5053  st = c->fc->streams[i];
5054  sc = st->priv_data;
5055  if (!sc->has_sidx) {
5056  st->duration = sc->track_end = av_rescale(ref_st->duration, sc->time_scale, ref_sc->time_scale);
5057  }
5058  }
5059 
5060  c->frag_index.complete = 1;
5061  }
5062 
5063  return 0;
5064 }
5065 
5066 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
5067 /* like the files created with Adobe Premiere 5.0, for samples see */
5068 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
5070 {
5071  int err;
5072 
5073  if (atom.size < 8)
5074  return 0; /* continue */
5075  if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
5076  avio_skip(pb, atom.size - 4);
5077  return 0;
5078  }
5079  atom.type = avio_rl32(pb);
5080  atom.size -= 8;
5081  if (atom.type != MKTAG('m','d','a','t')) {
5082  avio_skip(pb, atom.size);
5083  return 0;
5084  }
5085  err = mov_read_mdat(c, pb, atom);
5086  return err;
5087 }
5088 
5090 {
5091 #if CONFIG_ZLIB
5092  AVIOContext ctx;
5093  uint8_t *cmov_data;
5094  uint8_t *moov_data; /* uncompressed data */
5095  long cmov_len, moov_len;
5096  int ret = -1;
5097 
5098  avio_rb32(pb); /* dcom atom */
5099  if (avio_rl32(pb) != MKTAG('d','c','o','m'))
5100  return AVERROR_INVALIDDATA;
5101  if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
5102  av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
5103  return AVERROR_INVALIDDATA;
5104  }
5105  avio_rb32(pb); /* cmvd atom */
5106  if (avio_rl32(pb) != MKTAG('c','m','v','d'))
5107  return AVERROR_INVALIDDATA;
5108  moov_len = avio_rb32(pb); /* uncompressed size */
5109  cmov_len = atom.size - 6 * 4;
5110 
5111  cmov_data = av_malloc(cmov_len);
5112  if (!cmov_data)
5113  return AVERROR(ENOMEM);
5114  moov_data = av_malloc(moov_len);
5115  if (!moov_data) {
5116  av_free(cmov_data);
5117  return AVERROR(ENOMEM);
5118  }
5119  ret = ffio_read_size(pb, cmov_data, cmov_len);
5120  if (ret < 0)
5121  goto free_and_return;
5122 
5123  ret = AVERROR_INVALIDDATA;
5124  if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
5125  goto free_and_return;
5126  if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
5127  goto free_and_return;
5129  atom.type = MKTAG('m','o','o','v');
5130  atom.size = moov_len;
5131  ret = mov_read_default(c, &ctx, atom);
5132 free_and_return:
5133  av_free(moov_data);
5134  av_free(cmov_data);
5135  return ret;
5136 #else
5137  av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
5138  return AVERROR(ENOSYS);
5139 #endif
5140 }
5141 
5142 /* edit list atom */
5144 {
5145  MOVStreamContext *sc;
5146  int i, edit_count, version;
5147  int64_t elst_entry_size;
5148 
5149  if (c->fc->nb_streams < 1 || c->ignore_editlist)
5150  return 0;
5151  sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
5152 
5153  version = avio_r8(pb); /* version */
5154  avio_rb24(pb); /* flags */
5155  edit_count = avio_rb32(pb); /* entries */
5156  atom.size -= 8;
5157 
5158  elst_entry_size = version == 1 ? 20 : 12;
5159  if (atom.size != edit_count * elst_entry_size) {
5161  av_log(c->fc, AV_LOG_ERROR, "Invalid edit list entry_count: %d for elst atom of size: %"PRId64" bytes.\n",
5162  edit_count, atom.size + 8);
5163  return AVERROR_INVALIDDATA;
5164  } else {
5165  edit_count = atom.size / elst_entry_size;
5166  if (edit_count * elst_entry_size != atom.size) {
5167  av_log(c->fc, AV_LOG_WARNING, "ELST atom of %"PRId64" bytes, bigger than %d entries.", atom.size, edit_count);
5168  }
5169  }
5170  }
5171 
5172  if (!edit_count)
5173  return 0;
5174  if (sc->elst_data)
5175  av_log(c->fc, AV_LOG_WARNING, "Duplicated ELST atom\n");
5176  av_free(sc->elst_data);
5177  sc->elst_count = 0;
5178  sc->elst_data = av_malloc_array(edit_count, sizeof(*sc->elst_data));
5179  if (!sc->elst_data)
5180  return AVERROR(ENOMEM);
5181 
5182  av_log(c->fc, AV_LOG_TRACE, "track[%u].edit_count = %i\n", c->fc->nb_streams - 1, edit_count);
5183  for (i = 0; i < edit_count && atom.size > 0 && !pb->eof_reached; i++) {
5184  MOVElst *e = &sc->elst_data[i];
5185 
5186  if (version == 1) {
5187  e->duration = avio_rb64(pb);
5188  e->time = avio_rb64(pb);
5189  atom.size -= 16;
5190  } else {
5191  e->duration = avio_rb32(pb); /* segment duration */
5192  e->time = (int32_t)avio_rb32(pb); /* media time */
5193  atom.size -= 8;
5194  }
5195  e->rate = avio_rb32(pb) / 65536.0;
5196  atom.size -= 4;
5197  av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
5198  e->duration, e->time, e->rate);
5199 
5200  if (e->time < 0 && e->time != -1 &&
5202  av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list media time=%"PRId64"\n",
5203  c->fc->nb_streams-1, i, e->time);
5204  return AVERROR_INVALIDDATA;
5205  }
5206  }
5207  sc->elst_count = i;
5208 
5209  return 0;
5210 }
5211 
5213 {
5214  MOVStreamContext *sc;
5215 
5216  if (c->fc->nb_streams < 1)
5217  return AVERROR_INVALIDDATA;
5218  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5219  sc->timecode_track = avio_rb32(pb);
5220  return 0;
5221 }
5222 
5224 {
5225  AVStream *st;
5226  int ret;
5227 
5228  if (c->fc->nb_streams < 1)
5229  return 0;
5230  st = c->fc->streams[c->fc->nb_streams - 1];
5231 
5232  if (atom.size < 4) {
5233  av_log(c->fc, AV_LOG_ERROR, "Empty AV1 Codec Configuration Box\n");
5234  return AVERROR_INVALIDDATA;
5235  }
5236 
5237  /* For now, propagate only the OBUs, if any. Once libavcodec is
5238  updated to handle isobmff style extradata this can be removed. */
5239  avio_skip(pb, 4);
5240 
5241  if (atom.size == 4)
5242  return 0;
5243 
5244  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 4);
5245  if (ret < 0)
5246  return ret;
5247 
5248  return 0;
5249 }
5250 
5252 {
5253  AVStream *st;
5254  int version, color_range, color_primaries, color_trc, color_space;
5255 
5256  if (c->fc->nb_streams < 1)
5257  return 0;
5258  st = c->fc->streams[c->fc->nb_streams - 1];
5259 
5260  if (atom.size < 5) {
5261  av_log(c->fc, AV_LOG_ERROR, "Empty VP Codec Configuration box\n");
5262  return AVERROR_INVALIDDATA;
5263  }
5264 
5265  version = avio_r8(pb);
5266  if (version != 1) {
5267  av_log(c->fc, AV_LOG_WARNING, "Unsupported VP Codec Configuration box version %d\n", version);
5268  return 0;
5269  }
5270  avio_skip(pb, 3); /* flags */
5271 
5272  avio_skip(pb, 2); /* profile + level */
5273  color_range = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
5274  color_primaries = avio_r8(pb);
5275  color_trc = avio_r8(pb);
5276  color_space = avio_r8(pb);
5277  if (avio_rb16(pb)) /* codecIntializationDataSize */
5278  return AVERROR_INVALIDDATA;
5279 
5280  if (!av_color_primaries_name(color_primaries))
5281  color_primaries = AVCOL_PRI_UNSPECIFIED;
5282  if (!av_color_transfer_name(color_trc))
5283  color_trc = AVCOL_TRC_UNSPECIFIED;
5284  if (!av_color_space_name(color_space))
5285  color_space = AVCOL_SPC_UNSPECIFIED;
5286 
5287  st->codecpar->color_range = (color_range & 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
5289  st->codecpar->color_trc = color_trc;
5290  st->codecpar->color_space = color_space;
5291 
5292  return 0;
5293 }
5294 
5296 {
5297  MOVStreamContext *sc;
5298  int i, version;
5299 
5300  if (c->fc->nb_streams < 1)
5301  return AVERROR_INVALIDDATA;
5302 
5303  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5304 
5305  if (atom.size < 5) {
5306  av_log(c->fc, AV_LOG_ERROR, "Empty Mastering Display Metadata box\n");
5307  return AVERROR_INVALIDDATA;
5308  }
5309 
5310  version = avio_r8(pb);
5311  if (version) {
5312  av_log(c->fc, AV_LOG_WARNING, "Unsupported Mastering Display Metadata box version %d\n", version);
5313  return 0;
5314  }
5315  avio_skip(pb, 3); /* flags */
5316 
5318  if (!sc->mastering)
5319  return AVERROR(ENOMEM);
5320 
5321  for (i = 0; i < 3; i++) {
5322  sc->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), 1 << 16);
5323  sc->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), 1 << 16);
5324  }
5325  sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), 1 << 16);
5326  sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), 1 << 16);
5327 
5328  sc->mastering->max_luminance = av_make_q(avio_rb32(pb), 1 << 8);
5329  sc->mastering->min_luminance = av_make_q(avio_rb32(pb), 1 << 14);
5330 
5331  sc->mastering->has_primaries = 1;
5332  sc->mastering->has_luminance = 1;
5333 
5334  return 0;
5335 }
5336 
5338 {
5339  MOVStreamContext *sc;
5340  const int mapping[3] = {1, 2, 0};
5341  const int chroma_den = 50000;
5342  const int luma_den = 10000;
5343  int i;
5344 
5345  if (c->fc->nb_streams < 1)
5346  return AVERROR_INVALIDDATA;
5347 
5348  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5349 
5350  if (atom.size < 24) {
5351  av_log(c->fc, AV_LOG_ERROR, "Invalid Mastering Display Color Volume box\n");
5352  return AVERROR_INVALIDDATA;
5353  }
5354 
5356  if (!sc->mastering)
5357  return AVERROR(ENOMEM);
5358 
5359  for (i = 0; i < 3; i++) {
5360  const int j = mapping[i];
5361  sc->mastering->display_primaries[j][0] = av_make_q(avio_rb16(pb), chroma_den);
5362  sc->mastering->display_primaries[j][1] = av_make_q(avio_rb16(pb), chroma_den);
5363  }
5364  sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), chroma_den);
5365  sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), chroma_den);
5366 
5367  sc->mastering->max_luminance = av_make_q(avio_rb32(pb), luma_den);
5368  sc->mastering->min_luminance = av_make_q(avio_rb32(pb), luma_den);
5369 
5370  sc->mastering->has_luminance = 1;
5371  sc->mastering->has_primaries = 1;
5372 
5373  return 0;
5374 }
5375 
5377 {
5378  MOVStreamContext *sc;
5379  int version;
5380 
5381  if (c->fc->nb_streams < 1)
5382  return AVERROR_INVALIDDATA;
5383 
5384  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5385 
5386  if (atom.size < 5) {
5387  av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level box\n");
5388  return AVERROR_INVALIDDATA;
5389  }
5390 
5391  version = avio_r8(pb);
5392  if (version) {
5393  av_log(c->fc, AV_LOG_WARNING, "Unsupported Content Light Level box version %d\n", version);
5394  return 0;
5395  }
5396  avio_skip(pb, 3); /* flags */
5397 
5399  if (!sc->coll)
5400  return AVERROR(ENOMEM);
5401 
5402  sc->coll->MaxCLL = avio_rb16(pb);
5403  sc->coll->MaxFALL = avio_rb16(pb);
5404 
5405  return 0;
5406 }
5407 
5409 {
5410  MOVStreamContext *sc;
5411 
5412  if (c->fc->nb_streams < 1)
5413  return AVERROR_INVALIDDATA;
5414 
5415  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5416 
5417  if (atom.size < 4) {
5418  av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level Info box\n");
5419  return AVERROR_INVALIDDATA;
5420  }
5421 
5423  if (!sc->coll)
5424  return AVERROR(ENOMEM);
5425 
5426  sc->coll->MaxCLL = avio_rb16(pb);
5427  sc->coll->MaxFALL = avio_rb16(pb);
5428 
5429  return 0;
5430 }
5431 
5433 {
5434  AVStream *st;
5435  MOVStreamContext *sc;
5436  enum AVStereo3DType type;
5437  int mode;
5438 
5439  if (c->fc->nb_streams < 1)
5440  return 0;
5441 
5442  st = c->fc->streams[c->fc->nb_streams - 1];
5443  sc = st->priv_data;
5444 
5445  if (atom.size < 5) {
5446  av_log(c->fc, AV_LOG_ERROR, "Empty stereoscopic video box\n");
5447  return AVERROR_INVALIDDATA;
5448  }
5449  avio_skip(pb, 4); /* version + flags */
5450 
5451  mode = avio_r8(pb);
5452  switch (mode) {
5453  case 0:
5454  type = AV_STEREO3D_2D;
5455  break;
5456  case 1:
5457  type = AV_STEREO3D_TOPBOTTOM;
5458  break;
5459  case 2:
5460  type = AV_STEREO3D_SIDEBYSIDE;
5461  break;
5462  default:
5463  av_log(c->fc, AV_LOG_WARNING, "Unknown st3d mode value %d\n", mode);
5464  return 0;
5465  }
5466 
5467  sc->stereo3d = av_stereo3d_alloc();
5468  if (!sc->stereo3d)
5469  return AVERROR(ENOMEM);
5470 
5471  sc->stereo3d->type = type;
5472  return 0;
5473 }
5474 
5476 {
5477  AVStream *st;
5478  MOVStreamContext *sc;
5479  int size, version, layout;
5480  int32_t yaw, pitch, roll;
5481  uint32_t l = 0, t = 0, r = 0, b = 0;
5482  uint32_t tag, padding = 0;
5483  enum AVSphericalProjection projection;
5484 
5485  if (c->fc->nb_streams < 1)
5486  return 0;
5487 
5488  st = c->fc->streams[c->fc->nb_streams - 1];
5489  sc = st->priv_data;
5490 
5491  if (atom.size < 8) {
5492  av_log(c->fc, AV_LOG_ERROR, "Empty spherical video box\n");
5493  return AVERROR_INVALIDDATA;
5494  }
5495 
5496  size = avio_rb32(pb);
5497  if (size <= 12 || size > atom.size)
5498  return AVERROR_INVALIDDATA;
5499 
5500  tag = avio_rl32(pb);
5501  if (tag != MKTAG('s','v','h','d')) {
5502  av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
5503  return 0;
5504  }
5505  version = avio_r8(pb);
5506  if (version != 0) {
5507  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5508  version);
5509  return 0;
5510  }
5511  avio_skip(pb, 3); /* flags */
5512  avio_skip(pb, size - 12); /* metadata_source */
5513 
5514  size = avio_rb32(pb);
5515  if (size > atom.size)
5516  return AVERROR_INVALIDDATA;
5517 
5518  tag = avio_rl32(pb);
5519  if (tag != MKTAG('p','r','o','j')) {
5520  av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
5521  return 0;
5522  }
5523 
5524  size = avio_rb32(pb);
5525  if (size > atom.size)
5526  return AVERROR_INVALIDDATA;
5527 
5528  tag = avio_rl32(pb);
5529  if (tag != MKTAG('p','r','h','d')) {
5530  av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
5531  return 0;
5532  }
5533  version = avio_r8(pb);
5534  if (version != 0) {
5535  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5536  version);
5537  return 0;
5538  }
5539  avio_skip(pb, 3); /* flags */
5540 
5541  /* 16.16 fixed point */
5542  yaw = avio_rb32(pb);
5543  pitch = avio_rb32(pb);
5544  roll = avio_rb32(pb);
5545 
5546  size = avio_rb32(pb);
5547  if (size > atom.size)
5548  return AVERROR_INVALIDDATA;
5549 
5550  tag = avio_rl32(pb);
5551  version = avio_r8(pb);
5552  if (version != 0) {
5553  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5554  version);
5555  return 0;
5556  }
5557  avio_skip(pb, 3); /* flags */
5558  switch (tag) {
5559  case MKTAG('c','b','m','p'):
5560  layout = avio_rb32(pb);
5561  if (layout) {
5562  av_log(c->fc, AV_LOG_WARNING,
5563  "Unsupported cubemap layout %d\n", layout);
5564  return 0;
5565  }
5566  projection = AV_SPHERICAL_CUBEMAP;
5567  padding = avio_rb32(pb);
5568  break;
5569  case MKTAG('e','q','u','i'):
5570  t = avio_rb32(pb);
5571  b = avio_rb32(pb);
5572  l = avio_rb32(pb);
5573  r = avio_rb32(pb);
5574 
5575  if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
5576  av_log(c->fc, AV_LOG_ERROR,
5577  "Invalid bounding rectangle coordinates "
5578  "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
5579  return AVERROR_INVALIDDATA;
5580  }
5581 
5582  if (l || t || r || b)
5583  projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
5584  else
5585  projection = AV_SPHERICAL_EQUIRECTANGULAR;
5586  break;
5587  default:
5588  av_log(c->fc, AV_LOG_ERROR, "Unknown projection type: %s\n", av_fourcc2str(tag));
5589  return 0;
5590  }
5591 
5593  if (!sc->spherical)
5594  return AVERROR(ENOMEM);
5595 
5596  sc->spherical->projection = projection;
5597 
5598  sc->spherical->yaw = yaw;
5599  sc->spherical->pitch = pitch;
5600  sc->spherical->roll = roll;
5601 
5602  sc->spherical->padding = padding;
5603 
5604  sc->spherical->bound_left = l;
5605  sc->spherical->bound_top = t;
5606  sc->spherical->bound_right = r;
5607  sc->spherical->bound_bottom = b;
5608 
5609  return 0;
5610 }
5611 
5613 {
5614  int ret = 0;
5615  uint8_t *buffer = av_malloc(len + 1);
5616  const char *val;
5617 
5618  if (!buffer)
5619  return AVERROR(ENOMEM);
5620  buffer[len] = '\0';
5621 
5622  ret = ffio_read_size(pb, buffer, len);
5623  if (ret < 0)
5624  goto out;
5625 
5626  /* Check for mandatory keys and values, try to support XML as best-effort */
5627  if (!sc->spherical &&
5628  av_stristr(buffer, "<GSpherical:StitchingSoftware>") &&
5629  (val = av_stristr(buffer, "<GSpherical:Spherical>")) &&
5630  av_stristr(val, "true") &&
5631  (val = av_stristr(buffer, "<GSpherical:Stitched>")) &&
5632  av_stristr(val, "true") &&
5633  (val = av_stristr(buffer, "<GSpherical:ProjectionType>")) &&
5634  av_stristr(val, "equirectangular")) {
5636  if (!sc->spherical)
5637  goto out;
5638 
5640 
5641  if (av_stristr(buffer, "<GSpherical:StereoMode>") && !sc->stereo3d) {
5642  enum AVStereo3DType mode;
5643 
5644  if (av_stristr(buffer, "left-right"))
5645  mode = AV_STEREO3D_SIDEBYSIDE;
5646  else if (av_stristr(buffer, "top-bottom"))
5647  mode = AV_STEREO3D_TOPBOTTOM;
5648  else
5649  mode = AV_STEREO3D_2D;
5650 
5651  sc->stereo3d = av_stereo3d_alloc();
5652  if (!sc->stereo3d)
5653  goto out;
5654 
5655  sc->stereo3d->type = mode;
5656  }
5657 
5658  /* orientation */
5659  val = av_stristr(buffer, "<GSpherical:InitialViewHeadingDegrees>");
5660  if (val)
5661  sc->spherical->yaw = strtol(val, NULL, 10) * (1 << 16);
5662  val = av_stristr(buffer, "<GSpherical:InitialViewPitchDegrees>");
5663  if (val)
5664  sc->spherical->pitch = strtol(val, NULL, 10) * (1 << 16);
5665  val = av_stristr(buffer, "<GSpherical:InitialViewRollDegrees>");
5666  if (val)
5667  sc->spherical->roll = strtol(val, NULL, 10) * (1 << 16);
5668  }
5669 
5670 out:
5671  av_free(buffer);
5672  return ret;
5673 }
5674 
5676 {
5677  AVStream *st;
5678  MOVStreamContext *sc;
5679  int64_t ret;
5680  uint8_t uuid[16];
5681  static const uint8_t uuid_isml_manifest[] = {
5682  0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
5683  0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
5684  };
5685  static const uint8_t uuid_xmp[] = {
5686  0xbe, 0x7a, 0xcf, 0xcb, 0x97, 0xa9, 0x42, 0xe8,
5687  0x9c, 0x71, 0x99, 0x94, 0x91, 0xe3, 0xaf, 0xac
5688  };
5689  static const uint8_t uuid_spherical[] = {
5690  0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
5691  0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
5692  };
5693 
5694  if (atom.size < sizeof(uuid) || atom.size >= FFMIN(INT_MAX, SIZE_MAX))
5695  return AVERROR_INVALIDDATA;
5696 
5697  if (c->fc->nb_streams < 1)
5698  return 0;
5699  st = c->fc->streams[c->fc->nb_streams - 1];
5700  sc = st->priv_data;
5701 
5702  ret = avio_read(pb, uuid, sizeof(uuid));
5703  if (ret < 0) {
5704  return ret;
5705  } else if (ret != sizeof(uuid)) {
5706  return AVERROR_INVALIDDATA;
5707  }
5708  if (!memcmp(uuid, uuid_isml_manifest, sizeof(uuid))) {
5709  uint8_t *buffer, *ptr;
5710  char *endptr;
5711  size_t len = atom.size - sizeof(uuid);
5712 
5713  if (len < 4) {
5714  return AVERROR_INVALIDDATA;
5715  }
5716  ret = avio_skip(pb, 4); // zeroes
5717  len -= 4;
5718 
5719  buffer = av_mallocz(len + 1);
5720  if (!buffer) {
5721  return AVERROR(ENOMEM);
5722  }
5723  ret = avio_read(pb, buffer, len);
5724  if (ret < 0) {
5725  av_free(buffer);
5726  return ret;
5727  } else if (ret != len) {
5728  av_free(buffer);
5729  return AVERROR_INVALIDDATA;
5730  }
5731 
5732  ptr = buffer;
5733  while ((ptr = av_stristr(ptr, "systemBitrate=\""))) {
5734  ptr += sizeof("systemBitrate=\"") - 1;
5735  c->bitrates_count++;
5736  c->bitrates = av_realloc_f(c->bitrates, c->bitrates_count, sizeof(*c->bitrates));
5737  if (!c->bitrates) {
5738  c->bitrates_count = 0;
5739  av_free(buffer);
5740  return AVERROR(ENOMEM);
5741  }
5742  errno = 0;
5743  ret = strtol(ptr, &endptr, 10);
5744  if (ret < 0 || errno || *endptr != '"') {
5745  c->bitrates[c->bitrates_count - 1] = 0;
5746  } else {
5747  c->bitrates[c->bitrates_count - 1] = ret;
5748  }
5749  }
5750 
5751  av_free(buffer);
5752  } else if (!memcmp(uuid, uuid_xmp, sizeof(uuid))) {
5753  uint8_t *buffer;
5754  size_t len = atom.size - sizeof(uuid);
5755  if (c->export_xmp) {
5756  buffer = av_mallocz(len + 1);
5757  if (!buffer) {
5758  return AVERROR(ENOMEM);
5759  }
5760  ret = avio_read(pb, buffer, len);
5761  if (ret < 0) {
5762  av_free(buffer);
5763  return ret;
5764  } else if (ret != len) {
5765  av_free(buffer);
5766  return AVERROR_INVALIDDATA;
5767  }
5768  buffer[len] = '\0';
5769  av_dict_set(&c->fc->metadata, "xmp", buffer, 0);
5770  av_free(buffer);
5771  } else {
5772  // skip all uuid atom, which makes it fast for long uuid-xmp file
5773  ret = avio_skip(pb, len);
5774  if (ret < 0)
5775  return ret;
5776  }
5777  } else if (!memcmp(uuid, uuid_spherical, sizeof(uuid))) {
5778  size_t len = atom.size - sizeof(uuid);
5779  ret = mov_parse_uuid_spherical(sc, pb, len);
5780  if (ret < 0)
5781  return ret;
5782  if (!sc->spherical)
5783  av_log(c->fc, AV_LOG_WARNING, "Invalid spherical metadata found\n");
5784  }
5785 
5786  return 0;
5787 }
5788 
5790 {
5791  int ret;
5792  uint8_t content[16];
5793 
5794  if (atom.size < 8)
5795  return 0;
5796 
5797  ret = avio_read(pb, content, FFMIN(sizeof(content), atom.size));
5798  if (ret < 0)
5799  return ret;
5800 
5801  if ( !c->found_moov
5802  && !c->found_mdat
5803  && !memcmp(content, "Anevia\x1A\x1A", 8)
5806  }
5807 
5808  return 0;
5809 }
5810 
5812 {
5813  uint32_t format = avio_rl32(pb);
5814  MOVStreamContext *sc;
5815  enum AVCodecID id;
5816  AVStream *st;
5817 
5818  if (c->fc->nb_streams < 1)
5819  return 0;
5820  st = c->fc->streams[c->fc->nb_streams - 1];
5821  sc = st->priv_data;
5822 
5823  switch (sc->format)
5824  {
5825  case MKTAG('e','n','c','v'): // encrypted video
5826  case MKTAG('e','n','c','a'): // encrypted audio
5827  id = mov_codec_id(st, format);
5828  if (st->codecpar->codec_id != AV_CODEC_ID_NONE &&
5829  st->codecpar->codec_id != id) {
5830  av_log(c->fc, AV_LOG_WARNING,
5831  "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
5832  (char*)&format, st->codecpar->codec_id);
5833  break;
5834  }
5835 
5836  st->codecpar->codec_id = id;
5837  sc->format = format;
5838  break;
5839 
5840  default:
5841  if (format != sc->format) {
5842  av_log(c->fc, AV_LOG_WARNING,
5843  "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
5844  (char*)&format, (char*)&sc->format);
5845  }
5846  break;
5847  }
5848 
5849  return 0;
5850 }
5851 
5852 /**
5853  * Gets the current encryption info and associated current stream context. If
5854  * we are parsing a track fragment, this will return the specific encryption
5855  * info for this fragment; otherwise this will return the global encryption
5856  * info for the current stream.
5857  */
5859 {
5860  MOVFragmentStreamInfo *frag_stream_info;
5861  AVStream *st;
5862  int i;
5863 
5864  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
5865  if (frag_stream_info) {
5866  for (i = 0; i < c->fc->nb_streams; i++) {
5867  if (c->fc->streams[i]->id == frag_stream_info->id) {
5868  st = c->fc->streams[i];
5869  break;
5870  }
5871  }
5872  if (i == c->fc->nb_streams)
5873  return 0;
5874  *sc = st->priv_data;
5875 
5876  if (!frag_stream_info->encryption_index) {
5877  // If this stream isn't encrypted, don't create the index.
5878  if (!(*sc)->cenc.default_encrypted_sample)
5879  return 0;
5880  frag_stream_info->encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5881  if (!frag_stream_info->encryption_index)
5882  return AVERROR(ENOMEM);
5883  }
5884  *encryption_index = frag_stream_info->encryption_index;
5885  return 1;
5886  } else {
5887  // No current track fragment, using stream level encryption info.
5888 
5889  if (c->fc->nb_streams < 1)
5890  return 0;
5891  st = c->fc->streams[c->fc->nb_streams - 1];
5892  *sc = st->priv_data;
5893 
5894  if (!(*sc)->cenc.encryption_index) {
5895  // If this stream isn't encrypted, don't create the index.
5896  if (!(*sc)->cenc.default_encrypted_sample)
5897  return 0;
5898  (*sc)->cenc.encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5899  if (!(*sc)->cenc.encryption_index)
5900  return AVERROR(ENOMEM);
5901  }
5902 
5903  *encryption_index = (*sc)->cenc.encryption_index;
5904  return 1;
5905  }
5906 }
5907 
5909 {
5910  int i;
5911  unsigned int subsample_count;
5912  AVSubsampleEncryptionInfo *subsamples;
5913 
5914  if (!sc->cenc.default_encrypted_sample) {
5915  av_log(c->fc, AV_LOG_ERROR, "Missing schm or tenc\n");
5916  return AVERROR_INVALIDDATA;
5917  }
5918 
5920  if (!*sample)
5921  return AVERROR(ENOMEM);
5922 
5923  if (sc->cenc.per_sample_iv_size != 0) {
5924  if (avio_read(pb, (*sample)->iv, sc->cenc.per_sample_iv_size) != sc->cenc.per_sample_iv_size) {
5925  av_log(c->fc, AV_LOG_ERROR, "failed to read the initialization vector\n");
5926  av_encryption_info_free(*sample);
5927  *sample = NULL;
5928  return AVERROR_INVALIDDATA;
5929  }
5930  }
5931 
5932  if (use_subsamples) {
5933  subsample_count = avio_rb16(pb);
5934  av_free((*sample)->subsamples);
5935  (*sample)->subsamples = av_mallocz_array(subsample_count, sizeof(*subsamples));
5936  if (!(*sample)->subsamples) {
5937  av_encryption_info_free(*sample);
5938  *sample = NULL;
5939  return AVERROR(ENOMEM);
5940  }
5941 
5942  for (i = 0; i < subsample_count && !pb->eof_reached; i++) {
5943  (*sample)->subsamples[i].bytes_of_clear_data = avio_rb16(pb);
5944  (*sample)->subsamples[i].bytes_of_protected_data = avio_rb32(pb);
5945  }
5946 
5947  if (pb->eof_reached) {
5948  av_log(c->fc, AV_LOG_ERROR, "hit EOF while reading sub-sample encryption info\n");
5949  av_encryption_info_free(*sample);
5950  *sample = NULL;
5951  return AVERROR_INVALIDDATA;
5952  }
5953  (*sample)->subsample_count = subsample_count;
5954  }
5955 
5956  return 0;
5957 }
5958 
5960 {
5961  AVEncryptionInfo **encrypted_samples;
5962  MOVEncryptionIndex *encryption_index;
5963  MOVStreamContext *sc;
5964  int use_subsamples, ret;
5965  unsigned int sample_count, i, alloc_size = 0;
5966 
5967  ret = get_current_encryption_info(c, &encryption_index, &sc);
5968  if (ret != 1)
5969  return ret;
5970 
5971  if (encryption_index->nb_encrypted_samples) {
5972  // This can happen if we have both saio/saiz and senc atoms.
5973  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in senc\n");
5974  return 0;
5975  }
5976 
5977  avio_r8(pb); /* version */
5978  use_subsamples = avio_rb24(pb) & 0x02; /* flags */
5979 
5980  sample_count = avio_rb32(pb);
5981  if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
5982  return AVERROR(ENOMEM);
5983 
5984  for (i = 0; i < sample_count; i++) {
5985  unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
5986  encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
5987  min_samples * sizeof(*encrypted_samples));
5988  if (encrypted_samples) {
5989  encryption_index->encrypted_samples = encrypted_samples;
5990 
5992  c, pb, sc, &encryption_index->encrypted_samples[i], use_subsamples);
5993  } else {
5994  ret = AVERROR(ENOMEM);
5995  }
5996  if (pb->eof_reached) {
5997  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading senc\n");
5998  ret = AVERROR_INVALIDDATA;
5999  }
6000 
6001  if (ret < 0) {
6002  for (; i > 0; i--)
6003  av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6004  av_freep(&encryption_index->encrypted_samples);
6005  return ret;
6006  }
6007  }
6008  encryption_index->nb_encrypted_samples = sample_count;
6009 
6010  return 0;
6011 }
6012 
6014 {
6015  AVEncryptionInfo **sample, **encrypted_samples;
6016  int64_t prev_pos;
6017  size_t sample_count, sample_info_size, i;
6018  int ret = 0;
6019  unsigned int alloc_size = 0;
6020 
6021  if (encryption_index->nb_encrypted_samples)
6022  return 0;
6023  sample_count = encryption_index->auxiliary_info_sample_count;
6024  if (encryption_index->auxiliary_offsets_count != 1) {
6025  av_log(c->fc, AV_LOG_ERROR, "Multiple auxiliary info chunks are not supported\n");
6026  return AVERROR_PATCHWELCOME;
6027  }
6028  if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
6029  return AVERROR(ENOMEM);
6030 
6031  prev_pos = avio_tell(pb);
6032  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
6033  avio_seek(pb, encryption_index->auxiliary_offsets[0], SEEK_SET) != encryption_index->auxiliary_offsets[0]) {
6034  av_log(c->fc, AV_LOG_INFO, "Failed to seek for auxiliary info, will only parse senc atoms for encryption info\n");
6035  goto finish;
6036  }
6037 
6038  for (i = 0; i < sample_count && !pb->eof_reached; i++) {
6039  unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
6040  encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
6041  min_samples * sizeof(*encrypted_samples));
6042  if (!encrypted_samples) {
6043  ret = AVERROR(ENOMEM);
6044  goto finish;
6045  }
6046  encryption_index->encrypted_samples = encrypted_samples;
6047 
6048  sample = &encryption_index->encrypted_samples[i];
6049  sample_info_size = encryption_index->auxiliary_info_default_size
6050  ? encryption_index->auxiliary_info_default_size
6051  : encryption_index->auxiliary_info_sizes[i];
6052 
6053  ret = mov_read_sample_encryption_info(c, pb, sc, sample, sample_info_size > sc->cenc.per_sample_iv_size);
6054  if (ret < 0)
6055  goto finish;
6056  }
6057  if (pb->eof_reached) {
6058  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading auxiliary info\n");
6059  ret = AVERROR_INVALIDDATA;
6060  } else {
6061  encryption_index->nb_encrypted_samples = sample_count;
6062  }
6063 
6064 finish:
6065  avio_seek(pb, prev_pos, SEEK_SET);
6066  if (ret < 0) {
6067  for (; i > 0; i--) {
6068  av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6069  }
6070  av_freep(&encryption_index->encrypted_samples);
6071  }
6072  return ret;
6073 }
6074 
6075 /**
6076  * Tries to read the given number of bytes from the stream and puts it in a
6077  * newly allocated buffer. This reads in small chunks to avoid allocating large
6078  * memory if the file contains an invalid/malicious size value.
6079  */
6080 static int mov_try_read_block(AVIOContext *pb, size_t size, uint8_t **data)
6081 {
6082  const unsigned int block_size = 1024 * 1024;
6083  uint8_t *buffer = NULL;
6084  unsigned int alloc_size = 0, offset = 0;
6085  while (offset < size) {
6086  unsigned int new_size =
6087  alloc_size >= INT_MAX - block_size ? INT_MAX : alloc_size + block_size;
6088  uint8_t *new_buffer = av_fast_realloc(buffer, &alloc_size, new_size);
6089  unsigned int to_read = FFMIN(size, alloc_size) - offset;
6090  if (!new_buffer) {
6091  av_free(buffer);
6092  return AVERROR(ENOMEM);
6093  }
6094  buffer = new_buffer;
6095 
6096  if (avio_read(pb, buffer + offset, to_read) != to_read) {
6097  av_free(buffer);
6098  return AVERROR_INVALIDDATA;
6099  }
6100  offset += to_read;
6101  }
6102 
6103  *data = buffer;
6104  return 0;
6105 }
6106 
6108 {
6109  MOVEncryptionIndex *encryption_index;
6110  MOVStreamContext *sc;
6111  int ret;
6112  unsigned int sample_count, aux_info_type, aux_info_param;
6113 
6114  ret = get_current_encryption_info(c, &encryption_index, &sc);
6115  if (ret != 1)
6116  return ret;
6117 
6118  if (encryption_index->nb_encrypted_samples) {
6119  // This can happen if we have both saio/saiz and senc atoms.
6120  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saiz\n");
6121  return 0;
6122  }
6123 
6124  if (encryption_index->auxiliary_info_sample_count) {
6125  av_log(c->fc, AV_LOG_ERROR, "Duplicate saiz atom\n");
6126  return AVERROR_INVALIDDATA;
6127  }
6128 
6129  avio_r8(pb); /* version */
6130  if (avio_rb24(pb) & 0x01) { /* flags */
6131  aux_info_type = avio_rb32(pb);
6132  aux_info_param = avio_rb32(pb);
6133  if (sc->cenc.default_encrypted_sample) {
6134  if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6135  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type\n");
6136  return 0;
6137  }
6138  if (aux_info_param != 0) {
6139  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type_parameter\n");
6140  return 0;
6141  }
6142  } else {
6143  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6144  if ((aux_info_type == MKBETAG('c','e','n','c') ||
6145  aux_info_type == MKBETAG('c','e','n','s') ||
6146  aux_info_type == MKBETAG('c','b','c','1') ||
6147  aux_info_type == MKBETAG('c','b','c','s')) &&
6148  aux_info_param == 0) {
6149  av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saiz without schm/tenc\n");
6150  return AVERROR_INVALIDDATA;
6151  } else {
6152  return 0;
6153  }
6154  }
6155  } else if (!sc->cenc.default_encrypted_sample) {
6156  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6157  return 0;
6158  }
6159 
6160  encryption_index->auxiliary_info_default_size = avio_r8(pb);
6161  sample_count = avio_rb32(pb);
6162  encryption_index->auxiliary_info_sample_count = sample_count;
6163 
6164  if (encryption_index->auxiliary_info_default_size == 0) {
6165  ret = mov_try_read_block(pb, sample_count, &encryption_index->auxiliary_info_sizes);
6166  if (ret < 0) {
6167  av_log(c->fc, AV_LOG_ERROR, "Failed to read the auxiliary info\n");
6168  return ret;
6169  }
6170  }
6171 
6172  if (encryption_index->auxiliary_offsets_count) {
6173  return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6174  }
6175 
6176  return 0;
6177 }
6178 
6180 {
6181  uint64_t *auxiliary_offsets;
6182  MOVEncryptionIndex *encryption_index;
6183  MOVStreamContext *sc;
6184  int i, ret;
6185  unsigned int version, entry_count, aux_info_type, aux_info_param;
6186  unsigned int alloc_size = 0;
6187 
6188  ret = get_current_encryption_info(c, &encryption_index, &sc);
6189  if (ret != 1)
6190  return ret;
6191 
6192  if (encryption_index->nb_encrypted_samples) {
6193  // This can happen if we have both saio/saiz and senc atoms.
6194  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saio\n");
6195  return 0;
6196  }
6197 
6198  if (encryption_index->auxiliary_offsets_count) {
6199  av_log(c->fc, AV_LOG_ERROR, "Duplicate saio atom\n");
6200  return AVERROR_INVALIDDATA;
6201  }
6202 
6203  version = avio_r8(pb); /* version */
6204  if (avio_rb24(pb) & 0x01) { /* flags */
6205  aux_info_type = avio_rb32(pb);
6206  aux_info_param = avio_rb32(pb);
6207  if (sc->cenc.default_encrypted_sample) {
6208  if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6209  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type\n");
6210  return 0;
6211  }
6212  if (aux_info_param != 0) {
6213  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type_parameter\n");
6214  return 0;
6215  }
6216  } else {
6217  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6218  if ((aux_info_type == MKBETAG('c','e','n','c') ||
6219  aux_info_type == MKBETAG('c','e','n','s') ||
6220  aux_info_type == MKBETAG('c','b','c','1') ||
6221  aux_info_type == MKBETAG('c','b','c','s')) &&
6222  aux_info_param == 0) {
6223  av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saio without schm/tenc\n");
6224  return AVERROR_INVALIDDATA;
6225  } else {
6226  return 0;
6227  }
6228  }
6229  } else if (!sc->cenc.default_encrypted_sample) {
6230  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6231  return 0;
6232  }
6233 
6234  entry_count = avio_rb32(pb);
6235  if (entry_count >= INT_MAX / sizeof(*auxiliary_offsets))
6236  return AVERROR(ENOMEM);
6237 
6238  for (i = 0; i < entry_count && !pb->eof_reached; i++) {
6239  unsigned int min_offsets = FFMIN(FFMAX(i + 1, 1024), entry_count);
6240  auxiliary_offsets = av_fast_realloc(
6241  encryption_index->auxiliary_offsets, &alloc_size,
6242  min_offsets * sizeof(*auxiliary_offsets));
6243  if (!auxiliary_offsets) {
6244  av_freep(&encryption_index->auxiliary_offsets);
6245  return AVERROR(ENOMEM);
6246  }
6247  encryption_index->auxiliary_offsets = auxiliary_offsets;
6248 
6249  if (version == 0) {
6250  encryption_index->auxiliary_offsets[i] = avio_rb32(pb);
6251  } else {
6252  encryption_index->auxiliary_offsets[i] = avio_rb64(pb);
6253  }
6254  if (c->frag_index.current >= 0) {
6255  encryption_index->auxiliary_offsets[i] += c->fragment.base_data_offset;
6256  }
6257  }
6258 
6259  if (pb->eof_reached) {
6260  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading saio\n");
6261  av_freep(&encryption_index->auxiliary_offsets);
6262  return AVERROR_INVALIDDATA;
6263  }
6264 
6265  encryption_index->auxiliary_offsets_count = entry_count;
6266 
6267  if (encryption_index->auxiliary_info_sample_count) {
6268  return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6269  }
6270 
6271  return 0;
6272 }
6273 
6275 {
6276  AVEncryptionInitInfo *info, *old_init_info;
6277  uint8_t **key_ids;
6278  AVStream *st;
6279  uint8_t *side_data, *extra_data, *old_side_data;
6280  size_t side_data_size;
6281  int ret = 0, old_side_data_size;
6282  unsigned int version, kid_count, extra_data_size, alloc_size = 0;
6283 
6284  if (c->fc->nb_streams < 1)
6285  return 0;
6286  st = c->fc->streams[c->fc->nb_streams-1];
6287 
6288  version = avio_r8(pb); /* version */
6289  avio_rb24(pb); /* flags */
6290 
6291  info = av_encryption_init_info_alloc(/* system_id_size */ 16, /* num_key_ids */ 0,
6292  /* key_id_size */ 16, /* data_size */ 0);
6293  if (!info)
6294  return AVERROR(ENOMEM);
6295 
6296  if (avio_read(pb, info->system_id, 16) != 16) {
6297  av_log(c->fc, AV_LOG_ERROR, "Failed to read the system id\n");
6298  ret = AVERROR_INVALIDDATA;
6299  goto finish;
6300  }
6301 
6302  if (version > 0) {
6303  kid_count = avio_rb32(pb);
6304  if (kid_count >= INT_MAX / sizeof(*key_ids))
6305  return AVERROR(ENOMEM);
6306 
6307  for (unsigned int i = 0; i < kid_count && !pb->eof_reached; i++) {
6308  unsigned int min_kid_count = FFMIN(FFMAX(i + 1, 1024), kid_count);
6309  key_ids = av_fast_realloc(info->key_ids, &alloc_size,
6310  min_kid_count * sizeof(*key_ids));
6311  if (!key_ids) {
6312  ret = AVERROR(ENOMEM);
6313  goto finish;
6314  }
6315  info->key_ids = key_ids;
6316 
6317  info->key_ids[i] = av_mallocz(16);
6318  if (!info->key_ids[i]) {
6319  ret = AVERROR(ENOMEM);
6320  goto finish;
6321  }
6322  info->num_key_ids = i + 1;
6323 
6324  if (avio_read(pb, info->key_ids[i], 16) != 16) {
6325  av_log(c->fc, AV_LOG_ERROR, "Failed to read the key id\n");
6326  ret = AVERROR_INVALIDDATA;
6327  goto finish;
6328  }
6329  }
6330 
6331  if (pb->eof_reached) {
6332  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading pssh\n");
6333  ret = AVERROR_INVALIDDATA;
6334  goto finish;
6335  }
6336  }
6337 
6338  extra_data_size = avio_rb32(pb);
6339  ret = mov_try_read_block(pb, extra_data_size, &extra_data);
6340  if (ret < 0)
6341  goto finish;
6342 
6343  av_freep(&info->data); // malloc(0) may still allocate something.
6344  info->data = extra_data;
6345  info->data_size = extra_data_size;
6346 
6347  // If there is existing initialization data, append to the list.
6348  old_side_data = av_stream_get_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO, &old_side_data_size);
6349  if (old_side_data) {
6350  old_init_info = av_encryption_init_info_get_side_data(old_side_data, old_side_data_size);
6351  if (old_init_info) {
6352  // Append to the end of the list.
6353  for (AVEncryptionInitInfo *cur = old_init_info;; cur = cur->next) {
6354  if (!cur->next) {
6355  cur->next = info;
6356  break;
6357  }
6358  }
6359  info = old_init_info;
6360  } else {
6361  // Assume existing side-data will be valid, so the only error we could get is OOM.
6362  ret = AVERROR(ENOMEM);
6363  goto finish;
6364  }
6365  }
6366 
6367  side_data = av_encryption_init_info_add_side_data(info, &side_data_size);
6368  if (!side_data) {
6369  ret = AVERROR(ENOMEM);
6370  goto finish;
6371  }
6373  side_data, side_data_size);
6374  if (ret < 0)
6375  av_free(side_data);
6376 
6377 finish:
6379  return ret;
6380 }
6381 
6383 {
6384  AVStream *st;
6385  MOVStreamContext *sc;
6386 
6387  if (c->fc->nb_streams < 1)
6388  return 0;
6389  st = c->fc->streams[c->fc->nb_streams-1];
6390  sc = st->priv_data;
6391 
6392  if (sc->pseudo_stream_id != 0) {
6393  av_log(c->fc, AV_LOG_ERROR, "schm boxes are only supported in first sample descriptor\n");
6394  return AVERROR_PATCHWELCOME;
6395  }
6396 
6397  if (atom.size < 8)
6398  return AVERROR_INVALIDDATA;
6399 
6400  avio_rb32(pb); /* version and flags */
6401 
6402  if (!sc->cenc.default_encrypted_sample) {
6404  if (!sc->cenc.default_encrypted_sample) {
6405  return AVERROR(ENOMEM);
6406  }
6407  }
6408 
6410  return 0;
6411 }
6412 
6414 {
6415  AVStream *st;
6416  MOVStreamContext *sc;
6417  unsigned int version, pattern, is_protected, iv_size;
6418 
6419  if (c->fc->nb_streams < 1)
6420  return 0;
6421  st = c->fc->streams[c->fc->nb_streams-1];
6422  sc = st->priv_data;
6423 
6424  if (sc->pseudo_stream_id != 0) {
6425  av_log(c->fc, AV_LOG_ERROR, "tenc atom are only supported in first sample descriptor\n");
6426  return AVERROR_PATCHWELCOME;
6427  }
6428 
6429  if (!sc->cenc.default_encrypted_sample) {
6431  if (!sc->cenc.default_encrypted_sample) {
6432  return AVERROR(ENOMEM);
6433  }
6434  }
6435 
6436  if (atom.size < 20)
6437  return AVERROR_INVALIDDATA;
6438 
6439  version = avio_r8(pb); /* version */
6440  avio_rb24(pb); /* flags */
6441 
6442  avio_r8(pb); /* reserved */
6443  pattern = avio_r8(pb);
6444 
6445  if (version > 0) {
6446  sc->cenc.default_encrypted_sample->crypt_byte_block = pattern >> 4;
6447  sc->cenc.default_encrypted_sample->skip_byte_block = pattern & 0xf;
6448  }
6449 
6450  is_protected = avio_r8(pb);
6451  if (is_protected && !sc->cenc.encryption_index) {
6452  // The whole stream should be by-default encrypted.
6454  if (!sc->cenc.encryption_index)
6455  return AVERROR(ENOMEM);
6456  }
6457  sc->cenc.per_sample_iv_size = avio_r8(pb);
6458  if (sc->cenc.per_sample_iv_size != 0 && sc->cenc.per_sample_iv_size != 8 &&
6459  sc->cenc.per_sample_iv_size != 16) {
6460  av_log(c->fc, AV_LOG_ERROR, "invalid per-sample IV size value\n");
6461  return AVERROR_INVALIDDATA;
6462  }
6463  if (avio_read(pb, sc->cenc.default_encrypted_sample->key_id, 16) != 16) {
6464  av_log(c->fc, AV_LOG_ERROR, "failed to read the default key ID\n");
6465  return AVERROR_INVALIDDATA;
6466  }
6467 
6468  if (is_protected && !sc->cenc.per_sample_iv_size) {
6469  iv_size = avio_r8(pb);
6470  if (iv_size != 8 && iv_size != 16) {
6471  av_log(c->fc, AV_LOG_ERROR, "invalid default_constant_IV_size in tenc atom\n");
6472  return AVERROR_INVALIDDATA;
6473  }
6474 
6475  if (avio_read(pb, sc->cenc.default_encrypted_sample->iv, iv_size) != iv_size) {
6476  av_log(c->fc, AV_LOG_ERROR, "failed to read the default IV\n");
6477  return AVERROR_INVALIDDATA;
6478  }
6479  }
6480 
6481  return 0;
6482 }
6483 
6485 {
6486  AVStream *st;
6487  int last, type, size, ret;
6488  uint8_t buf[4];
6489 
6490  if (c->fc->nb_streams < 1)
6491  return 0;
6492  st = c->fc->streams[c->fc->nb_streams-1];
6493 
6494  if ((uint64_t)atom.size > (1<<30) || atom.size < 42)
6495  return AVERROR_INVALIDDATA;
6496 
6497  /* Check FlacSpecificBox version. */
6498  if (avio_r8(pb) != 0)
6499  return AVERROR_INVALIDDATA;
6500 
6501  avio_rb24(pb); /* Flags */
6502 
6503  avio_read(pb, buf, sizeof(buf));
6504  flac_parse_block_header(buf, &last, &type, &size);
6505 
6506  if (type != FLAC_METADATA_TYPE_STREAMINFO || size != FLAC_STREAMINFO_SIZE) {
6507  av_log(c->fc, AV_LOG_ERROR, "STREAMINFO must be first FLACMetadataBlock\n");
6508  return AVERROR_INVALIDDATA;
6509  }
6510 
6511  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
6512  if (ret < 0)
6513  return ret;
6514 
6515  if (!last)
6516  av_log(c->fc, AV_LOG_WARNING, "non-STREAMINFO FLACMetadataBlock(s) ignored\n");
6517 
6518  return 0;
6519 }
6520 
6522 {
6523  int i, ret;
6524 
6525  if (sample->scheme != MKBETAG('c','e','n','c') || sample->crypt_byte_block != 0 || sample->skip_byte_block != 0) {
6526  av_log(c->fc, AV_LOG_ERROR, "Only the 'cenc' encryption scheme is supported\n");
6527  return AVERROR_PATCHWELCOME;
6528  }
6529 
6530  if (!sc->cenc.aes_ctr) {
6531  /* initialize the cipher */
6532  sc->cenc.aes_ctr = av_aes_ctr_alloc();
6533  if (!sc->cenc.aes_ctr) {
6534  return AVERROR(ENOMEM);
6535  }
6536 
6537  ret = av_aes_ctr_init(sc->cenc.aes_ctr, c->decryption_key);
6538  if (ret < 0) {
6539  return ret;
6540  }
6541  }
6542 
6543  av_aes_ctr_set_full_iv(sc->cenc.aes_ctr, sample->iv);
6544 
6545  if (!sample->subsample_count)
6546  {
6547  /* decrypt the whole packet */
6548  av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, size);
6549  return 0;
6550  }
6551 
6552  for (i = 0; i < sample->subsample_count; i++)
6553  {
6554  if (sample->subsamples[i].bytes_of_clear_data + sample->subsamples[i].bytes_of_protected_data > size) {
6555  av_log(c->fc, AV_LOG_ERROR, "subsample size exceeds the packet size left\n");
6556  return AVERROR_INVALIDDATA;
6557  }
6558 
6559  /* skip the clear bytes */
6560  input += sample->subsamples[i].bytes_of_clear_data;
6561  size -= sample->subsamples[i].bytes_of_clear_data;
6562 
6563  /* decrypt the encrypted bytes */
6564  av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, sample->subsamples[i].bytes_of_protected_data);
6565  input += sample->subsamples[i].bytes_of_protected_data;
6566  size -= sample->subsamples[i].bytes_of_protected_data;
6567  }
6568 
6569  if (size > 0) {
6570  av_log(c->fc, AV_LOG_ERROR, "leftover packet bytes after subsample processing\n");
6571  return AVERROR_INVALIDDATA;
6572  }
6573 
6574  return 0;
6575 }
6576 
6577 static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
6578 {
6579  MOVFragmentStreamInfo *frag_stream_info;
6580  MOVEncryptionIndex *encryption_index;
6581  AVEncryptionInfo *encrypted_sample;
6582  int encrypted_index, ret;
6583 
6584  frag_stream_info = get_frag_stream_info(&mov->frag_index, mov->frag_index.current, st->id);
6585  encrypted_index = current_index;
6586  encryption_index = NULL;
6587  if (frag_stream_info) {
6588  // Note this only supports encryption info in the first sample descriptor.
6589  if (mov->fragment.stsd_id == 1) {
6590  if (frag_stream_info->encryption_index) {
6591  encrypted_index = current_index - frag_stream_info->index_entry;
6592  encryption_index = frag_stream_info->encryption_index;
6593  } else {
6594  encryption_index = sc->cenc.encryption_index;
6595  }
6596  }
6597  } else {
6598  encryption_index = sc->cenc.encryption_index;
6599  }
6600 
6601  if (encryption_index) {
6602  if (encryption_index->auxiliary_info_sample_count &&
6603  !encryption_index->nb_encrypted_samples) {
6604  av_log(mov->fc, AV_LOG_ERROR, "saiz atom found without saio\n");
6605  return AVERROR_INVALIDDATA;
6606  }
6607  if (encryption_index->auxiliary_offsets_count &&
6608  !encryption_index->nb_encrypted_samples) {
6609  av_log(mov->fc, AV_LOG_ERROR, "saio atom found without saiz\n");
6610  return AVERROR_INVALIDDATA;
6611  }
6612 
6613  if (!encryption_index->nb_encrypted_samples) {
6614  // Full-sample encryption with default settings.
6615  encrypted_sample = sc->cenc.default_encrypted_sample;
6616  } else if (encrypted_index >= 0 && encrypted_index < encryption_index->nb_encrypted_samples) {
6617  // Per-sample setting override.
6618  encrypted_sample = encryption_index->encrypted_samples[encrypted_index];
6619  } else {
6620  av_log(mov->fc, AV_LOG_ERROR, "Incorrect number of samples in encryption info\n");
6621  return AVERROR_INVALIDDATA;
6622  }
6623 
6624  if (mov->decryption_key) {
6625  return cenc_decrypt(mov, sc, encrypted_sample, pkt->data, pkt->size);
6626  } else {
6627  size_t size;
6628  uint8_t *side_data = av_encryption_info_add_side_data(encrypted_sample, &size);
6629  if (!side_data)
6630  return AVERROR(ENOMEM);
6631  ret = av_packet_add_side_data(pkt, AV_PKT_DATA_ENCRYPTION_INFO, side_data, size);
6632  if (ret < 0)
6633  av_free(side_data);
6634  return ret;
6635  }
6636  }
6637 
6638  return 0;
6639 }
6640 
6642 {
6643  const int OPUS_SEEK_PREROLL_MS = 80;
6644  AVStream *st;
6645  size_t size;
6646  uint16_t pre_skip;
6647 
6648  if (c->fc->nb_streams < 1)
6649  return 0;
6650  st = c->fc->streams[c->fc->nb_streams-1];
6651 
6652  if ((uint64_t)atom.size > (1<<30) || atom.size < 11)
6653  return AVERROR_INVALIDDATA;
6654 
6655  /* Check OpusSpecificBox version. */
6656  if (avio_r8(pb) != 0) {
6657  av_log(c->fc, AV_LOG_ERROR, "unsupported OpusSpecificBox version\n");
6658  return AVERROR_INVALIDDATA;
6659  }
6660 
6661  /* OpusSpecificBox size plus magic for Ogg OpusHead header. */
6662  size = atom.size + 8;
6663 
6664  if (ff_alloc_extradata(st->codecpar, size))
6665  return AVERROR(ENOMEM);
6666 
6667  AV_WL32(st->codecpar->extradata, MKTAG('O','p','u','s'));
6668  AV_WL32(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
6669  AV_WB8(st->codecpar->extradata + 8, 1); /* OpusHead version */
6670  avio_read(pb, st->codecpar->extradata + 9, size - 9);
6671 
6672  /* OpusSpecificBox is stored in big-endian, but OpusHead is
6673  little-endian; aside from the preceeding magic and version they're
6674  otherwise currently identical. Data after output gain at offset 16
6675  doesn't need to be bytewapped. */
6676  pre_skip = AV_RB16(st->codecpar->extradata + 10);
6677  AV_WL16(st->codecpar->extradata + 10, pre_skip);
6678  AV_WL32(st->codecpar->extradata + 12, AV_RB32(st->codecpar->extradata + 12));
6679  AV_WL16(st->codecpar->extradata + 16, AV_RB16(st->codecpar->extradata + 16));
6680 
6681  st->codecpar->initial_padding = pre_skip;
6682  st->codecpar->seek_preroll = av_rescale_q(OPUS_SEEK_PREROLL_MS,
6683  (AVRational){1, 1000},
6684  (AVRational){1, 48000});
6685 
6686  return 0;
6687 }
6688 
6690 { MKTAG('A','C','L','R'), mov_read_aclr },
6691 { MKTAG('A','P','R','G'), mov_read_avid },
6692 { MKTAG('A','A','L','P'), mov_read_avid },
6693 { MKTAG('A','R','E','S'), mov_read_ares },
6694 { MKTAG('a','v','s','s'), mov_read_avss },
6695 { MKTAG('a','v','1','C'), mov_read_av1c },
6696 { MKTAG('c','h','p','l'), mov_read_chpl },
6697 { MKTAG('c','o','6','4'), mov_read_stco },
6698 { MKTAG('c','o','l','r'), mov_read_colr },
6699 { MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
6700 { MKTAG('d','i','n','f'), mov_read_default },
6701 { MKTAG('D','p','x','E'), mov_read_dpxe },
6702 { MKTAG('d','r','e','f'), mov_read_dref },
6703 { MKTAG('e','d','t','s'), mov_read_default },
6704 { MKTAG('e','l','s','t'), mov_read_elst },
6705 { MKTAG('e','n','d','a'), mov_read_enda },
6706 { MKTAG('f','i','e','l'), mov_read_fiel },
6707 { MKTAG('a','d','r','m'), mov_read_adrm },
6708 { MKTAG('f','t','y','p'), mov_read_ftyp },
6709 { MKTAG('g','l','b','l'), mov_read_glbl },
6710 { MKTAG('h','d','l','r'), mov_read_hdlr },
6711 { MKTAG('i','l','s','t'), mov_read_ilst },
6712 { MKTAG('j','p','2','h'), mov_read_jp2h },
6713 { MKTAG('m','d','a','t'), mov_read_mdat },
6714 { MKTAG('m','d','h','d'), mov_read_mdhd },
6715 { MKTAG('m','d','i','a'), mov_read_default },
6716 { MKTAG('m','e','t','a'), mov_read_meta },
6717 { MKTAG('m','i','n','f'), mov_read_default },
6718 { MKTAG('m','o','o','f'), mov_read_moof },
6719 { MKTAG('m','o','o','v'), mov_read_moov },
6720 { MKTAG('m','v','e','x'), mov_read_default },
6721 { MKTAG('m','v','h','d'), mov_read_mvhd },
6722 { MKTAG('S','M','I',' '), mov_read_svq3 },
6723 { MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */
6724 { MKTAG('a','v','c','C'), mov_read_glbl },
6725 { MKTAG('p','a','s','p'), mov_read_pasp },
6726 { MKTAG('s','i','d','x'), mov_read_sidx },
6727 { MKTAG('s','t','b','l'), mov_read_default },
6728 { MKTAG('s','t','c','o'), mov_read_stco },
6729 { MKTAG('s','t','p','s'), mov_read_stps },
6730 { MKTAG('s','t','r','f'), mov_read_strf },
6731 { MKTAG('s','t','s','c'), mov_read_stsc },
6732 { MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
6733 { MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
6734 { MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
6735 { MKTAG('s','t','t','s'), mov_read_stts },
6736 { MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
6737 { MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
6738 { MKTAG('t','f','d','t'), mov_read_tfdt },
6739 { MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
6740 { MKTAG('t','r','a','k'), mov_read_trak },
6741 { MKTAG('t','r','a','f'), mov_read_default },
6742 { MKTAG('t','r','e','f'), mov_read_default },
6743 { MKTAG('t','m','c','d'), mov_read_tmcd },
6744 { MKTAG('c','h','a','p'), mov_read_chap },
6745 { MKTAG('t','r','e','x'), mov_read_trex },
6746 { MKTAG('t','r','u','n'), mov_read_trun },
6747 { MKTAG('u','d','t','a'), mov_read_default },
6748 { MKTAG('w','a','v','e'), mov_read_wave },
6749 { MKTAG('e','s','d','s'), mov_read_esds },
6750 { MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */
6751 { MKTAG('d','e','c','3'), mov_read_dec3 }, /* EAC-3 info */
6752 { MKTAG('d','d','t','s'), mov_read_ddts }, /* DTS audio descriptor */
6753 { MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
6754 { MKTAG('w','f','e','x'), mov_read_wfex },
6755 { MKTAG('c','m','o','v'), mov_read_cmov },
6756 { MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */
6757 { MKTAG('d','v','c','1'), mov_read_dvc1 },
6758 { MKTAG('s','b','g','p'), mov_read_sbgp },
6759 { MKTAG('h','v','c','C'), mov_read_glbl },
6760 { MKTAG('u','u','i','d'), mov_read_uuid },
6761 { MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },
6762 { MKTAG('f','r','e','e'), mov_read_free },
6763 { MKTAG('-','-','-','-'), mov_read_custom },
6764 { MKTAG('s','i','n','f'), mov_read_default },
6765 { MKTAG('f','r','m','a'), mov_read_frma },
6766 { MKTAG('s','e','n','c'), mov_read_senc },
6767 { MKTAG('s','a','i','z'), mov_read_saiz },
6768 { MKTAG('s','a','i','o'), mov_read_saio },
6769 { MKTAG('p','s','s','h'), mov_read_pssh },
6770 { MKTAG('s','c','h','m'), mov_read_schm },
6771 { MKTAG('s','c','h','i'), mov_read_default },
6772 { MKTAG('t','e','n','c'), mov_read_tenc },
6773 { MKTAG('d','f','L','a'), mov_read_dfla },
6774 { MKTAG('s','t','3','d'), mov_read_st3d }, /* stereoscopic 3D video box */
6775 { MKTAG('s','v','3','d'), mov_read_sv3d }, /* spherical video box */
6776 { MKTAG('d','O','p','s'), mov_read_dops },
6777 { MKTAG('S','m','D','m'), mov_read_smdm },
6778 { MKTAG('C','o','L','L'), mov_read_coll },
6779 { MKTAG('v','p','c','C'), mov_read_vpcc },
6780 { MKTAG('m','d','c','v'), mov_read_mdcv },
6781 { MKTAG('c','l','l','i'), mov_read_clli },
6782 { 0, NULL }
6783 };
6784 
6786 {
6787  int64_t total_size = 0;
6788  MOVAtom a;
6789  int i;
6790 
6791  if (c->atom_depth > 10) {
6792  av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");
6793  return AVERROR_INVALIDDATA;
6794  }
6795  c->atom_depth ++;
6796 
6797  if (atom.size < 0)
6798  atom.size = INT64_MAX;
6799  while (total_size <= atom.size - 8 && !avio_feof(pb)) {
6801  a.size = atom.size;
6802  a.type=0;
6803  if (atom.size >= 8) {
6804  a.size = avio_rb32(pb);
6805  a.type = avio_rl32(pb);
6806  if (a.type == MKTAG('f','r','e','e') &&
6807  a.size >= 8 &&
6809  c->moov_retry) {
6810  uint8_t buf[8];
6811  uint32_t *type = (uint32_t *)buf + 1;
6812  if (avio_read(pb, buf, 8) != 8)
6813  return AVERROR_INVALIDDATA;
6814  avio_seek(pb, -8, SEEK_CUR);
6815  if (*type == MKTAG('m','v','h','d') ||
6816  *type == MKTAG('c','m','o','v')) {
6817  av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free atom.\n");
6818  a.type = MKTAG('m','o','o','v');
6819  }
6820  }
6821  if (atom.type != MKTAG('r','o','o','t') &&
6822  atom.type != MKTAG('m','o','o','v'))
6823  {
6824  if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))
6825  {
6826  av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
6827  avio_skip(pb, -8);
6828  c->atom_depth --;
6829  return 0;
6830  }
6831  }
6832  total_size += 8;
6833  if (a.size == 1 && total_size + 8 <= atom.size) { /* 64 bit extended size */
6834  a.size = avio_rb64(pb) - 8;
6835  total_size += 8;
6836  }
6837  }
6838  av_log(c->fc, AV_LOG_TRACE, "type:'%s' parent:'%s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
6839  av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
6840  if (a.size == 0) {
6841  a.size = atom.size - total_size + 8;
6842  }
6843  a.size -= 8;
6844  if (a.size < 0)
6845  break;
6846  a.size = FFMIN(a.size, atom.size - total_size);
6847 
6848  for (i = 0; mov_default_parse_table[i].type; i++)
6849  if (mov_default_parse_table[i].type == a.type) {
6850  parse = mov_default_parse_table[i].parse;
6851  break;
6852  }
6853 
6854  // container is user data
6855  if (!parse && (atom.type == MKTAG('u','d','t','a') ||
6856  atom.type == MKTAG('i','l','s','t')))
6858 
6859  // Supports parsing the QuickTime Metadata Keys.
6860  // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
6861  if (!parse && c->found_hdlr_mdta &&
6862  atom.type == MKTAG('m','e','t','a') &&
6863  a.type == MKTAG('k','e','y','s')) {
6864  parse = mov_read_keys;
6865  }
6866 
6867  if (!parse) { /* skip leaf atoms data */
6868  avio_skip(pb, a.size);
6869  } else {
6870  int64_t start_pos = avio_tell(pb);
6871  int64_t left;
6872  int err = parse(c, pb, a);
6873  if (err < 0) {
6874  c->atom_depth --;
6875  return err;
6876  }
6877  if (c->found_moov && c->found_mdat &&
6879  start_pos + a.size == avio_size(pb))) {
6881  c->next_root_atom = start_pos + a.size;
6882  c->atom_depth --;
6883  return 0;
6884  }
6885  left = a.size - avio_tell(pb) + start_pos;
6886  if (left > 0) /* skip garbage at atom end */
6887  avio_skip(pb, left);
6888  else if (left < 0) {
6889  av_log(c->fc, AV_LOG_WARNING,
6890  "overread end of atom '%.4s' by %"PRId64" bytes\n",
6891  (char*)&a.type, -left);
6892  avio_seek(pb, left, SEEK_CUR);
6893  }
6894  }
6895 
6896  total_size += a.size;
6897  }
6898 
6899  if (total_size < atom.size && atom.size < 0x7ffff)
6900  avio_skip(pb, atom.size - total_size);
6901 
6902  c->atom_depth --;
6903  return 0;
6904 }
6905 
6906 static int mov_probe(const AVProbeData *p)
6907 {
6908  int64_t offset;
6909  uint32_t tag;
6910  int score = 0;
6911  int moov_offset = -1;
6912 
6913  /* check file header */
6914  offset = 0;
6915  for (;;) {
6916  /* ignore invalid offset */
6917  if ((offset + 8) > (unsigned int)p->buf_size)
6918  break;
6919  tag = AV_RL32(p->buf + offset + 4);
6920  switch(tag) {
6921  /* check for obvious tags */
6922  case MKTAG('m','o','o','v'):
6923  moov_offset = offset + 4;
6924  case MKTAG('m','d','a','t'):
6925  case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
6926  case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
6927  case MKTAG('f','t','y','p'):
6928  if (AV_RB32(p->buf+offset) < 8 &&
6929  (AV_RB32(p->buf+offset) != 1 ||
6930  offset + 12 > (unsigned int)p->buf_size ||
6931  AV_RB64(p->buf+offset + 8) == 0)) {
6932  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
6933  } else if (tag == MKTAG('f','t','y','p') &&
6934  ( AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')
6935  || AV_RL32(p->buf + offset + 8) == MKTAG('j','p','x',' ')
6936  )) {
6937  score = FFMAX(score, 5);
6938  } else {
6939  score = AVPROBE_SCORE_MAX;
6940  }
6941  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6942  break;
6943  /* those are more common words, so rate then a bit less */
6944  case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
6945  case MKTAG('w','i','d','e'):
6946  case MKTAG('f','r','e','e'):
6947  case MKTAG('j','u','n','k'):
6948  case MKTAG('p','i','c','t'):
6949  score = FFMAX(score, AVPROBE_SCORE_MAX - 5);
6950  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6951  break;
6952  case MKTAG(0x82,0x82,0x7f,0x7d):
6953  case MKTAG('s','k','i','p'):
6954  case MKTAG('u','u','i','d'):
6955  case MKTAG('p','r','f','l'):
6956  /* if we only find those cause probedata is too small at least rate them */
6957  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
6958  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6959  break;
6960  default:
6961  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6962  }
6963  }
6964  if(score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
6965  /* moov atom in the header - we should make sure that this is not a
6966  * MOV-packed MPEG-PS */
6967  offset = moov_offset;
6968 
6969  while(offset < (p->buf_size - 16)){ /* Sufficient space */
6970  /* We found an actual hdlr atom */
6971  if(AV_RL32(p->buf + offset ) == MKTAG('h','d','l','r') &&
6972  AV_RL32(p->buf + offset + 8) == MKTAG('m','h','l','r') &&
6973  AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
6974  av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
6975  /* We found a media handler reference atom describing an
6976  * MPEG-PS-in-MOV, return a
6977  * low score to force expanding the probe window until
6978  * mpegps_probe finds what it needs */
6979  return 5;
6980  }else
6981  /* Keep looking */
6982  offset+=2;
6983  }
6984  }
6985 
6986  return score;
6987 }
6988 
6989 // must be done after parsing all trak because there's no order requirement
6991 {
6992  MOVContext *mov = s->priv_data;
6993  AVStream *st;
6994  MOVStreamContext *sc;
6995  int64_t cur_pos;
6996  int i, j;
6997  int chapter_track;
6998 
6999  for (j = 0; j < mov->nb_chapter_tracks; j++) {
7000  chapter_track = mov->chapter_tracks[j];
7001  st = NULL;
7002  for (i = 0; i < s->nb_streams; i++)
7003  if (s->streams[i]->id == chapter_track) {
7004  st = s->streams[i];
7005  break;
7006  }
7007  if (!st) {
7008  av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
7009  continue;
7010  }
7011 
7012  sc = st->priv_data;
7013  cur_pos = avio_tell(sc->pb);
7014 
7015  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
7017  if (st->nb_index_entries) {
7018  // Retrieve the first frame, if possible
7019  AVPacket pkt;
7020  AVIndexEntry *sample = &st->index_entries[0];
7021  if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7022  av_log(s, AV_LOG_ERROR, "Failed to retrieve first frame\n");
7023  goto finish;
7024  }
7025 
7026  if (av_get_packet(sc->pb, &pkt, sample->size) < 0)
7027  goto finish;
7028 
7029  st->attached_pic = pkt;
7030  st->attached_pic.stream_index = st->index;
7032  }
7033  } else {
7036  st->discard = AVDISCARD_ALL;
7037  for (i = 0; i < st->nb_index_entries; i++) {
7039  int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
7040  uint8_t *title;
7041  uint16_t ch;
7042  int len, title_len;
7043 
7044  if (end < sample->timestamp) {
7045  av_log(s, AV_LOG_WARNING, "ignoring stream duration which is shorter than chapters\n");
7046  end = AV_NOPTS_VALUE;
7047  }
7048 
7049  if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7050  av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
7051  goto finish;
7052  }
7053 
7054  // the first two bytes are the length of the title
7055  len = avio_rb16(sc->pb);
7056  if (len > sample->size-2)
7057  continue;
7058  title_len = 2*len + 1;
7059  if (!(title = av_mallocz(title_len)))
7060  goto finish;
7061 
7062  // The samples could theoretically be in any encoding if there's an encd
7063  // atom following, but in practice are only utf-8 or utf-16, distinguished
7064  // instead by the presence of a BOM
7065  if (!len) {
7066  title[0] = 0;
7067  } else {
7068  ch = avio_rb16(sc->pb);
7069  if (ch == 0xfeff)
7070  avio_get_str16be(sc->pb, len, title, title_len);
7071  else if (ch == 0xfffe)
7072  avio_get_str16le(sc->pb, len, title, title_len);
7073  else {
7074  AV_WB16(title, ch);
7075  if (len == 1 || len == 2)
7076  title[len] = 0;
7077  else
7078  avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
7079  }
7080  }
7081 
7082  avpriv_new_chapter(s, i, st->time_base, sample->timestamp, end, title);
7083  av_freep(&title);
7084  }
7085  }
7086 finish:
7087  avio_seek(sc->pb, cur_pos, SEEK_SET);
7088  }
7089 }
7090 
7092  uint32_t value, int flags)
7093 {
7094  AVTimecode tc;
7095  char buf[AV_TIMECODE_STR_SIZE];
7096  AVRational rate = st->avg_frame_rate;
7097  int ret = av_timecode_init(&tc, rate, flags, 0, s);
7098  if (ret < 0)
7099  return ret;
7100  av_dict_set(&st->metadata, "timecode",
7101  av_timecode_make_string(&tc, buf, value), 0);
7102  return 0;
7103 }
7104 
7106 {
7107  MOVStreamContext *sc = st->priv_data;
7108  char buf[AV_TIMECODE_STR_SIZE];
7109  int64_t cur_pos = avio_tell(sc->pb);
7110  int hh, mm, ss, ff, drop;
7111 
7112  if (!st->nb_index_entries)
7113  return -1;
7114 
7115  avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7116  avio_skip(s->pb, 13);
7117  hh = avio_r8(s->pb);
7118  mm = avio_r8(s->pb);
7119  ss = avio_r8(s->pb);
7120  drop = avio_r8(s->pb);
7121  ff = avio_r8(s->pb);
7122  snprintf(buf, AV_TIMECODE_STR_SIZE, "%02d:%02d:%02d%c%02d",
7123  hh, mm, ss, drop ? ';' : ':', ff);
7124  av_dict_set(&st->metadata, "timecode", buf, 0);
7125 
7126  avio_seek(sc->pb, cur_pos, SEEK_SET);
7127  return 0;
7128 }
7129 
7131 {
7132  MOVStreamContext *sc = st->priv_data;
7133  int flags = 0;
7134  int64_t cur_pos = avio_tell(sc->pb);
7135  uint32_t value;
7136 
7137  if (!st->nb_index_entries)
7138  return -1;
7139 
7140  avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7141  value = avio_rb32(s->pb);
7142 
7143  if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
7144  if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
7145  if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
7146 
7147  /* Assume Counter flag is set to 1 in tmcd track (even though it is likely
7148  * not the case) and thus assume "frame number format" instead of QT one.
7149  * No sample with tmcd track can be found with a QT timecode at the moment,
7150  * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
7151  * format). */
7152  parse_timecode_in_framenum_format(s, st, value, flags);
7153 
7154  avio_seek(sc->pb, cur_pos, SEEK_SET);
7155  return 0;
7156 }
7157 
7159  int i;
7160  if (!index || !*index) return;
7161  for (i = 0; i < (*index)->nb_encrypted_samples; i++) {
7162  av_encryption_info_free((*index)->encrypted_samples[i]);
7163  }
7164  av_freep(&(*index)->encrypted_samples);
7165  av_freep(&(*index)->auxiliary_info_sizes);
7166  av_freep(&(*index)->auxiliary_offsets);
7167  av_freep(index);
7168 }
7169 
7171 {
7172  MOVContext *mov = s->priv_data;
7173  int i, j;
7174 
7175  for (i = 0; i < s->nb_streams; i++) {
7176  AVStream *st = s->streams[i];
7177  MOVStreamContext *sc = st->priv_data;
7178 
7179  if (!sc)
7180  continue;
7181 
7182  av_freep(&sc->ctts_data);
7183  for (j = 0; j < sc->drefs_count; j++) {
7184  av_freep(&sc->drefs[j].path);
7185  av_freep(&sc->drefs[j].dir);
7186  }
7187  av_freep(&sc->drefs);
7188 
7189  sc->drefs_count = 0;
7190 
7191  if (!sc->pb_is_copied)
7192  ff_format_io_close(s, &sc->pb);
7193 
7194  sc->pb = NULL;
7195  av_freep(&sc->chunk_offsets);
7196  av_freep(&sc->stsc_data);
7197  av_freep(&sc->sample_sizes);
7198  av_freep(&sc->keyframes);
7199  av_freep(&sc->stts_data);
7200  av_freep(&sc->stps_data);
7201  av_freep(&sc->elst_data);
7202  av_freep(&sc->rap_group);
7203  av_freep(&sc->display_matrix);
7204  av_freep(&sc->index_ranges);
7205 
7206  if (sc->extradata)
7207  for (j = 0; j < sc->stsd_count; j++)
7208  av_free(sc->extradata[j]);
7209  av_freep(&sc->extradata);
7210  av_freep(&sc->extradata_size);
7211 
7215 
7216  av_freep(&sc->stereo3d);
7217  av_freep(&sc->spherical);
7218  av_freep(&sc->mastering);
7219  av_freep(&sc->coll);
7220  }
7221 
7222  if (mov->dv_demux) {
7224  mov->dv_fctx = NULL;
7225  }
7226 
7227  if (mov->meta_keys) {
7228  for (i = 1; i < mov->meta_keys_count; i++) {
7229  av_freep(&mov->meta_keys[i]);
7230  }
7231  av_freep(&mov->meta_keys);
7232  }
7233 
7234  av_freep(&mov->trex_data);
7235  av_freep(&mov->bitrates);
7236 
7237  for (i = 0; i < mov->frag_index.nb_items; i++) {
7239  for (j = 0; j < mov->frag_index.item[i].nb_stream_info; j++) {
7240  mov_free_encryption_index(&frag[j].encryption_index);
7241  }
7242  av_freep(&mov->frag_index.item[i].stream_info);
7243  }
7244  av_freep(&mov->frag_index.item);
7245 
7246  av_freep(&mov->aes_decrypt);
7247  av_freep(&mov->chapter_tracks);
7248 
7249  return 0;
7250 }
7251 
7252 static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
7253 {
7254  int i;
7255 
7256  for (i = 0; i < s->nb_streams; i++) {
7257  AVStream *st = s->streams[i];
7258  MOVStreamContext *sc = st->priv_data;
7259 
7260  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
7261  sc->timecode_track == tmcd_id)
7262  return 1;
7263  }
7264  return 0;
7265 }
7266 
7267 /* look for a tmcd track not referenced by any video track, and export it globally */
7269 {
7270  int i;
7271 
7272  for (i = 0; i < s->nb_streams; i++) {
7273  AVStream *st = s->streams[i];
7274 
7275  if (st->codecpar->codec_tag == MKTAG('t','m','c','d') &&
7276  !tmcd_is_referenced(s, i + 1)) {
7277  AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
7278  if (tcr) {
7279  av_dict_set(&s->metadata, "timecode", tcr->value, 0);
7280  break;
7281  }
7282  }
7283  }
7284 }
7285 
7286 static int read_tfra(MOVContext *mov, AVIOContext *f)
7287 {
7288  int version, fieldlength, i, j;
7289  int64_t pos = avio_tell(f);
7290  uint32_t size = avio_rb32(f);
7291  unsigned track_id, item_count;
7292 
7293  if (avio_rb32(f) != MKBETAG('t', 'f', 'r', 'a')) {
7294  return 1;
7295  }
7296  av_log(mov->fc, AV_LOG_VERBOSE, "found tfra\n");
7297 
7298  version = avio_r8(f);
7299  avio_rb24(f);
7300  track_id = avio_rb32(f);
7301  fieldlength = avio_rb32(f);
7302  item_count = avio_rb32(f);
7303  for (i = 0; i < item_count; i++) {
7304  int64_t time, offset;
7305  int index;
7306  MOVFragmentStreamInfo * frag_stream_info;
7307 
7308  if (avio_feof(f)) {
7309  return AVERROR_INVALIDDATA;
7310  }
7311 
7312  if (version == 1) {
7313  time = avio_rb64(f);
7314  offset = avio_rb64(f);
7315  } else {
7316  time = avio_rb32(f);
7317  offset = avio_rb32(f);
7318  }
7319 
7320  // The first sample of each stream in a fragment is always a random
7321  // access sample. So it's entry in the tfra can be used as the
7322  // initial PTS of the fragment.
7323  index = update_frag_index(mov, offset);
7324  frag_stream_info = get_frag_stream_info(&mov->frag_index, index, track_id);
7325  if (frag_stream_info &&
7326  frag_stream_info->first_tfra_pts == AV_NOPTS_VALUE)
7327  frag_stream_info->first_tfra_pts = time;
7328 
7329  for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
7330  avio_r8(f);
7331  for (j = 0; j < ((fieldlength >> 2) & 3) + 1; j++)
7332  avio_r8(f);
7333  for (j = 0; j < ((fieldlength >> 0) & 3) + 1; j++)
7334  avio_r8(f);
7335  }
7336 
7337  avio_seek(f, pos + size, SEEK_SET);
7338  return 0;
7339 }
7340 
7342 {
7343  int64_t stream_size = avio_size(f);
7344  int64_t original_pos = avio_tell(f);
7345  int64_t seek_ret;
7346  int32_t mfra_size;
7347  int ret = -1;
7348  if ((seek_ret = avio_seek(f, stream_size - 4, SEEK_SET)) < 0) {
7349  ret = seek_ret;
7350  goto fail;
7351  }
7352  mfra_size = avio_rb32(f);
7353  if (mfra_size < 0 || mfra_size > stream_size) {
7354  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (unreasonable size)\n");
7355  goto fail;
7356  }
7357  if ((seek_ret = avio_seek(f, -mfra_size, SEEK_CUR)) < 0) {
7358  ret = seek_ret;
7359  goto fail;
7360  }
7361  if (avio_rb32(f) != mfra_size) {
7362  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (size mismatch)\n");
7363  goto fail;
7364  }
7365  if (avio_rb32(f) != MKBETAG('m', 'f', 'r', 'a')) {
7366  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (tag mismatch)\n");
7367  goto fail;
7368  }
7369  av_log(c->fc, AV_LOG_VERBOSE, "stream has mfra\n");
7370  do {
7371  ret = read_tfra(c, f);
7372  if (ret < 0)
7373  goto fail;
7374  } while (!ret);
7375  ret = 0;
7376 fail:
7377  seek_ret = avio_seek(f, original_pos, SEEK_SET);
7378  if (seek_ret < 0) {
7379  av_log(c->fc, AV_LOG_ERROR,
7380  "failed to seek back after looking for mfra\n");
7381  ret = seek_ret;
7382  }
7383  return ret;
7384 }
7385 
7387 {
7388  MOVContext *mov = s->priv_data;
7389  AVIOContext *pb = s->pb;
7390  int j, err;
7391  MOVAtom atom = { AV_RL32("root") };
7392  int i;
7393 
7394  if (mov->decryption_key_len != 0 && mov->decryption_key_len != AES_CTR_KEY_SIZE) {
7395  av_log(s, AV_LOG_ERROR, "Invalid decryption key len %d expected %d\n",
7397  return AVERROR(EINVAL);
7398  }
7399 
7400  mov->fc = s;
7401  mov->trak_index = -1;
7402  /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
7403  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
7404  atom.size = avio_size(pb);
7405  else
7406  atom.size = INT64_MAX;
7407 
7408  /* check MOV header */
7409  do {
7410  if (mov->moov_retry)
7411  avio_seek(pb, 0, SEEK_SET);
7412  if ((err = mov_read_default(mov, pb, atom)) < 0) {
7413  av_log(s, AV_LOG_ERROR, "error reading header\n");
7414  mov_read_close(s);
7415  return err;
7416  }
7417  } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->moov_retry++);
7418  if (!mov->found_moov) {
7419  av_log(s, AV_LOG_ERROR, "moov atom not found\n");
7420  mov_read_close(s);
7421  return AVERROR_INVALIDDATA;
7422  }
7423  av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
7424 
7425  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
7426  if (mov->nb_chapter_tracks > 0 && !mov->ignore_chapters)
7427  mov_read_chapters(s);
7428  for (i = 0; i < s->nb_streams; i++)
7429  if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {
7430  mov_read_timecode_track(s, s->streams[i]);
7431  } else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
7432  mov_read_rtmd_track(s, s->streams[i]);
7433  }
7434  }
7435 
7436  /* copy timecode metadata from tmcd tracks to the related video streams */
7437  for (i = 0; i < s->nb_streams; i++) {
7438  AVStream *st = s->streams[i];
7439  MOVStreamContext *sc = st->priv_data;
7440  if (sc->timecode_track > 0) {
7441  AVDictionaryEntry *tcr;
7442  int tmcd_st_id = -1;
7443 
7444  for (j = 0; j < s->nb_streams; j++)
7445  if (s->streams[j]->id == sc->timecode_track)
7446  tmcd_st_id = j;
7447 
7448  if (tmcd_st_id < 0 || tmcd_st_id == i)
7449  continue;
7450  tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
7451  if (tcr)
7452  av_dict_set(&st->metadata, "timecode", tcr->value, 0);
7453  }
7454  }
7456 
7457  for (i = 0; i < s->nb_streams; i++) {
7458  AVStream *st = s->streams[i];
7459  MOVStreamContext *sc = st->priv_data;
7460  fix_timescale(mov, sc);
7462  st->skip_samples = sc->start_pad;
7463  }
7464  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)
7466  sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
7468  if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
7469  st->codecpar->width = sc->width;
7470  st->codecpar->height = sc->height;
7471  }
7473  if ((err = mov_rewrite_dvd_sub_extradata(st)) < 0)
7474  return err;
7475  }
7476  }
7477  if (mov->handbrake_version &&
7478  mov->handbrake_version <= 1000000*0 + 1000*10 + 2 && // 0.10.2
7480  ) {
7481  av_log(s, AV_LOG_VERBOSE, "Forcing full parsing for mp3 stream\n");
7483  }
7484  }
7485 
7486  if (mov->trex_data) {
7487  for (i = 0; i < s->nb_streams; i++) {
7488  AVStream *st = s->streams[i];
7489  MOVStreamContext *sc = st->priv_data;
7490  if (st->duration > 0) {
7491  if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7492  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7493  sc->data_size, sc->time_scale);
7494  mov_read_close(s);
7495  return AVERROR_INVALIDDATA;
7496  }
7497  st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
7498  }
7499  }
7500  }
7501 
7502  if (mov->use_mfra_for > 0) {
7503  for (i = 0; i < s->nb_streams; i++) {
7504  AVStream *st = s->streams[i];
7505  MOVStreamContext *sc = st->priv_data;
7506  if (sc->duration_for_fps > 0) {
7507  if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7508  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7509  sc->data_size, sc->time_scale);
7510  mov_read_close(s);
7511  return AVERROR_INVALIDDATA;
7512  }
7513  st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale /
7514  sc->duration_for_fps;
7515  }
7516  }
7517  }
7518 
7519  for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {
7520  if (mov->bitrates[i]) {
7521  s->streams[i]->codecpar->bit_rate = mov->bitrates[i];
7522  }
7523  }
7524 
7525  ff_rfps_calculate(s);
7526 
7527  for (i = 0; i < s->nb_streams; i++) {
7528  AVStream *st = s->streams[i];
7529  MOVStreamContext *sc = st->priv_data;
7530 
7531  switch (st->codecpar->codec_type) {
7532  case AVMEDIA_TYPE_AUDIO:
7533  err = ff_replaygain_export(st, s->metadata);
7534  if (err < 0) {
7535  mov_read_close(s);
7536  return err;
7537  }
7538  break;
7539  case AVMEDIA_TYPE_VIDEO:
7540  if (sc->display_matrix) {
7542  sizeof(int32_t) * 9);
7543  if (err < 0)
7544  return err;
7545 
7546  sc->display_matrix = NULL;
7547  }
7548  if (sc->stereo3d) {
7550  (uint8_t *)sc->stereo3d,
7551  sizeof(*sc->stereo3d));
7552  if (err < 0)
7553  return err;
7554 
7555  sc->stereo3d = NULL;
7556  }
7557  if (sc->spherical) {
7559  (uint8_t *)sc->spherical,
7560  sc->spherical_size);
7561  if (err < 0)
7562  return err;
7563 
7564  sc->spherical = NULL;
7565  }
7566  if (sc->mastering) {
7568  (uint8_t *)sc->mastering,
7569  sizeof(*sc->mastering));
7570  if (err < 0)
7571  return err;
7572 
7573  sc->mastering = NULL;
7574  }
7575  if (sc->coll) {
7577  (uint8_t *)sc->coll,
7578  sc->coll_size);
7579  if (err < 0)
7580  return err;
7581 
7582  sc->coll = NULL;
7583  }
7584  break;
7585  }
7586  }
7588 
7589  for (i = 0; i < mov->frag_index.nb_items; i++)
7590  if (mov->frag_index.item[i].moof_offset <= mov->fragment.moof_offset)
7591  mov->frag_index.item[i].headers_read = 1;
7592 
7593  return 0;
7594 }
7595 
7597 {
7599  int64_t best_dts = INT64_MAX;
7600  int i;
7601  for (i = 0; i < s->nb_streams; i++) {
7602  AVStream *avst = s->streams[i];
7603  MOVStreamContext *msc = avst->priv_data;
7604  if (msc->pb && msc->current_sample < avst->nb_index_entries) {
7605  AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
7606  int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
7607  av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
7608  if (!sample || (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && current_sample->pos < sample->pos) ||
7609  ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
7610  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
7611  ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
7612  (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
7613  sample = current_sample;
7614  best_dts = dts;
7615  *st = avst;
7616  }
7617  }
7618  }
7619  return sample;
7620 }
7621 
7622 static int should_retry(AVIOContext *pb, int error_code) {
7623  if (error_code == AVERROR_EOF || avio_feof(pb))
7624  return 0;
7625 
7626  return 1;
7627 }
7628 
7629 static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
7630 {
7631  int ret;
7632  MOVContext *mov = s->priv_data;
7633 
7634  if (index >= 0 && index < mov->frag_index.nb_items)
7635  target = mov->frag_index.item[index].moof_offset;
7636  if (avio_seek(s->pb, target, SEEK_SET) != target) {
7637  av_log(mov->fc, AV_LOG_ERROR, "root atom offset 0x%"PRIx64": partial file\n", target);
7638  return AVERROR_INVALIDDATA;
7639  }
7640 
7641  mov->next_root_atom = 0;
7642  if (index < 0 || index >= mov->frag_index.nb_items)
7643  index = search_frag_moof_offset(&mov->frag_index, target);
7644  if (index < mov->frag_index.nb_items) {
7645  if (index + 1 < mov->frag_index.nb_items)
7646  mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
7647  if (mov->frag_index.item[index].headers_read)
7648  return 0;
7649  mov->frag_index.item[index].headers_read = 1;
7650  }
7651 
7652  mov->found_mdat = 0;
7653 
7654  ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
7655  if (ret < 0)
7656  return ret;
7657  if (avio_feof(s->pb))
7658  return AVERROR_EOF;
7659  av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
7660 
7661  return 1;
7662 }
7663 
7665 {
7666  uint8_t *side, *extradata;
7667  int extradata_size;
7668 
7669  /* Save the current index. */
7670  sc->last_stsd_index = sc->stsc_data[sc->stsc_index].id - 1;
7671 
7672  /* Notify the decoder that extradata changed. */
7673  extradata_size = sc->extradata_size[sc->last_stsd_index];
7674  extradata = sc->extradata[sc->last_stsd_index];
7675  if (extradata_size > 0 && extradata) {
7676  side = av_packet_new_side_data(pkt,
7678  extradata_size);
7679  if (!side)
7680  return AVERROR(ENOMEM);
7681  memcpy(side, extradata, extradata_size);
7682  }
7683 
7684  return 0;
7685 }
7686 
7688 {
7689  MOVContext *mov = s->priv_data;
7690  MOVStreamContext *sc;
7692  AVStream *st = NULL;
7693  int64_t current_index;
7694  int ret;
7695  mov->fc = s;
7696  retry:
7697  sample = mov_find_next_sample(s, &st);
7698  if (!sample || (mov->next_root_atom && sample->pos > mov->next_root_atom)) {
7699  if (!mov->next_root_atom)
7700  return AVERROR_EOF;
7701  if ((ret = mov_switch_root(s, mov->next_root_atom, -1)) < 0)
7702  return ret;
7703  goto retry;
7704  }
7705  sc = st->priv_data;
7706  /* must be done just before reading, to avoid infinite loop on sample */
7707  current_index = sc->current_index;
7709 
7710  if (mov->next_root_atom) {
7711  sample->pos = FFMIN(sample->pos, mov->next_root_atom);
7712  sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));
7713  }
7714 
7715  if (st->discard != AVDISCARD_ALL) {
7716  int64_t ret64 = avio_seek(sc->pb, sample->pos, SEEK_SET);
7717  if (ret64 != sample->pos) {
7718  av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
7719  sc->ffindex, sample->pos);
7720  if (should_retry(sc->pb, ret64)) {
7722  }
7723  return AVERROR_INVALIDDATA;
7724  }
7725 
7726  if( st->discard == AVDISCARD_NONKEY && 0==(sample->flags & AVINDEX_KEYFRAME) ) {
7727  av_log(mov->fc, AV_LOG_DEBUG, "Nonkey frame from stream %d discarded due to AVDISCARD_NONKEY\n", sc->ffindex);
7728  goto retry;
7729  }
7730 
7731  ret = av_get_packet(sc->pb, pkt, sample->size);
7732  if (ret < 0) {
7733  if (should_retry(sc->pb, ret)) {
7735  }
7736  return ret;
7737  }
7738  if (sc->has_palette) {
7739  uint8_t *pal;
7740 
7742  if (!pal) {
7743  av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
7744  } else {
7745  memcpy(pal, sc->palette, AVPALETTE_SIZE);
7746  sc->has_palette = 0;
7747  }
7748  }
7749 #if CONFIG_DV_DEMUXER
7750  if (mov->dv_demux && sc->dv_audio_container) {
7751  avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);
7752  av_freep(&pkt->data);
7753  pkt->size = 0;
7754  ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
7755  if (ret < 0)
7756  return ret;
7757  }
7758 #endif
7759  if (st->codecpar->codec_id == AV_CODEC_ID_MP3 && !st->need_parsing && pkt->size > 4) {
7760  if (ff_mpa_check_header(AV_RB32(pkt->data)) < 0)
7762  }
7763  }
7764 
7765  pkt->stream_index = sc->ffindex;
7766  pkt->dts = sample->timestamp;
7767  if (sample->flags & AVINDEX_DISCARD_FRAME) {
7768  pkt->flags |= AV_PKT_FLAG_DISCARD;
7769  }
7770  if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {
7771  pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
7772  /* update ctts context */
7773  sc->ctts_sample++;
7774  if (sc->ctts_index < sc->ctts_count &&
7775  sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
7776  sc->ctts_index++;
7777  sc->ctts_sample = 0;
7778  }
7779  } else {
7780  int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
7782 
7783  if (next_dts >= pkt->dts)
7784  pkt->duration = next_dts - pkt->dts;
7785  pkt->pts = pkt->dts;
7786  }
7787  if (st->discard == AVDISCARD_ALL)
7788  goto retry;
7789  pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
7790  pkt->pos = sample->pos;
7791 
7792  /* Multiple stsd handling. */
7793  if (sc->stsc_data) {
7794  /* Keep track of the stsc index for the given sample, then check
7795  * if the stsd index is different from the last used one. */
7796  sc->stsc_sample++;
7797  if (mov_stsc_index_valid(sc->stsc_index, sc->stsc_count) &&
7798  mov_get_stsc_samples(sc, sc->stsc_index) == sc->stsc_sample) {
7799  sc->stsc_index++;
7800  sc->stsc_sample = 0;
7801  /* Do not check indexes after a switch. */
7802  } else if (sc->stsc_data[sc->stsc_index].id > 0 &&
7803  sc->stsc_data[sc->stsc_index].id - 1 < sc->stsd_count &&
7804  sc->stsc_data[sc->stsc_index].id - 1 != sc->last_stsd_index) {
7805  ret = mov_change_extradata(sc, pkt);
7806  if (ret < 0)
7807  return ret;
7808  }
7809  }
7810 
7811  if (mov->aax_mode)
7812  aax_filter(pkt->data, pkt->size, mov);
7813 
7814  ret = cenc_filter(mov, st, sc, pkt, current_index);
7815  if (ret < 0)
7816  return ret;
7817 
7818  return 0;
7819 }
7820 
7821 static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
7822 {
7823  MOVContext *mov = s->priv_data;
7824  int index;
7825 
7826  if (!mov->frag_index.complete)
7827  return 0;
7828 
7829  index = search_frag_timestamp(&mov->frag_index, st, timestamp);
7830  if (index < 0)
7831  index = 0;
7832  if (!mov->frag_index.item[index].headers_read)
7833  return mov_switch_root(s, -1, index);
7834  if (index + 1 < mov->frag_index.nb_items)
7835  mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
7836 
7837  return 0;
7838 }
7839 
7840 static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
7841 {
7842  MOVStreamContext *sc = st->priv_data;
7843  int sample, time_sample, ret;
7844  unsigned int i;
7845 
7846  // Here we consider timestamp to be PTS, hence try to offset it so that we
7847  // can search over the DTS timeline.
7848  timestamp -= (sc->min_corrected_pts + sc->dts_shift);
7849 
7850  ret = mov_seek_fragment(s, st, timestamp);
7851  if (ret < 0)
7852  return ret;
7853 
7854  sample = av_index_search_timestamp(st, timestamp, flags);
7855  av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
7856  if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
7857  sample = 0;
7858  if (sample < 0) /* not sure what to do */
7859  return AVERROR_INVALIDDATA;
7860  mov_current_sample_set(sc, sample);
7861  av_log(s, AV_LOG_TRACE, "stream %d, found sample %d\n", st->index, sc->current_sample);
7862  /* adjust ctts index */
7863  if (sc->ctts_data) {
7864  time_sample = 0;
7865  for (i = 0; i < sc->ctts_count; i++) {
7866  int next = time_sample + sc->ctts_data[i].count;
7867  if (next > sc->current_sample) {
7868  sc->ctts_index = i;
7869  sc->ctts_sample = sc->current_sample - time_sample;
7870  break;
7871  }
7872  time_sample = next;
7873  }
7874  }
7875 
7876  /* adjust stsd index */
7877  if (sc->chunk_count) {
7878  time_sample = 0;
7879  for (i = 0; i < sc->stsc_count; i++) {
7880  int64_t next = time_sample + mov_get_stsc_samples(sc, i);
7881  if (next > sc->current_sample) {
7882  sc->stsc_index = i;
7883  sc->stsc_sample = sc->current_sample - time_sample;
7884  break;
7885  }
7886  av_assert0(next == (int)next);
7887  time_sample = next;
7888  }
7889  }
7890 
7891  return sample;
7892 }
7893 
7894 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
7895 {
7896  MOVContext *mc = s->priv_data;
7897  AVStream *st;
7898  int sample;
7899  int i;
7900 
7901  if (stream_index >= s->nb_streams)
7902  return AVERROR_INVALIDDATA;
7903 
7904  st = s->streams[stream_index];
7905  sample = mov_seek_stream(s, st, sample_time, flags);
7906  if (sample < 0)
7907  return sample;
7908 
7909  if (mc->seek_individually) {
7910  /* adjust seek timestamp to found sample timestamp */
7911  int64_t seek_timestamp = st->index_entries[sample].timestamp;
7912 
7913  for (i = 0; i < s->nb_streams; i++) {
7914  int64_t timestamp;
7915  MOVStreamContext *sc = s->streams[i]->priv_data;
7916  st = s->streams[i];
7917  st->skip_samples = (sample_time <= 0) ? sc->start_pad : 0;
7918 
7919  if (stream_index == i)
7920  continue;
7921 
7922  timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
7923  mov_seek_stream(s, st, timestamp, flags);
7924  }
7925  } else {
7926  for (i = 0; i < s->nb_streams; i++) {
7927  MOVStreamContext *sc;
7928  st = s->streams[i];
7929  sc = st->priv_data;
7930  mov_current_sample_set(sc, 0);
7931  }
7932  while (1) {
7933  MOVStreamContext *sc;
7934  AVIndexEntry *entry = mov_find_next_sample(s, &st);
7935  if (!entry)
7936  return AVERROR_INVALIDDATA;
7937  sc = st->priv_data;
7938  if (sc->ffindex == stream_index && sc->current_sample == sample)
7939  break;
7941  }
7942  }
7943  return 0;
7944 }
7945 
7946 #define OFFSET(x) offsetof(MOVContext, x)
7947 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
7948 static const AVOption mov_options[] = {
7949  {"use_absolute_path",
7950  "allow using absolute path when opening alias, this is a possible security issue",
7951  OFFSET(use_absolute_path), AV_OPT_TYPE_BOOL, {.i64 = 0},
7952  0, 1, FLAGS},
7953  {"seek_streams_individually",
7954  "Seek each stream individually to the to the closest point",
7955  OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
7956  0, 1, FLAGS},
7957  {"ignore_editlist", "Ignore the edit list atom.", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
7958  0, 1, FLAGS},
7959  {"advanced_editlist",
7960  "Modify the AVIndex according to the editlists. Use this option to decode in the order specified by the edits.",
7961  OFFSET(advanced_editlist), AV_OPT_TYPE_BOOL, {.i64 = 1},
7962  0, 1, FLAGS},
7963  {"ignore_chapters", "", OFFSET(ignore_chapters), AV_OPT_TYPE_BOOL, {.i64 = 0},
7964  0, 1, FLAGS},
7965  {"use_mfra_for",
7966  "use mfra for fragment timestamps",
7967  OFFSET(use_mfra_for), AV_OPT_TYPE_INT, {.i64 = FF_MOV_FLAG_MFRA_AUTO},
7969  "use_mfra_for"},
7970  {"auto", "auto", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_AUTO}, 0, 0,
7971  FLAGS, "use_mfra_for" },
7972  {"dts", "dts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_DTS}, 0, 0,
7973  FLAGS, "use_mfra_for" },
7974  {"pts", "pts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_PTS}, 0, 0,
7975  FLAGS, "use_mfra_for" },
7976  { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
7977  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
7978  { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
7979  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
7980  { "activation_bytes", "Secret bytes for Audible AAX files", OFFSET(activation_bytes),
7982  { "audible_fixed_key", // extracted from libAAX_SDK.so and AAXSDKWin.dll files!
7983  "Fixed key used for handling Audible AAX files", OFFSET(audible_fixed_key),
7984  AV_OPT_TYPE_BINARY, {.str="77214d4b196a87cd520045fd20a51d67"},
7985  .flags = AV_OPT_FLAG_DECODING_PARAM },
7986  { "decryption_key", "The media decryption key (hex)", OFFSET(decryption_key), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
7987  { "enable_drefs", "Enable external track support.", OFFSET(enable_drefs), AV_OPT_TYPE_BOOL,
7988  {.i64 = 0}, 0, 1, FLAGS },
7989 
7990  { NULL },
7991 };
7992 
7993 static const AVClass mov_class = {
7994  .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
7995  .item_name = av_default_item_name,
7996  .option = mov_options,
7997  .version = LIBAVUTIL_VERSION_INT,
7998 };
7999 
8001  .name = "mov,mp4,m4a,3gp,3g2,mj2",
8002  .long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
8003  .priv_class = &mov_class,
8004  .priv_data_size = sizeof(MOVContext),
8005  .extensions = "mov,mp4,m4a,3gp,3g2,mj2",
8006  .read_probe = mov_probe,
8012 };
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1721
int itunes_metadata
metadata are itunes style
Definition: isom.h:260
int * bitrates
bitrates read before streams creation
Definition: isom.h:272
static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1370
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:345
#define AVINDEX_DISCARD_FRAME
Definition: avformat.h:818
int64_t current_index
Definition: isom.h:190
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:4732
AVSphericalMapping * av_spherical_alloc(size_t *size)
Allocate a AVSphericalVideo structure and initialize its fields to default values.
Definition: spherical.c:24
int cid
Definition: mxfenc.c:2072
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2511
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1940
int64_t moof_offset
Definition: isom.h:137
#define AV_RB8(x)
Definition: intreadwrite.h:395
size_t auxiliary_offsets_count
Definition: isom.h:124
#define NULL
Definition: coverity.c:32
#define DRM_BLOB_SIZE
Definition: mov.c:986
const char const char void * val
Definition: avisynth_c.h:863
#define FF_API_OLD_ROTATE_API
Definition: version.h:80
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4038
discard all frames except keyframes
Definition: avcodec.h:810
static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:777
static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1511
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4045
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
Definition: mov.c:7629
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
static const char * format[]
Definition: af_aiir.c:338
int size
static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:818
#define av_realloc_f(p, o, n)
uint32_t tmcd_flags
tmcd track flags
Definition: isom.h:208
#define OPUS_SEEK_PREROLL_MS
Definition: oggparseopus.c:35
unsigned int rap_group_count
Definition: isom.h:211
int found_tfhd
Definition: isom.h:90
unsigned int elst_count
Definition: isom.h:176
unsigned MaxCLL
Max content light level (cd/m^2).
void av_encryption_info_free(AVEncryptionInfo *info)
Frees the given encryption info object.
static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5069
AVOption.
Definition: opt.h:246
hash context
Definition: sha.c:34
MOVTrackExt * trex_data
Definition: isom.h:258
int export_all
Definition: isom.h:270
int64_t end
Definition: isom.h:154
static int mov_change_extradata(MOVStreamContext *sc, AVPacket *pkt)
Definition: mov.c:7664
unsigned track_id
Definition: isom.h:91
#define MOV_TFHD_DEFAULT_DURATION
Definition: isom.h:307
static AVIndexEntry * mov_find_next_sample(AVFormatContext *s, AVStream **st)
Definition: mov.c:7596
uint32_t format
Definition: isom.h:232
static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:535
static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4297
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3125
unsigned int samples_per_frame
Definition: isom.h:194
AVEncryptionInitInfo * av_encryption_init_info_alloc(uint32_t system_id_size, uint32_t num_key_ids, uint32_t key_id_size, uint32_t data_size)
Allocates an AVEncryptionInitInfo structure and sub-pointers to hold the given sizes.
static void mov_build_index(MOVContext *mov, AVStream *st)
Definition: mov.c:3720
int dv_audio_container
Definition: isom.h:195
Definition: isom.h:56
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Definition: sha.c:273
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
float rate
Definition: isom.h:70
uint64_t base_data_offset
Definition: isom.h:92
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int64_t duration
Definition: isom.h:68
size_t spherical_size
Definition: isom.h:227
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
unsigned int ctts_allocated_size
Definition: isom.h:167
#define AV_RB64
Definition: intreadwrite.h:164
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4886
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
const char * g
Definition: vf_curves.c:115
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:696
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle...
Definition: avstring.c:56
int64_t pos
Definition: avformat.h:810
static void mov_free_encryption_index(MOVEncryptionIndex **index)
Definition: mov.c:7158
void av_encryption_init_info_free(AVEncryptionInitInfo *info)
Frees the given encryption init info object.
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2513
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
unsigned int stsc_count
Definition: isom.h:169
int has_palette
Definition: isom.h:206
static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:123
uint32_t crypt_byte_block
Only used for pattern encryption.
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: avcodec.h:1258
static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
Definition: mov.c:1175
static MOVFragmentStreamInfo * get_current_frag_stream_info(MOVFragmentIndex *frag_index)
Definition: mov.c:1195
enum AVCodecID codec_id
Definition: qsv.c:72
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
Definition: spherical.h:72
AVEncryptionInfo * default_encrypted_sample
Definition: isom.h:238
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
int allocated_size
Definition: isom.h:145
static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4159
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
AVMasteringDisplayMetadata * mastering
Definition: isom.h:228
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1478
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
const char * b
Definition: vf_curves.c:116
#define AV_WB8(p, d)
Definition: intreadwrite.h:396
#define MOV_TRUN_SAMPLE_CTS
Definition: isom.h:318
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: aes.c:163
uint8_t * decryption_key
Definition: isom.h:287
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1110
This describes encryption info for a packet.
int ignore_chapters
Definition: isom.h:267
static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
Definition: mov.c:7252
void * activation_bytes
Definition: isom.h:282
#define tc
Definition: regdef.h:69
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1673
AVEncryptionInfo ** encrypted_samples
Definition: isom.h:118
static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6107
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
uint64_t * auxiliary_offsets
Absolute seek position.
Definition: isom.h:123
color_range
void * priv_data
Definition: avformat.h:896
uint8_t * av_encryption_init_info_add_side_data(const AVEncryptionInitInfo *info, size_t *side_data_size)
Allocates and initializes side data that holds a copy of the given encryption init info...
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
const char * key
int version
Definition: avisynth_c.h:858
int16_t audio_cid
stsd audio compression id
Definition: isom.h:197
char ** meta_keys
Definition: isom.h:252
#define PUT_UTF8(val, tmp, PUT_BYTE)
Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
Definition: common.h:438
discard all
Definition: avcodec.h:811
Views are next to each other.
Definition: stereo3d.h:67
static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
Definition: mov.c:5612
#define IS_MATRIX_IDENT(matrix)
Definition: mov.c:4436
static AVPacket pkt
int height
tkhd height
Definition: isom.h:203
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:785
int(* parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:72
#define src
Definition: vp8dsp.c:254
static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:298
#define sample
uint32_t type
Definition: isom.h:83
static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5675
uint32_t skip_byte_block
Only used for pattern encryption.
MOVElst * elst_data
Definition: isom.h:175
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
AVStereo3D * av_stereo3d_alloc(void)
Allocate an AVStereo3D structure and set its fields to default values.
Definition: stereo3d.c:28
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1666
MOVStsc * stsc_data
Definition: isom.h:170
int nb_items
Definition: isom.h:148
static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1460
int ctts_index
Definition: isom.h:177
int complete
Definition: isom.h:146
unsigned stsd_id
Definition: isom.h:103
AVSphericalMapping * spherical
Definition: isom.h:226
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
int found_moov
&#39;moov&#39; atom has been found
Definition: isom.h:248
static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2712
static void export_orphan_timecode(AVFormatContext *s)
Definition: mov.c:7268
enum AVColorSpace color_space
Definition: avcodec.h:4046
static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1776
static MOVFragmentStreamInfo * get_frag_stream_info(MOVFragmentIndex *frag_index, int index, int id)
Definition: mov.c:1156
#define MOV_TFHD_DEFAULT_BASE_IS_MOOF
Definition: isom.h:311
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2915
Macro definitions for various function/variable attributes.
int frame_size
Audio only.
Definition: avcodec.h:4078
Mastering display metadata (based on SMPTE-2086:2014).
Definition: avcodec.h:1366
static int should_retry(AVIOContext *pb, int error_code)
Definition: mov.c:7622
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that&#39;s been allocated with av_malloc() or another memory allocation function...
Definition: dict.h:73
static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
Definition: mov.c:1630
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
unsigned flags
Definition: isom.h:106
#define MOV_TKHD_FLAG_ENABLED
Definition: isom.h:330
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4587
int isom
1 if file is ISO Media (mp4/3gp)
Definition: isom.h:256
int found_mdat
&#39;mdat&#39; atom has been found
Definition: isom.h:249
int width
tkhd width
Definition: isom.h:202
unsigned drefs_count
Definition: isom.h:198
static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5432
Format I/O context.
Definition: avformat.h:1358
static int mov_read_header(AVFormatContext *s)
Definition: mov.c:7386
char filename[64]
Definition: isom.h:78
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1491
void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int count)
Process a buffer using a previously initialized context.
Definition: aes_ctr.c:111
static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int64_t size)
Definition: mov.c:2288
Public dictionary API.
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:258
MOVDref * drefs
Definition: isom.h:199
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1138
static char buffer[20]
Definition: seek.c:32
static const AVOption mov_options[]
Definition: mov.c:7948
static void mov_current_sample_dec(MOVStreamContext *sc)
Definition: mov.c:3376
static int64_t start_time
Definition: ffplay.c:331
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
int first
Definition: isom.h:62
uint8_t
uint8_t ** key_ids
An array of key IDs this initialization data is for.
AVEncryptionInfo * av_encryption_info_clone(const AVEncryptionInfo *info)
Allocates an AVEncryptionInfo structure with a copy of the given data.
#define FF_MOV_FLAG_MFRA_DTS
Definition: isom.h:363
#define av_malloc(s)
static int64_t add_ctts_entry(MOVStts **ctts_data, unsigned int *ctts_count, unsigned int *allocated_size, int count, int duration)
Append a new ctts entry to ctts_data.
Definition: mov.c:3281
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4023
size_t coll_size
Definition: isom.h:230
AVOptions.
unsigned int sample_count
Definition: isom.h:181
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:75
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:800
int count
Definition: isom.h:63
int dts_shift
dts shift when ctts is negative
Definition: isom.h:204
int stsd_version
Definition: isom.h:222
static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:858
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
#define f(width, name)
Definition: cbs_vp9.c:255
unsigned int bytes_of_clear_data
The number of bytes that are clear.
timecode is drop frame
Definition: timecode.h:36
#define AV_RB32
Definition: intreadwrite.h:130
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6641
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1252
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
int id
Format-specific stream ID.
Definition: avformat.h:888
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5641
AVInputFormat ff_mov_demuxer
Definition: mov.c:8000
unsigned int count
Definition: isom.h:110
static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5089
static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVStreamContext *sc, AVEncryptionInfo **sample, int use_subsamples)
Definition: mov.c:5908
static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add index entry with the given values, to the end of st->index_entries.
Definition: mov.c:3226
static void mov_current_sample_inc(MOVStreamContext *sc)
Definition: mov.c:3364
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4459
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5447
int16_t nlvl_to
Definition: isom.h:79
uint32_t scheme
The fourcc encryption scheme, in big-endian byte order.
This file is part of FFmpeg.
This describes info used to initialize an encryption key system.
#define AV_CH_LOW_FREQUENCY
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int64_t duration
Definition: movenc.c:63
char volume[28]
Definition: isom.h:77
static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:114
static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:939
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb, int codec_tag, int format, int64_t size)
Definition: mov.c:2433
int stsd_count
Definition: isom.h:221
int activation_bytes_size
Definition: isom.h:283
int initial_padding
Audio only.
Definition: avcodec.h:4086
const char data[16]
Definition: mxf.c:91
#define height
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
static void finish(void)
Definition: movenc.c:345
#define ALAC_EXTRADATA_SIZE
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:324
uint8_t * data
Definition: avcodec.h:1477
This side data is encryption initialization data.
Definition: avcodec.h:1393
#define MOV_TRUN_SAMPLE_SIZE
Definition: isom.h:316
uint32_t tag
Definition: movenc.c:1496
void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
Definition: utils.c:2091
int nb_frames_for_fps
Definition: isom.h:214
uint8_t * iv
The initialization vector.
#define ff_dlog(a,...)
#define AVERROR_EOF
End of file.
Definition: error.h:55
bitstream reader API header.
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
struct AVAESCTR * aes_ctr
Definition: isom.h:236
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:711
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:921
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
Definition: replaygain.c:91
static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encryption_index, MOVStreamContext **sc)
Gets the current encryption info and associated current stream context.
Definition: mov.c:5858
static int test_same_origin(const char *src, const char *ref)
Definition: mov.c:4048
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
void av_aes_ctr_free(struct AVAESCTR *a)
Release an AVAESCTR context.
Definition: aes_ctr.c:84
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1544
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4059
#define av_log(a,...)
int current_sample
Definition: isom.h:189
#define MOV_TFHD_DEFAULT_SIZE
Definition: isom.h:308
int32_t movie_display_matrix[3][3]
display matrix from mvhd
Definition: isom.h:290
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:647
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
AVEncryptionInitInfo * av_encryption_init_info_get_side_data(const uint8_t *side_data, size_t side_data_size)
Creates a copy of the AVEncryptionInitInfo that is contained in the given side data.
static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5811
unsigned track_id
Definition: isom.h:102
static int mov_try_read_block(AVIOContext *pb, size_t size, uint8_t **data)
Tries to read the given number of bytes from the stream and puts it in a newly allocated buffer...
Definition: mov.c:6080
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3986
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
void ff_rfps_calculate(AVFormatContext *ic)
Definition: utils.c:3382
int64_t time_offset
time offset of the edit list entries
Definition: isom.h:187
static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4340
unsigned int keyframe_count
Definition: isom.h:184
MOVIndexRange * index_ranges
Definition: isom.h:191
AVSubsampleEncryptionInfo * subsamples
An array of subsample encryption info specifying how parts of the sample are encrypted.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:184
int64_t first_tfra_pts
Definition: isom.h:130
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
Definition: ac3tab.c:89
static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1596
static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2557
uint8_t * auxiliary_info_sizes
Definition: isom.h:120
static int mov_rewrite_dvd_sub_extradata(AVStream *st)
Definition: mov.c:2253
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
int * extradata_size
Definition: isom.h:219
const AVCodecTag ff_codec_movdata_tags[]
Definition: isom.c:383
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int64_t size)
Definition: mov.c:2223
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1533
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
unsigned int ctts_count
Definition: isom.h:166
static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5251
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
int64_t tfdt_dts
Definition: isom.h:131
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2148
static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:954
static int mov_read_mdcv(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5337
static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5143
static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOContext *pb, MOVEncryptionIndex *encryption_index)
Definition: mov.c:6013
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
AVAudioServiceType
Definition: avcodec.h:814
int stsc_sample
Definition: isom.h:172
#define AV_RB16
Definition: intreadwrite.h:53
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:769
#define AVERROR(e)
Definition: error.h:43
static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2972
int atom_depth
Definition: isom.h:278
uint32_t num_key_ids
The number of key IDs.
static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5376
static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1819
static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1824
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:811
MOVIndexRange * current_index_range
Definition: isom.h:192
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
Display matrix.
enum AVColorPrimaries color_primaries
Definition: avcodec.h:4044
char * url
input or output URL.
Definition: avformat.h:1454
int video_delay
Video only.
Definition: avcodec.h:4052
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int * keyframes
Definition: isom.h:185
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
AVFormatContext * fc
Definition: isom.h:245
static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
Definition: mov.c:4077
simple assert() macros that are a bit more flexible than ISO C assert().
static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4686
#define FFNABS(a)
Negative Absolute value.
Definition: common.h:81
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int handbrake_version
Definition: isom.h:261
int ctts_sample
Definition: isom.h:178
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:31
static int ff_mpa_check_header(uint32_t header)
uint8_t * av_encryption_info_add_side_data(const AVEncryptionInfo *info, size_t *size)
Allocates and initializes side data that holds a copy of the given encryption info.
#define AES_CTR_KEY_SIZE
Definition: aes_ctr.h:30
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet. ...
Definition: avformat.h:1149
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int keyframe_absent
Definition: isom.h:183
static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4961
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:499
#define FFMAX(a, b)
Definition: common.h:94
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
int16_t nlvl_from
Definition: isom.h:79
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES
Definition: isom.h:328
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
Definition: avformat.h:823
#define fail()
Definition: checkasm.h:120
static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
Definition: mov.c:1396
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc(void)
Copyright (c) 2016 Neil Birkbeck neil.birkbeck@gmail.com
void * audible_fixed_key
Definition: isom.h:284
const AVCodecTag ff_codec_movsubtitle_tags[]
Definition: isom.c:376
int64_t min_corrected_pts
minimum Composition time shown by the edits excluding empty edits.
Definition: isom.h:188
static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:988
#define MIN_DATA_ENTRY_BOX_SIZE
Definition: mov.c:573
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2867
static int search_frag_timestamp(MOVFragmentIndex *frag_index, AVStream *st, int64_t timestamp)
Definition: mov.c:1266
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
Only parse headers, do not repack.
Definition: avformat.h:801
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
Definition: mov.c:2461
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:638
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:205
struct AVAESCTR * av_aes_ctr_alloc(void)
Allocate an AVAESCTR context.
Definition: aes_ctr.c:36
static float distance(float x, float y, int band)
static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4444
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6785
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
static int aax_filter(uint8_t *input, int size, MOVContext *c)
Definition: mov.c:1087
static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1543
#define MAX_REORDER_DELAY
Definition: mov.c:3308
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
AVContentLightMetadata * coll
Definition: isom.h:229
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1411
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:170
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5311
static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
Definition: mov.c:7840
uint8_t file_key[20]
Definition: isom.h:280
static int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
Definition: mov.c:2697
static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:80
int block_align
Audio only.
Definition: avcodec.h:4074
static av_const double hypot(double x, double y)
Definition: libm.h:366
struct AVAES * aes_decrypt
Definition: isom.h:286
static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2885
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
static int mov_read_clli(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5408
struct AVEncryptionInitInfo * next
An optional pointer to the next initialization info in the list.
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
audio channel layout utility functions
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3288
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:793
static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4603
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
Spherical video.
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
MOVFragmentStreamInfo * stream_info
Definition: isom.h:141
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
Definition: utils.c:5462
AVStereo3DType
List of possible 3D Types.
Definition: stereo3d.h:51
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1101
#define width
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5212
char * dir
Definition: isom.h:76
static int mov_stsc_index_valid(unsigned int index, unsigned int count)
Definition: mov.c:2691
static int update_frag_index(MOVContext *c, int64_t offset)
Definition: mov.c:1300
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:315
static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5959
int id
Definition: isom.h:64
uint8_t auxiliary_info_default_size
Definition: isom.h:122
static int cenc_filter(MOVContext *mov, AVStream *st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
Definition: mov.c:6577
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: avcodec.h:1372
int decryption_key_len
Definition: isom.h:288
static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1703
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:169
#define FLAGS
Definition: mov.c:7947
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
int32_t
static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
Definition: mov.c:7130
AVFormatContext * ctx
Definition: movenc.c:48
int audible_fixed_key_size
Definition: isom.h:285
static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4562
static void mov_fix_index(MOVContext *mov, AVStream *st)
Fix st->index_entries, so that it contains only the entries (and the entries which are needed to deco...
Definition: mov.c:3416
static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1735
int advanced_editlist
Definition: isom.h:266
static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4648
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:1674
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
Definition: mov.c:1211
char * path
Definition: isom.h:75
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int time_scale
Definition: isom.h:186
#define s(width, name)
Definition: cbs_vp9.c:257
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:476
#define AV_RL32
Definition: intreadwrite.h:146
uint64_t moof_offset
Definition: isom.h:93
MOVStts * ctts_data
Definition: isom.h:168
#define OFFSET(x)
Definition: mov.c:7946
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
#define MOV_TRUN_SAMPLE_DURATION
Definition: isom.h:315
AVDictionary * metadata
Definition: avformat.h:945
uint8_t * av_stream_new_side_data(AVStream *stream, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5498
unsigned size
Definition: isom.h:105
#define AV_CH_FRONT_CENTER
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4043
int ignore_editlist
Definition: isom.h:265
MOVFragmentIndexItem * item
Definition: isom.h:149
int64_t * chunk_offsets
Definition: isom.h:163
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mov.c:7687
static int mov_read_close(AVFormatContext *s)
Definition: mov.c:7170
unsigned int index
Definition: isom.h:111
static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
This function reads atom content and puts data in extradata without tag nor size unlike mov_read_extr...
Definition: mov.c:1882
MOVFragmentIndex frag_index
Definition: isom.h:277
if(ret< 0)
Definition: vf_mcdeint.c:279
int ff_mov_read_chan(AVFormatContext *s, AVIOContext *pb, AVStream *st, int64_t size)
Read &#39;chan&#39; tag from the input stream.
Definition: mov_chan.c:547
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:849
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:229
#define FF_MOV_FLAG_MFRA_PTS
Definition: isom.h:364
static int cenc_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
Definition: mov.c:6521
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:522
static int mov_read_av1c(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5223
int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb)
Definition: mov_esds.c:23
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
#define mc
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
int64_t duration
duration of the longest track
Definition: isom.h:247
int ff_mov_lang_to_iso639(unsigned code, char to[4])
Definition: isom.c:441
static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6484
Stream structure.
Definition: avformat.h:881
static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
Definition: mov.c:180
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVSphericalProjection
Projection of the video surface(s) on a sphere.
Definition: spherical.h:51
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
Definition: aes.c:195
static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
Definition: mov.c:281
Content light level (based on CTA-861.3).
Definition: avcodec.h:1379
unsigned duration
Definition: isom.h:104
DVDemuxContext * dv_demux
Definition: isom.h:254
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int timecode_track
Definition: isom.h:201
int * sample_sizes
Definition: isom.h:182
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1199
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mov.c:7894
int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts)
add frame for rfps calculation.
Definition: utils.c:3322
static const uint32_t mac_to_unicode[128]
Definition: mov.c:139
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:826
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:574
#define av_bswap32
Definition: bswap.h:33
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
int ff_get_qtpalette(int codec_id, AVIOContext *pb, uint32_t *palette)
Retrieve the palette (or "color table" in QuickTime terms), either from the video sample description...
Definition: qtpalette.c:31
unsigned duration
Definition: isom.h:96
Views are on top of each other.
Definition: stereo3d.h:79
MOVSbgp * rap_group
Definition: isom.h:212
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:364
const AVCodecTag ff_codec_movaudio_tags[]
Definition: isom.c:318
int duration
Definition: isom.h:58
static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6274
static void mov_read_chapters(AVFormatContext *s)
Definition: mov.c:6990
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
Definition: mov.c:2058
int * chapter_tracks
Definition: isom.h:262
unsigned int stsz_sample_size
always contains sample size from stsz atom
Definition: isom.h:180
static int read_tfra(MOVContext *mov, AVIOContext *f)
Definition: mov.c:7286
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
Public header for SHA-1 & SHA-256 hash function implementations.
static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:782
unsigned trex_count
Definition: isom.h:259
#define MOV_TRUN_FIRST_SAMPLE_FLAGS
Definition: isom.h:314
#define AV_CH_FRONT_LEFT
static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4288
timecode wraps after 24 hours
Definition: timecode.h:37
int enable_drefs
Definition: isom.h:289
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:45
static int64_t get_frag_time(MOVFragmentIndex *frag_index, int index, int track_id)
Definition: mov.c:1245
int64_t data_size
Definition: isom.h:207
static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5789
int has_looked_for_mfra
Definition: isom.h:276
void * buf
Definition: avisynth_c.h:766
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
uint32_t type
Definition: isom.h:74
int nb_index_entries
Definition: avformat.h:1112
unsigned int count
Definition: isom.h:57
MOVStts * stts_data
Definition: isom.h:165
double value
Definition: eval.c:98
MOVEncryptionIndex * encryption_index
Definition: isom.h:133
Describe the class of an AVClass context structure.
Definition: log.h:67
static int find_prev_closest_index(AVStream *st, AVIndexEntry *e_old, int nb_old, MOVStts *ctts_data, int64_t ctts_count, int64_t timestamp_pts, int flag, int64_t *index, int64_t *ctts_index, int64_t *ctts_sample)
Find the closest previous frame to the timestamp_pts, in e_old index entries.
Definition: mov.c:3130
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
int index
Definition: gxfenc.c:89
unsigned int bytes_of_protected_data
The number of bytes that are protected.
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
Rational number (pair of numerator and denominator).
Definition: rational.h:58
unsigned int aax_mode
&#39;aax&#39; file has been detected
Definition: isom.h:279
#define isnan(x)
Definition: libm.h:340
#define AV_DISPOSITION_TIMED_THUMBNAILS
The stream is sparse, and contains thumbnail images, often corresponding to chapter markers...
Definition: avformat.h:854
static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1708
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
static int mov_probe(const AVProbeData *p)
Definition: mov.c:6906
MOVFragment fragment
current fragment in moof atom
Definition: isom.h:257
AVFieldOrder
Definition: avcodec.h:1543
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
static void mov_estimate_video_delay(MOVContext *c, AVStream *st)
Definition: mov.c:3309
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1232
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:295
int64_t track_end
used for dts generation in fragmented movie files
Definition: isom.h:209
Definition: isom.h:82
static enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
Compute codec id for &#39;lpcm&#39; tag.
Definition: isom.h:370
int use_mfra_for
Definition: isom.h:275
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.h:145
static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
Definition: mov.c:2114
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len, char *dst, int dstlen)
Definition: mov.c:158
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:498
#define MOV_TFHD_DEFAULT_FLAGS
Definition: isom.h:309
static int mov_read_schm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6382
static int mov_read_tenc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6413
This side data contains encryption info for how to decrypt the packet.
Definition: avcodec.h:1399
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:2630
#define snprintf
Definition: snprintf.h:34
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:456
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4393
#define FF_MOV_FLAG_MFRA_AUTO
Definition: isom.h:362
int64_t time
Definition: isom.h:69
int pb_is_copied
Definition: isom.h:159
#define MOV_TRUN_SAMPLE_FLAGS
Definition: isom.h:317
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
#define TAG_IS_AVCI(tag)
Definition: isom.h:340
#define MOV_TFHD_STSD_ID
Definition: isom.h:306
static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2748
AVFormatContext * dv_fctx
Definition: isom.h:255
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:93
unsigned int stsc_index
Definition: isom.h:171
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
struct MOVStreamContext::@262 cenc
int seek_preroll
Audio only.
Definition: avcodec.h:4097
uint32_t subsample_count
uint64_t implicit_offset
Definition: isom.h:94
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVStereo3D * stereo3d
Definition: isom.h:225
static void mov_update_dts_shift(MOVStreamContext *sc, int duration)
Definition: mov.c:2961
unsigned int per_sample_iv_size
Definition: isom.h:237
static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4418
#define AV_CH_SIDE_RIGHT
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:84
unsigned * stps_data
partial sync sample for mpeg-2 open gop
Definition: isom.h:174
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:168
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:978
static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
Definition: mov.c:100
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1051
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
int64_t sidx_pts
Definition: isom.h:129
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: avcodec.h:4067
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1713
MPEG Audio header decoder.
int start_pad
amount of samples to skip due to enc-dec delay
Definition: isom.h:210
int trak_index
Index of the current &#39;trak&#39;.
Definition: isom.h:251
negative time values are allowed
Definition: timecode.h:38
full parsing and repack
Definition: avformat.h:800
Main libavformat public API header.
int32_t * display_matrix
Definition: isom.h:224
int
AVIOContext * pb
Definition: isom.h:158
static void fix_index_entry_timestamps(AVStream *st, int end_index, int64_t end_ts, int64_t *frame_duration_buffer, int frame_duration_buffer_size)
Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index) by subtracting end_ts successively by the amounts given in frame_duration_buffer.
Definition: mov.c:3266
static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
An strf atom is a BITMAPINFOHEADER struct.
Definition: mov.c:1953
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: avcodec.h:1516
unsigned int bytes_per_frame
Definition: isom.h:193
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
unsigned flags
Definition: isom.h:98
int bitrates_count
Definition: isom.h:273
uint8_t * key_id
The ID of the key used to encrypt the packet.
static int mov_read_rtmd_track(AVFormatContext *s, AVStream *st)
Definition: mov.c:7105
#define MOV_TFHD_BASE_DATA_OFFSET
Definition: isom.h:305
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int64_t size
Definition: isom.h:84
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
static int mov_read_smdm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5295
int export_xmp
Definition: isom.h:271
int seek_individually
Definition: isom.h:268
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:81
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
static const MOVParseTableEntry mov_default_parse_table[]
Definition: mov.c:6689
static int get_edit_list_entry(MOVContext *mov, const MOVStreamContext *msc, unsigned int edit_list_index, int64_t *edit_list_media_time, int64_t *edit_list_duration, int64_t global_timescale)
Get ith edit list entry (media time, duration).
Definition: mov.c:3088
static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st, uint32_t value, int flags)
Definition: mov.c:7091
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:920
#define flag(name)
Definition: cbs_av1.c:553
static double c[64]
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2891
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:920
unsigned int stps_count
Definition: isom.h:173
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3306
unsigned int chunk_count
Definition: isom.h:162
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
Stereoscopic video.
uint8_t * data
Key-system specific initialization data.
static int mov_codec_id(AVStream *st, uint32_t format)
Definition: mov.c:2023
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
int den
Denominator.
Definition: rational.h:60
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:347
int64_t start
Definition: isom.h:153
unsigned meta_keys_count
Definition: isom.h:253
static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
Definition: mov.c:231
#define MKBETAG(a, b, c, d)
Definition: common.h:367
static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1976
uint32_t palette[256]
Definition: isom.h:205
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
unsigned stsd_id
Definition: isom.h:95
static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
Definition: mov.c:7821
unsigned int index_entries_allocated_size
Definition: avformat.h:1113
MOVEncryptionIndex * encryption_index
Definition: isom.h:239
#define av_free(p)
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:475
static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index, int id, int entries)
Definition: mov.c:1355
static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
Definition: mov.c:2354
char * value
Definition: dict.h:87
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1698
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
as in Berlin toast format
Definition: avcodec.h:582
int len
static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom, enum AVCodecID codec_id)
Definition: mov.c:1667
unsigned int stts_count
Definition: isom.h:164
int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key)
Initialize an AVAESCTR context.
Definition: aes_ctr.c:69
unsigned int sample_size
may contain value calculated from stsd or value from stsz atom
Definition: isom.h:179
static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5475
uint32_t type
Definition: mov.c:71
void * priv_data
Format private data.
Definition: avformat.h:1386
static int mov_read_mfra(MOVContext *c, AVIOContext *f)
Definition: mov.c:7341
uint8_t file_iv[20]
Definition: isom.h:281
static const AVClass mov_class
Definition: mov.c:7993
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:167
static int64_t get_stream_info_time(MOVFragmentStreamInfo *frag_stream_info)
Definition: mov.c:1235
uint64_t layout
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3999
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
#define MOV_TRUN_DATA_OFFSET
Definition: isom.h:313
int64_t next_root_atom
offset of the next root atom
Definition: isom.h:269
int last_stsd_index
Definition: isom.h:220
unsigned int nb_encrypted_samples
Definition: isom.h:117
int channels
Audio only.
Definition: avcodec.h:4063
unsigned int nb_chapter_tracks
Definition: isom.h:263
int time_scale
Definition: isom.h:246
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1922
Definition: isom.h:67
int pseudo_stream_id
-1 means demux all ids
Definition: isom.h:196
#define AV_CH_FRONT_RIGHT
static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom, AVCodecParameters *par, uint8_t *buf)
Definition: mov.c:1645
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1473
int ffindex
AVStream index.
Definition: isom.h:160
uint8_t ** extradata
extradata array (and size) for multiple stsd
Definition: isom.h:218
FILE * out
Definition: movenc.c:54
int use_absolute_path
Definition: isom.h:264
AVEncryptionInfo * av_encryption_info_alloc(uint32_t subsample_count, uint32_t key_id_size, uint32_t iv_size)
Allocates an AVEncryptionInfo structure and sub-pointers to hold the given number of subsamples...
#define av_freep(p)
void INT64 INT64 count
Definition: avisynth_c.h:766
static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:4622
void INT64 start
Definition: avisynth_c.h:766
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2622
static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
Definition: mov.c:3388
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
unsigned size
Definition: isom.h:97
#define av_malloc_array(a, b)
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:879
void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t *iv)
Forcefully change the "full" 16-byte iv, including the counter.
Definition: aes_ctr.c:48
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:358
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:1693
int64_t duration_for_fps
Definition: isom.h:215
#define AV_CH_SIDE_LEFT
#define FFSWAP(type, a, b)
Definition: common.h:99
const char int length
Definition: avisynth_c.h:860
static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:2797
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
int stream_index
Definition: avcodec.h:1479
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:113
#define MKTAG(a, b, c, d)
Definition: common.h:366
int moov_retry
Definition: isom.h:274
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:936
static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
Definition: mov.c:4149
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
#define ID3v1_GENRE_MAX
Definition: id3v1.h:29
const char *const ff_id3v1_genre_str[ID3v1_GENRE_MAX+1]
ID3v1 genres.
Definition: id3v1.c:27
enum AVCodecID id
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
Definition: avcodec.h:1454
static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:3038
size_t auxiliary_info_sample_count
Definition: isom.h:121
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
int found_hdlr_mdta
&#39;hdlr&#39; atom with type &#39;mdta&#39; has been found
Definition: isom.h:250
int has_sidx
Definition: isom.h:234
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:963
uint8_t * system_id
A unique identifier for the key system this is for, can be NULL if it is not known.
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
Definition: isom.h:73
static uint32_t yuv_to_rgba(uint32_t ycbcr)
Definition: mov.c:2237
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
#define MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC
Definition: isom.h:321
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: avcodec.h:1264
static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6179