FFmpeg  4.2.1
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 = avio_rl32(pb);
4422  atom.size -= 4;
4423  if (tag == MKTAG('h','d','l','r')) {
4424  avio_seek(pb, -8, SEEK_CUR);
4425  atom.size += 8;
4426  return mov_read_default(c, pb, atom);
4427  }
4428  }
4429  return 0;
4430 }
4431 
4432 // return 1 when matrix is identity, 0 otherwise
4433 #define IS_MATRIX_IDENT(matrix) \
4434  ( (matrix)[0][0] == (1 << 16) && \
4435  (matrix)[1][1] == (1 << 16) && \
4436  (matrix)[2][2] == (1 << 30) && \
4437  !(matrix)[0][1] && !(matrix)[0][2] && \
4438  !(matrix)[1][0] && !(matrix)[1][2] && \
4439  !(matrix)[2][0] && !(matrix)[2][1])
4440 
4442 {
4443  int i, j, e;
4444  int width;
4445  int height;
4446  int display_matrix[3][3];
4447  int res_display_matrix[3][3] = { { 0 } };
4448  AVStream *st;
4449  MOVStreamContext *sc;
4450  int version;
4451  int flags;
4452 
4453  if (c->fc->nb_streams < 1)
4454  return 0;
4455  st = c->fc->streams[c->fc->nb_streams-1];
4456  sc = st->priv_data;
4457 
4458  // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
4459  // avoids corrupting AVStreams mapped to an earlier tkhd.
4460  if (st->id != -1)
4461  return AVERROR_INVALIDDATA;
4462 
4463  version = avio_r8(pb);
4464  flags = avio_rb24(pb);
4466 
4467  if (version == 1) {
4468  avio_rb64(pb);
4469  avio_rb64(pb);
4470  } else {
4471  avio_rb32(pb); /* creation time */
4472  avio_rb32(pb); /* modification time */
4473  }
4474  st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
4475  avio_rb32(pb); /* reserved */
4476 
4477  /* highlevel (considering edits) duration in movie timebase */
4478  (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
4479  avio_rb32(pb); /* reserved */
4480  avio_rb32(pb); /* reserved */
4481 
4482  avio_rb16(pb); /* layer */
4483  avio_rb16(pb); /* alternate group */
4484  avio_rb16(pb); /* volume */
4485  avio_rb16(pb); /* reserved */
4486 
4487  //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
4488  // they're kept in fixed point format through all calculations
4489  // save u,v,z to store the whole matrix in the AV_PKT_DATA_DISPLAYMATRIX
4490  // side data, but the scale factor is not needed to calculate aspect ratio
4491  for (i = 0; i < 3; i++) {
4492  display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
4493  display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
4494  display_matrix[i][2] = avio_rb32(pb); // 2.30 fixed point
4495  }
4496 
4497  width = avio_rb32(pb); // 16.16 fixed point track width
4498  height = avio_rb32(pb); // 16.16 fixed point track height
4499  sc->width = width >> 16;
4500  sc->height = height >> 16;
4501 
4502  // apply the moov display matrix (after the tkhd one)
4503  for (i = 0; i < 3; i++) {
4504  const int sh[3] = { 16, 16, 30 };
4505  for (j = 0; j < 3; j++) {
4506  for (e = 0; e < 3; e++) {
4507  res_display_matrix[i][j] +=
4508  ((int64_t) display_matrix[i][e] *
4509  c->movie_display_matrix[e][j]) >> sh[e];
4510  }
4511  }
4512  }
4513 
4514  // save the matrix when it is not the default identity
4515  if (!IS_MATRIX_IDENT(res_display_matrix)) {
4516  double rotate;
4517 
4518  av_freep(&sc->display_matrix);
4519  sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
4520  if (!sc->display_matrix)
4521  return AVERROR(ENOMEM);
4522 
4523  for (i = 0; i < 3; i++)
4524  for (j = 0; j < 3; j++)
4525  sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
4526 
4529  if (!isnan(rotate)) {
4530  char rotate_buf[64];
4531  rotate = -rotate;
4532  if (rotate < 0) // for backward compatibility
4533  rotate += 360;
4534  snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
4535  av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
4536  }
4537 #endif
4538  }
4539 
4540  // transform the display width/height according to the matrix
4541  // to keep the same scale, use [width height 1<<16]
4542  if (width && height && sc->display_matrix) {
4543  double disp_transform[2];
4544 
4545  for (i = 0; i < 2; i++)
4546  disp_transform[i] = hypot(sc->display_matrix[0 + i],
4547  sc->display_matrix[3 + i]);
4548 
4549  if (disp_transform[0] > 0 && disp_transform[1] > 0 &&
4550  disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4551  fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4553  disp_transform[0] / disp_transform[1],
4554  INT_MAX);
4555  }
4556  return 0;
4557 }
4558 
4560 {
4561  MOVFragment *frag = &c->fragment;
4562  MOVTrackExt *trex = NULL;
4563  int flags, track_id, i;
4564 
4565  avio_r8(pb); /* version */
4566  flags = avio_rb24(pb);
4567 
4568  track_id = avio_rb32(pb);
4569  if (!track_id)
4570  return AVERROR_INVALIDDATA;
4571  for (i = 0; i < c->trex_count; i++)
4572  if (c->trex_data[i].track_id == track_id) {
4573  trex = &c->trex_data[i];
4574  break;
4575  }
4576  if (!trex) {
4577  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding trex (id %u)\n", track_id);
4578  return 0;
4579  }
4580  c->fragment.found_tfhd = 1;
4581  frag->track_id = track_id;
4582  set_frag_stream(&c->frag_index, track_id);
4583 
4586  frag->moof_offset : frag->implicit_offset;
4587  frag->stsd_id = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
4588 
4589  frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
4590  avio_rb32(pb) : trex->duration;
4591  frag->size = flags & MOV_TFHD_DEFAULT_SIZE ?
4592  avio_rb32(pb) : trex->size;
4593  frag->flags = flags & MOV_TFHD_DEFAULT_FLAGS ?
4594  avio_rb32(pb) : trex->flags;
4595  av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
4596 
4597  return 0;
4598 }
4599 
4601 {
4602  unsigned i, num;
4603  void *new_tracks;
4604 
4605  num = atom.size / 4;
4606  if (!(new_tracks = av_malloc_array(num, sizeof(int))))
4607  return AVERROR(ENOMEM);
4608 
4609  av_free(c->chapter_tracks);
4610  c->chapter_tracks = new_tracks;
4611  c->nb_chapter_tracks = num;
4612 
4613  for (i = 0; i < num && !pb->eof_reached; i++)
4614  c->chapter_tracks[i] = avio_rb32(pb);
4615 
4616  return 0;
4617 }
4618 
4620 {
4621  MOVTrackExt *trex;
4622  int err;
4623 
4624  if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
4625  return AVERROR_INVALIDDATA;
4626  if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
4627  sizeof(*c->trex_data))) < 0) {
4628  c->trex_count = 0;
4629  return err;
4630  }
4631 
4632  c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
4633 
4634  trex = &c->trex_data[c->trex_count++];
4635  avio_r8(pb); /* version */
4636  avio_rb24(pb); /* flags */
4637  trex->track_id = avio_rb32(pb);
4638  trex->stsd_id = avio_rb32(pb);
4639  trex->duration = avio_rb32(pb);
4640  trex->size = avio_rb32(pb);
4641  trex->flags = avio_rb32(pb);
4642  return 0;
4643 }
4644 
4646 {
4647  MOVFragment *frag = &c->fragment;
4648  AVStream *st = NULL;
4649  MOVStreamContext *sc;
4650  int version, i;
4651  MOVFragmentStreamInfo * frag_stream_info;
4652  int64_t base_media_decode_time;
4653 
4654  for (i = 0; i < c->fc->nb_streams; i++) {
4655  if (c->fc->streams[i]->id == frag->track_id) {
4656  st = c->fc->streams[i];
4657  break;
4658  }
4659  }
4660  if (!st) {
4661  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4662  return 0;
4663  }
4664  sc = st->priv_data;
4665  if (sc->pseudo_stream_id + 1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4666  return 0;
4667  version = avio_r8(pb);
4668  avio_rb24(pb); /* flags */
4669  if (version) {
4670  base_media_decode_time = avio_rb64(pb);
4671  } else {
4672  base_media_decode_time = avio_rb32(pb);
4673  }
4674 
4675  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4676  if (frag_stream_info)
4677  frag_stream_info->tfdt_dts = base_media_decode_time;
4678  sc->track_end = base_media_decode_time;
4679 
4680  return 0;
4681 }
4682 
4684 {
4685  MOVFragment *frag = &c->fragment;
4686  AVStream *st = NULL;
4687  MOVStreamContext *sc;
4688  MOVStts *ctts_data;
4689  uint64_t offset;
4690  int64_t dts, pts = AV_NOPTS_VALUE;
4691  int data_offset = 0;
4692  unsigned entries, first_sample_flags = frag->flags;
4693  int flags, distance, i;
4694  int64_t prev_dts = AV_NOPTS_VALUE;
4695  int next_frag_index = -1, index_entry_pos;
4696  size_t requested_size;
4697  size_t old_ctts_allocated_size;
4698  AVIndexEntry *new_entries;
4699  MOVFragmentStreamInfo * frag_stream_info;
4700 
4701  if (!frag->found_tfhd) {
4702  av_log(c->fc, AV_LOG_ERROR, "trun track id unknown, no tfhd was found\n");
4703  return AVERROR_INVALIDDATA;
4704  }
4705 
4706  for (i = 0; i < c->fc->nb_streams; i++) {
4707  if (c->fc->streams[i]->id == frag->track_id) {
4708  st = c->fc->streams[i];
4709  break;
4710  }
4711  }
4712  if (!st) {
4713  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4714  return 0;
4715  }
4716  sc = st->priv_data;
4717  if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4718  return 0;
4719 
4720  // Find the next frag_index index that has a valid index_entry for
4721  // the current track_id.
4722  //
4723  // A valid index_entry means the trun for the fragment was read
4724  // and it's samples are in index_entries at the given position.
4725  // New index entries will be inserted before the index_entry found.
4726  index_entry_pos = st->nb_index_entries;
4727  for (i = c->frag_index.current + 1; i < c->frag_index.nb_items; i++) {
4728  frag_stream_info = get_frag_stream_info(&c->frag_index, i, frag->track_id);
4729  if (frag_stream_info && frag_stream_info->index_entry >= 0) {
4730  next_frag_index = i;
4731  index_entry_pos = frag_stream_info->index_entry;
4732  break;
4733  }
4734  }
4735  av_assert0(index_entry_pos <= st->nb_index_entries);
4736 
4737  avio_r8(pb); /* version */
4738  flags = avio_rb24(pb);
4739  entries = avio_rb32(pb);
4740  av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
4741 
4742  if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
4743  return AVERROR_INVALIDDATA;
4744  if (flags & MOV_TRUN_DATA_OFFSET) data_offset = avio_rb32(pb);
4745  if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
4746 
4747  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4748  if (frag_stream_info)
4749  {
4750  if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
4752  pts = frag_stream_info->first_tfra_pts;
4753  av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
4754  ", using it for pts\n", pts);
4755  } else if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE) {
4756  // FIXME: sidx earliest_presentation_time is *PTS*, s.b.
4757  // pts = frag_stream_info->sidx_pts;
4758  dts = frag_stream_info->sidx_pts - sc->time_offset;
4759  av_log(c->fc, AV_LOG_DEBUG, "found sidx time %"PRId64
4760  ", using it for pts\n", pts);
4761  } else if (frag_stream_info->tfdt_dts != AV_NOPTS_VALUE) {
4762  dts = frag_stream_info->tfdt_dts - sc->time_offset;
4763  av_log(c->fc, AV_LOG_DEBUG, "found tfdt time %"PRId64
4764  ", using it for dts\n", dts);
4765  } else {
4766  dts = sc->track_end - sc->time_offset;
4767  av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4768  ", using it for dts\n", dts);
4769  }
4770  } else {
4771  dts = sc->track_end - sc->time_offset;
4772  av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4773  ", using it for dts\n", dts);
4774  }
4775  offset = frag->base_data_offset + data_offset;
4776  distance = 0;
4777  av_log(c->fc, AV_LOG_TRACE, "first sample flags 0x%x\n", first_sample_flags);
4778 
4779  // realloc space for new index entries
4780  if((uint64_t)st->nb_index_entries + entries >= UINT_MAX / sizeof(AVIndexEntry)) {
4781  entries = UINT_MAX / sizeof(AVIndexEntry) - st->nb_index_entries;
4782  av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n");
4783  }
4784  if (entries <= 0)
4785  return -1;
4786 
4787  requested_size = (st->nb_index_entries + entries) * sizeof(AVIndexEntry);
4788  new_entries = av_fast_realloc(st->index_entries,
4790  requested_size);
4791  if(!new_entries)
4792  return AVERROR(ENOMEM);
4793  st->index_entries= new_entries;
4794 
4795  requested_size = (st->nb_index_entries + entries) * sizeof(*sc->ctts_data);
4796  old_ctts_allocated_size = sc->ctts_allocated_size;
4797  ctts_data = av_fast_realloc(sc->ctts_data, &sc->ctts_allocated_size,
4798  requested_size);
4799  if (!ctts_data)
4800  return AVERROR(ENOMEM);
4801  sc->ctts_data = ctts_data;
4802 
4803  // In case there were samples without ctts entries, ensure they get
4804  // zero valued entries. This ensures clips which mix boxes with and
4805  // without ctts entries don't pickup uninitialized data.
4806  memset((uint8_t*)(sc->ctts_data) + old_ctts_allocated_size, 0,
4807  sc->ctts_allocated_size - old_ctts_allocated_size);
4808 
4809  if (index_entry_pos < st->nb_index_entries) {
4810  // Make hole in index_entries and ctts_data for new samples
4811  memmove(st->index_entries + index_entry_pos + entries,
4812  st->index_entries + index_entry_pos,
4813  sizeof(*st->index_entries) *
4814  (st->nb_index_entries - index_entry_pos));
4815  memmove(sc->ctts_data + index_entry_pos + entries,
4816  sc->ctts_data + index_entry_pos,
4817  sizeof(*sc->ctts_data) * (sc->ctts_count - index_entry_pos));
4818  if (index_entry_pos < sc->current_sample) {
4819  sc->current_sample += entries;
4820  }
4821  }
4822 
4823  st->nb_index_entries += entries;
4824  sc->ctts_count = st->nb_index_entries;
4825 
4826  // Record the index_entry position in frag_index of this fragment
4827  if (frag_stream_info)
4828  frag_stream_info->index_entry = index_entry_pos;
4829 
4830  if (index_entry_pos > 0)
4831  prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4832 
4833  for (i = 0; i < entries && !pb->eof_reached; i++) {
4834  unsigned sample_size = frag->size;
4835  int sample_flags = i ? frag->flags : first_sample_flags;
4836  unsigned sample_duration = frag->duration;
4837  unsigned ctts_duration = 0;
4838  int keyframe = 0;
4839  int index_entry_flags = 0;
4840 
4841  if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
4842  if (flags & MOV_TRUN_SAMPLE_SIZE) sample_size = avio_rb32(pb);
4843  if (flags & MOV_TRUN_SAMPLE_FLAGS) sample_flags = avio_rb32(pb);
4844  if (flags & MOV_TRUN_SAMPLE_CTS) ctts_duration = avio_rb32(pb);
4845 
4846  mov_update_dts_shift(sc, ctts_duration);
4847  if (pts != AV_NOPTS_VALUE) {
4848  dts = pts - sc->dts_shift;
4849  if (flags & MOV_TRUN_SAMPLE_CTS) {
4850  dts -= ctts_duration;
4851  } else {
4852  dts -= sc->time_offset;
4853  }
4854  av_log(c->fc, AV_LOG_DEBUG,
4855  "pts %"PRId64" calculated dts %"PRId64
4856  " sc->dts_shift %d ctts.duration %d"
4857  " sc->time_offset %"PRId64
4858  " flags & MOV_TRUN_SAMPLE_CTS %d\n",
4859  pts, dts,
4860  sc->dts_shift, ctts_duration,
4861  sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
4862  pts = AV_NOPTS_VALUE;
4863  }
4864 
4866  keyframe = 1;
4867  else
4868  keyframe =
4869  !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
4871  if (keyframe) {
4872  distance = 0;
4873  index_entry_flags |= AVINDEX_KEYFRAME;
4874  }
4875  // Fragments can overlap in time. Discard overlapping frames after
4876  // decoding.
4877  if (prev_dts >= dts)
4878  index_entry_flags |= AVINDEX_DISCARD_FRAME;
4879 
4880  st->index_entries[index_entry_pos].pos = offset;
4881  st->index_entries[index_entry_pos].timestamp = dts;
4882  st->index_entries[index_entry_pos].size= sample_size;
4883  st->index_entries[index_entry_pos].min_distance= distance;
4884  st->index_entries[index_entry_pos].flags = index_entry_flags;
4885 
4886  sc->ctts_data[index_entry_pos].count = 1;
4887  sc->ctts_data[index_entry_pos].duration = ctts_duration;
4888  index_entry_pos++;
4889 
4890  av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
4891  "size %u, distance %d, keyframe %d\n", st->index,
4892  index_entry_pos, offset, dts, sample_size, distance, keyframe);
4893  distance++;
4894  dts += sample_duration;
4895  offset += sample_size;
4896  sc->data_size += sample_size;
4897 
4898  if (sample_duration <= INT64_MAX - sc->duration_for_fps &&
4899  1 <= INT_MAX - sc->nb_frames_for_fps
4900  ) {
4901  sc->duration_for_fps += sample_duration;
4902  sc->nb_frames_for_fps ++;
4903  }
4904  }
4905  if (i < entries) {
4906  // EOF found before reading all entries. Fix the hole this would
4907  // leave in index_entries and ctts_data
4908  int gap = entries - i;
4909  memmove(st->index_entries + index_entry_pos,
4910  st->index_entries + index_entry_pos + gap,
4911  sizeof(*st->index_entries) *
4912  (st->nb_index_entries - (index_entry_pos + gap)));
4913  memmove(sc->ctts_data + index_entry_pos,
4914  sc->ctts_data + index_entry_pos + gap,
4915  sizeof(*sc->ctts_data) *
4916  (sc->ctts_count - (index_entry_pos + gap)));
4917 
4918  st->nb_index_entries -= gap;
4919  sc->ctts_count -= gap;
4920  if (index_entry_pos < sc->current_sample) {
4921  sc->current_sample -= gap;
4922  }
4923  entries = i;
4924  }
4925 
4926  // The end of this new fragment may overlap in time with the start
4927  // of the next fragment in index_entries. Mark the samples in the next
4928  // fragment that overlap with AVINDEX_DISCARD_FRAME
4929  prev_dts = AV_NOPTS_VALUE;
4930  if (index_entry_pos > 0)
4931  prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4932  for (i = index_entry_pos; i < st->nb_index_entries; i++) {
4933  if (prev_dts < st->index_entries[i].timestamp)
4934  break;
4936  }
4937 
4938  // If a hole was created to insert the new index_entries into,
4939  // the index_entry recorded for all subsequent moof must
4940  // be incremented by the number of entries inserted.
4941  fix_frag_index_entries(&c->frag_index, next_frag_index,
4942  frag->track_id, entries);
4943 
4944  if (pb->eof_reached) {
4945  av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted TRUN atom\n");
4946  return AVERROR_EOF;
4947  }
4948 
4949  frag->implicit_offset = offset;
4950 
4951  sc->track_end = dts + sc->time_offset;
4952  if (st->duration < sc->track_end)
4953  st->duration = sc->track_end;
4954 
4955  return 0;
4956 }
4957 
4959 {
4960  int64_t offset = avio_tell(pb) + atom.size, pts, timestamp;
4961  uint8_t version;
4962  unsigned i, j, track_id, item_count;
4963  AVStream *st = NULL;
4964  AVStream *ref_st = NULL;
4965  MOVStreamContext *sc, *ref_sc = NULL;
4966  AVRational timescale;
4967 
4968  version = avio_r8(pb);
4969  if (version > 1) {
4970  avpriv_request_sample(c->fc, "sidx version %u", version);
4971  return 0;
4972  }
4973 
4974  avio_rb24(pb); // flags
4975 
4976  track_id = avio_rb32(pb); // Reference ID
4977  for (i = 0; i < c->fc->nb_streams; i++) {
4978  if (c->fc->streams[i]->id == track_id) {
4979  st = c->fc->streams[i];
4980  break;
4981  }
4982  }
4983  if (!st) {
4984  av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %d\n", track_id);
4985  return 0;
4986  }
4987 
4988  sc = st->priv_data;
4989 
4990  timescale = av_make_q(1, avio_rb32(pb));
4991 
4992  if (timescale.den <= 0) {
4993  av_log(c->fc, AV_LOG_ERROR, "Invalid sidx timescale 1/%d\n", timescale.den);
4994  return AVERROR_INVALIDDATA;
4995  }
4996 
4997  if (version == 0) {
4998  pts = avio_rb32(pb);
4999  offset += avio_rb32(pb);
5000  } else {
5001  pts = avio_rb64(pb);
5002  offset += avio_rb64(pb);
5003  }
5004 
5005  avio_rb16(pb); // reserved
5006 
5007  item_count = avio_rb16(pb);
5008 
5009  for (i = 0; i < item_count; i++) {
5010  int index;
5011  MOVFragmentStreamInfo * frag_stream_info;
5012  uint32_t size = avio_rb32(pb);
5013  uint32_t duration = avio_rb32(pb);
5014  if (size & 0x80000000) {
5015  avpriv_request_sample(c->fc, "sidx reference_type 1");
5016  return AVERROR_PATCHWELCOME;
5017  }
5018  avio_rb32(pb); // sap_flags
5019  timestamp = av_rescale_q(pts, st->time_base, timescale);
5020 
5021  index = update_frag_index(c, offset);
5022  frag_stream_info = get_frag_stream_info(&c->frag_index, index, track_id);
5023  if (frag_stream_info)
5024  frag_stream_info->sidx_pts = timestamp;
5025 
5026  offset += size;
5027  pts += duration;
5028  }
5029 
5030  st->duration = sc->track_end = pts;
5031 
5032  sc->has_sidx = 1;
5033 
5034  if (offset == avio_size(pb)) {
5035  // Find first entry in fragment index that came from an sidx.
5036  // This will pretty much always be the first entry.
5037  for (i = 0; i < c->frag_index.nb_items; i++) {
5038  MOVFragmentIndexItem * item = &c->frag_index.item[i];
5039  for (j = 0; ref_st == NULL && j < item->nb_stream_info; j++) {
5040  MOVFragmentStreamInfo * si;
5041  si = &item->stream_info[j];
5042  if (si->sidx_pts != AV_NOPTS_VALUE) {
5043  ref_st = c->fc->streams[j];
5044  ref_sc = ref_st->priv_data;
5045  break;
5046  }
5047  }
5048  }
5049  if (ref_st) for (i = 0; i < c->fc->nb_streams; i++) {
5050  st = c->fc->streams[i];
5051  sc = st->priv_data;
5052  if (!sc->has_sidx) {
5053  st->duration = sc->track_end = av_rescale(ref_st->duration, sc->time_scale, ref_sc->time_scale);
5054  }
5055  }
5056 
5057  c->frag_index.complete = 1;
5058  }
5059 
5060  return 0;
5061 }
5062 
5063 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
5064 /* like the files created with Adobe Premiere 5.0, for samples see */
5065 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
5067 {
5068  int err;
5069 
5070  if (atom.size < 8)
5071  return 0; /* continue */
5072  if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
5073  avio_skip(pb, atom.size - 4);
5074  return 0;
5075  }
5076  atom.type = avio_rl32(pb);
5077  atom.size -= 8;
5078  if (atom.type != MKTAG('m','d','a','t')) {
5079  avio_skip(pb, atom.size);
5080  return 0;
5081  }
5082  err = mov_read_mdat(c, pb, atom);
5083  return err;
5084 }
5085 
5087 {
5088 #if CONFIG_ZLIB
5089  AVIOContext ctx;
5090  uint8_t *cmov_data;
5091  uint8_t *moov_data; /* uncompressed data */
5092  long cmov_len, moov_len;
5093  int ret = -1;
5094 
5095  avio_rb32(pb); /* dcom atom */
5096  if (avio_rl32(pb) != MKTAG('d','c','o','m'))
5097  return AVERROR_INVALIDDATA;
5098  if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
5099  av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
5100  return AVERROR_INVALIDDATA;
5101  }
5102  avio_rb32(pb); /* cmvd atom */
5103  if (avio_rl32(pb) != MKTAG('c','m','v','d'))
5104  return AVERROR_INVALIDDATA;
5105  moov_len = avio_rb32(pb); /* uncompressed size */
5106  cmov_len = atom.size - 6 * 4;
5107 
5108  cmov_data = av_malloc(cmov_len);
5109  if (!cmov_data)
5110  return AVERROR(ENOMEM);
5111  moov_data = av_malloc(moov_len);
5112  if (!moov_data) {
5113  av_free(cmov_data);
5114  return AVERROR(ENOMEM);
5115  }
5116  ret = ffio_read_size(pb, cmov_data, cmov_len);
5117  if (ret < 0)
5118  goto free_and_return;
5119 
5120  ret = AVERROR_INVALIDDATA;
5121  if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
5122  goto free_and_return;
5123  if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
5124  goto free_and_return;
5126  atom.type = MKTAG('m','o','o','v');
5127  atom.size = moov_len;
5128  ret = mov_read_default(c, &ctx, atom);
5129 free_and_return:
5130  av_free(moov_data);
5131  av_free(cmov_data);
5132  return ret;
5133 #else
5134  av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
5135  return AVERROR(ENOSYS);
5136 #endif
5137 }
5138 
5139 /* edit list atom */
5141 {
5142  MOVStreamContext *sc;
5143  int i, edit_count, version;
5144  int64_t elst_entry_size;
5145 
5146  if (c->fc->nb_streams < 1 || c->ignore_editlist)
5147  return 0;
5148  sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
5149 
5150  version = avio_r8(pb); /* version */
5151  avio_rb24(pb); /* flags */
5152  edit_count = avio_rb32(pb); /* entries */
5153  atom.size -= 8;
5154 
5155  elst_entry_size = version == 1 ? 20 : 12;
5156  if (atom.size != edit_count * elst_entry_size) {
5158  av_log(c->fc, AV_LOG_ERROR, "Invalid edit list entry_count: %d for elst atom of size: %"PRId64" bytes.\n",
5159  edit_count, atom.size + 8);
5160  return AVERROR_INVALIDDATA;
5161  } else {
5162  edit_count = atom.size / elst_entry_size;
5163  if (edit_count * elst_entry_size != atom.size) {
5164  av_log(c->fc, AV_LOG_WARNING, "ELST atom of %"PRId64" bytes, bigger than %d entries.", atom.size, edit_count);
5165  }
5166  }
5167  }
5168 
5169  if (!edit_count)
5170  return 0;
5171  if (sc->elst_data)
5172  av_log(c->fc, AV_LOG_WARNING, "Duplicated ELST atom\n");
5173  av_free(sc->elst_data);
5174  sc->elst_count = 0;
5175  sc->elst_data = av_malloc_array(edit_count, sizeof(*sc->elst_data));
5176  if (!sc->elst_data)
5177  return AVERROR(ENOMEM);
5178 
5179  av_log(c->fc, AV_LOG_TRACE, "track[%u].edit_count = %i\n", c->fc->nb_streams - 1, edit_count);
5180  for (i = 0; i < edit_count && atom.size > 0 && !pb->eof_reached; i++) {
5181  MOVElst *e = &sc->elst_data[i];
5182 
5183  if (version == 1) {
5184  e->duration = avio_rb64(pb);
5185  e->time = avio_rb64(pb);
5186  atom.size -= 16;
5187  } else {
5188  e->duration = avio_rb32(pb); /* segment duration */
5189  e->time = (int32_t)avio_rb32(pb); /* media time */
5190  atom.size -= 8;
5191  }
5192  e->rate = avio_rb32(pb) / 65536.0;
5193  atom.size -= 4;
5194  av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
5195  e->duration, e->time, e->rate);
5196 
5197  if (e->time < 0 && e->time != -1 &&
5199  av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list media time=%"PRId64"\n",
5200  c->fc->nb_streams-1, i, e->time);
5201  return AVERROR_INVALIDDATA;
5202  }
5203  }
5204  sc->elst_count = i;
5205 
5206  return 0;
5207 }
5208 
5210 {
5211  MOVStreamContext *sc;
5212 
5213  if (c->fc->nb_streams < 1)
5214  return AVERROR_INVALIDDATA;
5215  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5216  sc->timecode_track = avio_rb32(pb);
5217  return 0;
5218 }
5219 
5221 {
5222  AVStream *st;
5223  int ret;
5224 
5225  if (c->fc->nb_streams < 1)
5226  return 0;
5227  st = c->fc->streams[c->fc->nb_streams - 1];
5228 
5229  if (atom.size < 4) {
5230  av_log(c->fc, AV_LOG_ERROR, "Empty AV1 Codec Configuration Box\n");
5231  return AVERROR_INVALIDDATA;
5232  }
5233 
5234  /* For now, propagate only the OBUs, if any. Once libavcodec is
5235  updated to handle isobmff style extradata this can be removed. */
5236  avio_skip(pb, 4);
5237 
5238  if (atom.size == 4)
5239  return 0;
5240 
5241  ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 4);
5242  if (ret < 0)
5243  return ret;
5244 
5245  return 0;
5246 }
5247 
5249 {
5250  AVStream *st;
5251  int version, color_range, color_primaries, color_trc, color_space;
5252 
5253  if (c->fc->nb_streams < 1)
5254  return 0;
5255  st = c->fc->streams[c->fc->nb_streams - 1];
5256 
5257  if (atom.size < 5) {
5258  av_log(c->fc, AV_LOG_ERROR, "Empty VP Codec Configuration box\n");
5259  return AVERROR_INVALIDDATA;
5260  }
5261 
5262  version = avio_r8(pb);
5263  if (version != 1) {
5264  av_log(c->fc, AV_LOG_WARNING, "Unsupported VP Codec Configuration box version %d\n", version);
5265  return 0;
5266  }
5267  avio_skip(pb, 3); /* flags */
5268 
5269  avio_skip(pb, 2); /* profile + level */
5270  color_range = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
5271  color_primaries = avio_r8(pb);
5272  color_trc = avio_r8(pb);
5273  color_space = avio_r8(pb);
5274  if (avio_rb16(pb)) /* codecIntializationDataSize */
5275  return AVERROR_INVALIDDATA;
5276 
5277  if (!av_color_primaries_name(color_primaries))
5278  color_primaries = AVCOL_PRI_UNSPECIFIED;
5279  if (!av_color_transfer_name(color_trc))
5280  color_trc = AVCOL_TRC_UNSPECIFIED;
5281  if (!av_color_space_name(color_space))
5282  color_space = AVCOL_SPC_UNSPECIFIED;
5283 
5284  st->codecpar->color_range = (color_range & 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
5286  st->codecpar->color_trc = color_trc;
5287  st->codecpar->color_space = color_space;
5288 
5289  return 0;
5290 }
5291 
5293 {
5294  MOVStreamContext *sc;
5295  int i, version;
5296 
5297  if (c->fc->nb_streams < 1)
5298  return AVERROR_INVALIDDATA;
5299 
5300  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5301 
5302  if (atom.size < 5) {
5303  av_log(c->fc, AV_LOG_ERROR, "Empty Mastering Display Metadata box\n");
5304  return AVERROR_INVALIDDATA;
5305  }
5306 
5307  version = avio_r8(pb);
5308  if (version) {
5309  av_log(c->fc, AV_LOG_WARNING, "Unsupported Mastering Display Metadata box version %d\n", version);
5310  return 0;
5311  }
5312  avio_skip(pb, 3); /* flags */
5313 
5315  if (!sc->mastering)
5316  return AVERROR(ENOMEM);
5317 
5318  for (i = 0; i < 3; i++) {
5319  sc->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), 1 << 16);
5320  sc->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), 1 << 16);
5321  }
5322  sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), 1 << 16);
5323  sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), 1 << 16);
5324 
5325  sc->mastering->max_luminance = av_make_q(avio_rb32(pb), 1 << 8);
5326  sc->mastering->min_luminance = av_make_q(avio_rb32(pb), 1 << 14);
5327 
5328  sc->mastering->has_primaries = 1;
5329  sc->mastering->has_luminance = 1;
5330 
5331  return 0;
5332 }
5333 
5335 {
5336  MOVStreamContext *sc;
5337  const int mapping[3] = {1, 2, 0};
5338  const int chroma_den = 50000;
5339  const int luma_den = 10000;
5340  int i;
5341 
5342  if (c->fc->nb_streams < 1)
5343  return AVERROR_INVALIDDATA;
5344 
5345  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5346 
5347  if (atom.size < 24) {
5348  av_log(c->fc, AV_LOG_ERROR, "Invalid Mastering Display Color Volume box\n");
5349  return AVERROR_INVALIDDATA;
5350  }
5351 
5353  if (!sc->mastering)
5354  return AVERROR(ENOMEM);
5355 
5356  for (i = 0; i < 3; i++) {
5357  const int j = mapping[i];
5358  sc->mastering->display_primaries[j][0] = av_make_q(avio_rb16(pb), chroma_den);
5359  sc->mastering->display_primaries[j][1] = av_make_q(avio_rb16(pb), chroma_den);
5360  }
5361  sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), chroma_den);
5362  sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), chroma_den);
5363 
5364  sc->mastering->max_luminance = av_make_q(avio_rb32(pb), luma_den);
5365  sc->mastering->min_luminance = av_make_q(avio_rb32(pb), luma_den);
5366 
5367  sc->mastering->has_luminance = 1;
5368  sc->mastering->has_primaries = 1;
5369 
5370  return 0;
5371 }
5372 
5374 {
5375  MOVStreamContext *sc;
5376  int version;
5377 
5378  if (c->fc->nb_streams < 1)
5379  return AVERROR_INVALIDDATA;
5380 
5381  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5382 
5383  if (atom.size < 5) {
5384  av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level box\n");
5385  return AVERROR_INVALIDDATA;
5386  }
5387 
5388  version = avio_r8(pb);
5389  if (version) {
5390  av_log(c->fc, AV_LOG_WARNING, "Unsupported Content Light Level box version %d\n", version);
5391  return 0;
5392  }
5393  avio_skip(pb, 3); /* flags */
5394 
5396  if (!sc->coll)
5397  return AVERROR(ENOMEM);
5398 
5399  sc->coll->MaxCLL = avio_rb16(pb);
5400  sc->coll->MaxFALL = avio_rb16(pb);
5401 
5402  return 0;
5403 }
5404 
5406 {
5407  MOVStreamContext *sc;
5408 
5409  if (c->fc->nb_streams < 1)
5410  return AVERROR_INVALIDDATA;
5411 
5412  sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5413 
5414  if (atom.size < 4) {
5415  av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level Info box\n");
5416  return AVERROR_INVALIDDATA;
5417  }
5418 
5420  if (!sc->coll)
5421  return AVERROR(ENOMEM);
5422 
5423  sc->coll->MaxCLL = avio_rb16(pb);
5424  sc->coll->MaxFALL = avio_rb16(pb);
5425 
5426  return 0;
5427 }
5428 
5430 {
5431  AVStream *st;
5432  MOVStreamContext *sc;
5433  enum AVStereo3DType type;
5434  int mode;
5435 
5436  if (c->fc->nb_streams < 1)
5437  return 0;
5438 
5439  st = c->fc->streams[c->fc->nb_streams - 1];
5440  sc = st->priv_data;
5441 
5442  if (atom.size < 5) {
5443  av_log(c->fc, AV_LOG_ERROR, "Empty stereoscopic video box\n");
5444  return AVERROR_INVALIDDATA;
5445  }
5446  avio_skip(pb, 4); /* version + flags */
5447 
5448  mode = avio_r8(pb);
5449  switch (mode) {
5450  case 0:
5451  type = AV_STEREO3D_2D;
5452  break;
5453  case 1:
5454  type = AV_STEREO3D_TOPBOTTOM;
5455  break;
5456  case 2:
5457  type = AV_STEREO3D_SIDEBYSIDE;
5458  break;
5459  default:
5460  av_log(c->fc, AV_LOG_WARNING, "Unknown st3d mode value %d\n", mode);
5461  return 0;
5462  }
5463 
5464  sc->stereo3d = av_stereo3d_alloc();
5465  if (!sc->stereo3d)
5466  return AVERROR(ENOMEM);
5467 
5468  sc->stereo3d->type = type;
5469  return 0;
5470 }
5471 
5473 {
5474  AVStream *st;
5475  MOVStreamContext *sc;
5476  int size, version, layout;
5477  int32_t yaw, pitch, roll;
5478  uint32_t l = 0, t = 0, r = 0, b = 0;
5479  uint32_t tag, padding = 0;
5480  enum AVSphericalProjection projection;
5481 
5482  if (c->fc->nb_streams < 1)
5483  return 0;
5484 
5485  st = c->fc->streams[c->fc->nb_streams - 1];
5486  sc = st->priv_data;
5487 
5488  if (atom.size < 8) {
5489  av_log(c->fc, AV_LOG_ERROR, "Empty spherical video box\n");
5490  return AVERROR_INVALIDDATA;
5491  }
5492 
5493  size = avio_rb32(pb);
5494  if (size <= 12 || size > atom.size)
5495  return AVERROR_INVALIDDATA;
5496 
5497  tag = avio_rl32(pb);
5498  if (tag != MKTAG('s','v','h','d')) {
5499  av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
5500  return 0;
5501  }
5502  version = avio_r8(pb);
5503  if (version != 0) {
5504  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5505  version);
5506  return 0;
5507  }
5508  avio_skip(pb, 3); /* flags */
5509  avio_skip(pb, size - 12); /* metadata_source */
5510 
5511  size = avio_rb32(pb);
5512  if (size > atom.size)
5513  return AVERROR_INVALIDDATA;
5514 
5515  tag = avio_rl32(pb);
5516  if (tag != MKTAG('p','r','o','j')) {
5517  av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
5518  return 0;
5519  }
5520 
5521  size = avio_rb32(pb);
5522  if (size > atom.size)
5523  return AVERROR_INVALIDDATA;
5524 
5525  tag = avio_rl32(pb);
5526  if (tag != MKTAG('p','r','h','d')) {
5527  av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
5528  return 0;
5529  }
5530  version = avio_r8(pb);
5531  if (version != 0) {
5532  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5533  version);
5534  return 0;
5535  }
5536  avio_skip(pb, 3); /* flags */
5537 
5538  /* 16.16 fixed point */
5539  yaw = avio_rb32(pb);
5540  pitch = avio_rb32(pb);
5541  roll = avio_rb32(pb);
5542 
5543  size = avio_rb32(pb);
5544  if (size > atom.size)
5545  return AVERROR_INVALIDDATA;
5546 
5547  tag = avio_rl32(pb);
5548  version = avio_r8(pb);
5549  if (version != 0) {
5550  av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5551  version);
5552  return 0;
5553  }
5554  avio_skip(pb, 3); /* flags */
5555  switch (tag) {
5556  case MKTAG('c','b','m','p'):
5557  layout = avio_rb32(pb);
5558  if (layout) {
5559  av_log(c->fc, AV_LOG_WARNING,
5560  "Unsupported cubemap layout %d\n", layout);
5561  return 0;
5562  }
5563  projection = AV_SPHERICAL_CUBEMAP;
5564  padding = avio_rb32(pb);
5565  break;
5566  case MKTAG('e','q','u','i'):
5567  t = avio_rb32(pb);
5568  b = avio_rb32(pb);
5569  l = avio_rb32(pb);
5570  r = avio_rb32(pb);
5571 
5572  if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
5573  av_log(c->fc, AV_LOG_ERROR,
5574  "Invalid bounding rectangle coordinates "
5575  "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
5576  return AVERROR_INVALIDDATA;
5577  }
5578 
5579  if (l || t || r || b)
5580  projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
5581  else
5582  projection = AV_SPHERICAL_EQUIRECTANGULAR;
5583  break;
5584  default:
5585  av_log(c->fc, AV_LOG_ERROR, "Unknown projection type: %s\n", av_fourcc2str(tag));
5586  return 0;
5587  }
5588 
5590  if (!sc->spherical)
5591  return AVERROR(ENOMEM);
5592 
5593  sc->spherical->projection = projection;
5594 
5595  sc->spherical->yaw = yaw;
5596  sc->spherical->pitch = pitch;
5597  sc->spherical->roll = roll;
5598 
5599  sc->spherical->padding = padding;
5600 
5601  sc->spherical->bound_left = l;
5602  sc->spherical->bound_top = t;
5603  sc->spherical->bound_right = r;
5604  sc->spherical->bound_bottom = b;
5605 
5606  return 0;
5607 }
5608 
5610 {
5611  int ret = 0;
5612  uint8_t *buffer = av_malloc(len + 1);
5613  const char *val;
5614 
5615  if (!buffer)
5616  return AVERROR(ENOMEM);
5617  buffer[len] = '\0';
5618 
5619  ret = ffio_read_size(pb, buffer, len);
5620  if (ret < 0)
5621  goto out;
5622 
5623  /* Check for mandatory keys and values, try to support XML as best-effort */
5624  if (!sc->spherical &&
5625  av_stristr(buffer, "<GSpherical:StitchingSoftware>") &&
5626  (val = av_stristr(buffer, "<GSpherical:Spherical>")) &&
5627  av_stristr(val, "true") &&
5628  (val = av_stristr(buffer, "<GSpherical:Stitched>")) &&
5629  av_stristr(val, "true") &&
5630  (val = av_stristr(buffer, "<GSpherical:ProjectionType>")) &&
5631  av_stristr(val, "equirectangular")) {
5633  if (!sc->spherical)
5634  goto out;
5635 
5637 
5638  if (av_stristr(buffer, "<GSpherical:StereoMode>") && !sc->stereo3d) {
5639  enum AVStereo3DType mode;
5640 
5641  if (av_stristr(buffer, "left-right"))
5642  mode = AV_STEREO3D_SIDEBYSIDE;
5643  else if (av_stristr(buffer, "top-bottom"))
5644  mode = AV_STEREO3D_TOPBOTTOM;
5645  else
5646  mode = AV_STEREO3D_2D;
5647 
5648  sc->stereo3d = av_stereo3d_alloc();
5649  if (!sc->stereo3d)
5650  goto out;
5651 
5652  sc->stereo3d->type = mode;
5653  }
5654 
5655  /* orientation */
5656  val = av_stristr(buffer, "<GSpherical:InitialViewHeadingDegrees>");
5657  if (val)
5658  sc->spherical->yaw = strtol(val, NULL, 10) * (1 << 16);
5659  val = av_stristr(buffer, "<GSpherical:InitialViewPitchDegrees>");
5660  if (val)
5661  sc->spherical->pitch = strtol(val, NULL, 10) * (1 << 16);
5662  val = av_stristr(buffer, "<GSpherical:InitialViewRollDegrees>");
5663  if (val)
5664  sc->spherical->roll = strtol(val, NULL, 10) * (1 << 16);
5665  }
5666 
5667 out:
5668  av_free(buffer);
5669  return ret;
5670 }
5671 
5673 {
5674  AVStream *st;
5675  MOVStreamContext *sc;
5676  int64_t ret;
5677  uint8_t uuid[16];
5678  static const uint8_t uuid_isml_manifest[] = {
5679  0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
5680  0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
5681  };
5682  static const uint8_t uuid_xmp[] = {
5683  0xbe, 0x7a, 0xcf, 0xcb, 0x97, 0xa9, 0x42, 0xe8,
5684  0x9c, 0x71, 0x99, 0x94, 0x91, 0xe3, 0xaf, 0xac
5685  };
5686  static const uint8_t uuid_spherical[] = {
5687  0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
5688  0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
5689  };
5690 
5691  if (atom.size < sizeof(uuid) || atom.size >= FFMIN(INT_MAX, SIZE_MAX))
5692  return AVERROR_INVALIDDATA;
5693 
5694  if (c->fc->nb_streams < 1)
5695  return 0;
5696  st = c->fc->streams[c->fc->nb_streams - 1];
5697  sc = st->priv_data;
5698 
5699  ret = avio_read(pb, uuid, sizeof(uuid));
5700  if (ret < 0) {
5701  return ret;
5702  } else if (ret != sizeof(uuid)) {
5703  return AVERROR_INVALIDDATA;
5704  }
5705  if (!memcmp(uuid, uuid_isml_manifest, sizeof(uuid))) {
5706  uint8_t *buffer, *ptr;
5707  char *endptr;
5708  size_t len = atom.size - sizeof(uuid);
5709 
5710  if (len < 4) {
5711  return AVERROR_INVALIDDATA;
5712  }
5713  ret = avio_skip(pb, 4); // zeroes
5714  len -= 4;
5715 
5716  buffer = av_mallocz(len + 1);
5717  if (!buffer) {
5718  return AVERROR(ENOMEM);
5719  }
5720  ret = avio_read(pb, buffer, len);
5721  if (ret < 0) {
5722  av_free(buffer);
5723  return ret;
5724  } else if (ret != len) {
5725  av_free(buffer);
5726  return AVERROR_INVALIDDATA;
5727  }
5728 
5729  ptr = buffer;
5730  while ((ptr = av_stristr(ptr, "systemBitrate=\""))) {
5731  ptr += sizeof("systemBitrate=\"") - 1;
5732  c->bitrates_count++;
5733  c->bitrates = av_realloc_f(c->bitrates, c->bitrates_count, sizeof(*c->bitrates));
5734  if (!c->bitrates) {
5735  c->bitrates_count = 0;
5736  av_free(buffer);
5737  return AVERROR(ENOMEM);
5738  }
5739  errno = 0;
5740  ret = strtol(ptr, &endptr, 10);
5741  if (ret < 0 || errno || *endptr != '"') {
5742  c->bitrates[c->bitrates_count - 1] = 0;
5743  } else {
5744  c->bitrates[c->bitrates_count - 1] = ret;
5745  }
5746  }
5747 
5748  av_free(buffer);
5749  } else if (!memcmp(uuid, uuid_xmp, sizeof(uuid))) {
5750  uint8_t *buffer;
5751  size_t len = atom.size - sizeof(uuid);
5752  if (c->export_xmp) {
5753  buffer = av_mallocz(len + 1);
5754  if (!buffer) {
5755  return AVERROR(ENOMEM);
5756  }
5757  ret = avio_read(pb, buffer, len);
5758  if (ret < 0) {
5759  av_free(buffer);
5760  return ret;
5761  } else if (ret != len) {
5762  av_free(buffer);
5763  return AVERROR_INVALIDDATA;
5764  }
5765  buffer[len] = '\0';
5766  av_dict_set(&c->fc->metadata, "xmp", buffer, 0);
5767  av_free(buffer);
5768  } else {
5769  // skip all uuid atom, which makes it fast for long uuid-xmp file
5770  ret = avio_skip(pb, len);
5771  if (ret < 0)
5772  return ret;
5773  }
5774  } else if (!memcmp(uuid, uuid_spherical, sizeof(uuid))) {
5775  size_t len = atom.size - sizeof(uuid);
5776  ret = mov_parse_uuid_spherical(sc, pb, len);
5777  if (ret < 0)
5778  return ret;
5779  if (!sc->spherical)
5780  av_log(c->fc, AV_LOG_WARNING, "Invalid spherical metadata found\n");
5781  }
5782 
5783  return 0;
5784 }
5785 
5787 {
5788  int ret;
5789  uint8_t content[16];
5790 
5791  if (atom.size < 8)
5792  return 0;
5793 
5794  ret = avio_read(pb, content, FFMIN(sizeof(content), atom.size));
5795  if (ret < 0)
5796  return ret;
5797 
5798  if ( !c->found_moov
5799  && !c->found_mdat
5800  && !memcmp(content, "Anevia\x1A\x1A", 8)
5803  }
5804 
5805  return 0;
5806 }
5807 
5809 {
5810  uint32_t format = avio_rl32(pb);
5811  MOVStreamContext *sc;
5812  enum AVCodecID id;
5813  AVStream *st;
5814 
5815  if (c->fc->nb_streams < 1)
5816  return 0;
5817  st = c->fc->streams[c->fc->nb_streams - 1];
5818  sc = st->priv_data;
5819 
5820  switch (sc->format)
5821  {
5822  case MKTAG('e','n','c','v'): // encrypted video
5823  case MKTAG('e','n','c','a'): // encrypted audio
5824  id = mov_codec_id(st, format);
5825  if (st->codecpar->codec_id != AV_CODEC_ID_NONE &&
5826  st->codecpar->codec_id != id) {
5827  av_log(c->fc, AV_LOG_WARNING,
5828  "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
5829  (char*)&format, st->codecpar->codec_id);
5830  break;
5831  }
5832 
5833  st->codecpar->codec_id = id;
5834  sc->format = format;
5835  break;
5836 
5837  default:
5838  if (format != sc->format) {
5839  av_log(c->fc, AV_LOG_WARNING,
5840  "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
5841  (char*)&format, (char*)&sc->format);
5842  }
5843  break;
5844  }
5845 
5846  return 0;
5847 }
5848 
5849 /**
5850  * Gets the current encryption info and associated current stream context. If
5851  * we are parsing a track fragment, this will return the specific encryption
5852  * info for this fragment; otherwise this will return the global encryption
5853  * info for the current stream.
5854  */
5856 {
5857  MOVFragmentStreamInfo *frag_stream_info;
5858  AVStream *st;
5859  int i;
5860 
5861  frag_stream_info = get_current_frag_stream_info(&c->frag_index);
5862  if (frag_stream_info) {
5863  for (i = 0; i < c->fc->nb_streams; i++) {
5864  if (c->fc->streams[i]->id == frag_stream_info->id) {
5865  st = c->fc->streams[i];
5866  break;
5867  }
5868  }
5869  if (i == c->fc->nb_streams)
5870  return 0;
5871  *sc = st->priv_data;
5872 
5873  if (!frag_stream_info->encryption_index) {
5874  // If this stream isn't encrypted, don't create the index.
5875  if (!(*sc)->cenc.default_encrypted_sample)
5876  return 0;
5877  frag_stream_info->encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5878  if (!frag_stream_info->encryption_index)
5879  return AVERROR(ENOMEM);
5880  }
5881  *encryption_index = frag_stream_info->encryption_index;
5882  return 1;
5883  } else {
5884  // No current track fragment, using stream level encryption info.
5885 
5886  if (c->fc->nb_streams < 1)
5887  return 0;
5888  st = c->fc->streams[c->fc->nb_streams - 1];
5889  *sc = st->priv_data;
5890 
5891  if (!(*sc)->cenc.encryption_index) {
5892  // If this stream isn't encrypted, don't create the index.
5893  if (!(*sc)->cenc.default_encrypted_sample)
5894  return 0;
5895  (*sc)->cenc.encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5896  if (!(*sc)->cenc.encryption_index)
5897  return AVERROR(ENOMEM);
5898  }
5899 
5900  *encryption_index = (*sc)->cenc.encryption_index;
5901  return 1;
5902  }
5903 }
5904 
5906 {
5907  int i;
5908  unsigned int subsample_count;
5909  AVSubsampleEncryptionInfo *subsamples;
5910 
5911  if (!sc->cenc.default_encrypted_sample) {
5912  av_log(c->fc, AV_LOG_ERROR, "Missing schm or tenc\n");
5913  return AVERROR_INVALIDDATA;
5914  }
5915 
5917  if (!*sample)
5918  return AVERROR(ENOMEM);
5919 
5920  if (sc->cenc.per_sample_iv_size != 0) {
5921  if (avio_read(pb, (*sample)->iv, sc->cenc.per_sample_iv_size) != sc->cenc.per_sample_iv_size) {
5922  av_log(c->fc, AV_LOG_ERROR, "failed to read the initialization vector\n");
5923  av_encryption_info_free(*sample);
5924  *sample = NULL;
5925  return AVERROR_INVALIDDATA;
5926  }
5927  }
5928 
5929  if (use_subsamples) {
5930  subsample_count = avio_rb16(pb);
5931  av_free((*sample)->subsamples);
5932  (*sample)->subsamples = av_mallocz_array(subsample_count, sizeof(*subsamples));
5933  if (!(*sample)->subsamples) {
5934  av_encryption_info_free(*sample);
5935  *sample = NULL;
5936  return AVERROR(ENOMEM);
5937  }
5938 
5939  for (i = 0; i < subsample_count && !pb->eof_reached; i++) {
5940  (*sample)->subsamples[i].bytes_of_clear_data = avio_rb16(pb);
5941  (*sample)->subsamples[i].bytes_of_protected_data = avio_rb32(pb);
5942  }
5943 
5944  if (pb->eof_reached) {
5945  av_log(c->fc, AV_LOG_ERROR, "hit EOF while reading sub-sample encryption info\n");
5946  av_encryption_info_free(*sample);
5947  *sample = NULL;
5948  return AVERROR_INVALIDDATA;
5949  }
5950  (*sample)->subsample_count = subsample_count;
5951  }
5952 
5953  return 0;
5954 }
5955 
5957 {
5958  AVEncryptionInfo **encrypted_samples;
5959  MOVEncryptionIndex *encryption_index;
5960  MOVStreamContext *sc;
5961  int use_subsamples, ret;
5962  unsigned int sample_count, i, alloc_size = 0;
5963 
5964  ret = get_current_encryption_info(c, &encryption_index, &sc);
5965  if (ret != 1)
5966  return ret;
5967 
5968  if (encryption_index->nb_encrypted_samples) {
5969  // This can happen if we have both saio/saiz and senc atoms.
5970  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in senc\n");
5971  return 0;
5972  }
5973 
5974  avio_r8(pb); /* version */
5975  use_subsamples = avio_rb24(pb) & 0x02; /* flags */
5976 
5977  sample_count = avio_rb32(pb);
5978  if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
5979  return AVERROR(ENOMEM);
5980 
5981  for (i = 0; i < sample_count; i++) {
5982  unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
5983  encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
5984  min_samples * sizeof(*encrypted_samples));
5985  if (encrypted_samples) {
5986  encryption_index->encrypted_samples = encrypted_samples;
5987 
5989  c, pb, sc, &encryption_index->encrypted_samples[i], use_subsamples);
5990  } else {
5991  ret = AVERROR(ENOMEM);
5992  }
5993  if (pb->eof_reached) {
5994  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading senc\n");
5995  ret = AVERROR_INVALIDDATA;
5996  }
5997 
5998  if (ret < 0) {
5999  for (; i > 0; i--)
6000  av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6001  av_freep(&encryption_index->encrypted_samples);
6002  return ret;
6003  }
6004  }
6005  encryption_index->nb_encrypted_samples = sample_count;
6006 
6007  return 0;
6008 }
6009 
6011 {
6012  AVEncryptionInfo **sample, **encrypted_samples;
6013  int64_t prev_pos;
6014  size_t sample_count, sample_info_size, i;
6015  int ret = 0;
6016  unsigned int alloc_size = 0;
6017 
6018  if (encryption_index->nb_encrypted_samples)
6019  return 0;
6020  sample_count = encryption_index->auxiliary_info_sample_count;
6021  if (encryption_index->auxiliary_offsets_count != 1) {
6022  av_log(c->fc, AV_LOG_ERROR, "Multiple auxiliary info chunks are not supported\n");
6023  return AVERROR_PATCHWELCOME;
6024  }
6025  if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
6026  return AVERROR(ENOMEM);
6027 
6028  prev_pos = avio_tell(pb);
6029  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
6030  avio_seek(pb, encryption_index->auxiliary_offsets[0], SEEK_SET) != encryption_index->auxiliary_offsets[0]) {
6031  av_log(c->fc, AV_LOG_INFO, "Failed to seek for auxiliary info, will only parse senc atoms for encryption info\n");
6032  goto finish;
6033  }
6034 
6035  for (i = 0; i < sample_count && !pb->eof_reached; i++) {
6036  unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
6037  encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
6038  min_samples * sizeof(*encrypted_samples));
6039  if (!encrypted_samples) {
6040  ret = AVERROR(ENOMEM);
6041  goto finish;
6042  }
6043  encryption_index->encrypted_samples = encrypted_samples;
6044 
6045  sample = &encryption_index->encrypted_samples[i];
6046  sample_info_size = encryption_index->auxiliary_info_default_size
6047  ? encryption_index->auxiliary_info_default_size
6048  : encryption_index->auxiliary_info_sizes[i];
6049 
6050  ret = mov_read_sample_encryption_info(c, pb, sc, sample, sample_info_size > sc->cenc.per_sample_iv_size);
6051  if (ret < 0)
6052  goto finish;
6053  }
6054  if (pb->eof_reached) {
6055  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading auxiliary info\n");
6056  ret = AVERROR_INVALIDDATA;
6057  } else {
6058  encryption_index->nb_encrypted_samples = sample_count;
6059  }
6060 
6061 finish:
6062  avio_seek(pb, prev_pos, SEEK_SET);
6063  if (ret < 0) {
6064  for (; i > 0; i--) {
6065  av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6066  }
6067  av_freep(&encryption_index->encrypted_samples);
6068  }
6069  return ret;
6070 }
6071 
6072 /**
6073  * Tries to read the given number of bytes from the stream and puts it in a
6074  * newly allocated buffer. This reads in small chunks to avoid allocating large
6075  * memory if the file contains an invalid/malicious size value.
6076  */
6077 static int mov_try_read_block(AVIOContext *pb, size_t size, uint8_t **data)
6078 {
6079  const unsigned int block_size = 1024 * 1024;
6080  uint8_t *buffer = NULL;
6081  unsigned int alloc_size = 0, offset = 0;
6082  while (offset < size) {
6083  unsigned int new_size =
6084  alloc_size >= INT_MAX - block_size ? INT_MAX : alloc_size + block_size;
6085  uint8_t *new_buffer = av_fast_realloc(buffer, &alloc_size, new_size);
6086  unsigned int to_read = FFMIN(size, alloc_size) - offset;
6087  if (!new_buffer) {
6088  av_free(buffer);
6089  return AVERROR(ENOMEM);
6090  }
6091  buffer = new_buffer;
6092 
6093  if (avio_read(pb, buffer + offset, to_read) != to_read) {
6094  av_free(buffer);
6095  return AVERROR_INVALIDDATA;
6096  }
6097  offset += to_read;
6098  }
6099 
6100  *data = buffer;
6101  return 0;
6102 }
6103 
6105 {
6106  MOVEncryptionIndex *encryption_index;
6107  MOVStreamContext *sc;
6108  int ret;
6109  unsigned int sample_count, aux_info_type, aux_info_param;
6110 
6111  ret = get_current_encryption_info(c, &encryption_index, &sc);
6112  if (ret != 1)
6113  return ret;
6114 
6115  if (encryption_index->nb_encrypted_samples) {
6116  // This can happen if we have both saio/saiz and senc atoms.
6117  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saiz\n");
6118  return 0;
6119  }
6120 
6121  if (encryption_index->auxiliary_info_sample_count) {
6122  av_log(c->fc, AV_LOG_ERROR, "Duplicate saiz atom\n");
6123  return AVERROR_INVALIDDATA;
6124  }
6125 
6126  avio_r8(pb); /* version */
6127  if (avio_rb24(pb) & 0x01) { /* flags */
6128  aux_info_type = avio_rb32(pb);
6129  aux_info_param = avio_rb32(pb);
6130  if (sc->cenc.default_encrypted_sample) {
6131  if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6132  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type\n");
6133  return 0;
6134  }
6135  if (aux_info_param != 0) {
6136  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type_parameter\n");
6137  return 0;
6138  }
6139  } else {
6140  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6141  if ((aux_info_type == MKBETAG('c','e','n','c') ||
6142  aux_info_type == MKBETAG('c','e','n','s') ||
6143  aux_info_type == MKBETAG('c','b','c','1') ||
6144  aux_info_type == MKBETAG('c','b','c','s')) &&
6145  aux_info_param == 0) {
6146  av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saiz without schm/tenc\n");
6147  return AVERROR_INVALIDDATA;
6148  } else {
6149  return 0;
6150  }
6151  }
6152  } else if (!sc->cenc.default_encrypted_sample) {
6153  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6154  return 0;
6155  }
6156 
6157  encryption_index->auxiliary_info_default_size = avio_r8(pb);
6158  sample_count = avio_rb32(pb);
6159  encryption_index->auxiliary_info_sample_count = sample_count;
6160 
6161  if (encryption_index->auxiliary_info_default_size == 0) {
6162  ret = mov_try_read_block(pb, sample_count, &encryption_index->auxiliary_info_sizes);
6163  if (ret < 0) {
6164  av_log(c->fc, AV_LOG_ERROR, "Failed to read the auxiliary info\n");
6165  return ret;
6166  }
6167  }
6168 
6169  if (encryption_index->auxiliary_offsets_count) {
6170  return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6171  }
6172 
6173  return 0;
6174 }
6175 
6177 {
6178  uint64_t *auxiliary_offsets;
6179  MOVEncryptionIndex *encryption_index;
6180  MOVStreamContext *sc;
6181  int i, ret;
6182  unsigned int version, entry_count, aux_info_type, aux_info_param;
6183  unsigned int alloc_size = 0;
6184 
6185  ret = get_current_encryption_info(c, &encryption_index, &sc);
6186  if (ret != 1)
6187  return ret;
6188 
6189  if (encryption_index->nb_encrypted_samples) {
6190  // This can happen if we have both saio/saiz and senc atoms.
6191  av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saio\n");
6192  return 0;
6193  }
6194 
6195  if (encryption_index->auxiliary_offsets_count) {
6196  av_log(c->fc, AV_LOG_ERROR, "Duplicate saio atom\n");
6197  return AVERROR_INVALIDDATA;
6198  }
6199 
6200  version = avio_r8(pb); /* version */
6201  if (avio_rb24(pb) & 0x01) { /* flags */
6202  aux_info_type = avio_rb32(pb);
6203  aux_info_param = avio_rb32(pb);
6204  if (sc->cenc.default_encrypted_sample) {
6205  if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6206  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type\n");
6207  return 0;
6208  }
6209  if (aux_info_param != 0) {
6210  av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type_parameter\n");
6211  return 0;
6212  }
6213  } else {
6214  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6215  if ((aux_info_type == MKBETAG('c','e','n','c') ||
6216  aux_info_type == MKBETAG('c','e','n','s') ||
6217  aux_info_type == MKBETAG('c','b','c','1') ||
6218  aux_info_type == MKBETAG('c','b','c','s')) &&
6219  aux_info_param == 0) {
6220  av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saio without schm/tenc\n");
6221  return AVERROR_INVALIDDATA;
6222  } else {
6223  return 0;
6224  }
6225  }
6226  } else if (!sc->cenc.default_encrypted_sample) {
6227  // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6228  return 0;
6229  }
6230 
6231  entry_count = avio_rb32(pb);
6232  if (entry_count >= INT_MAX / sizeof(*auxiliary_offsets))
6233  return AVERROR(ENOMEM);
6234 
6235  for (i = 0; i < entry_count && !pb->eof_reached; i++) {
6236  unsigned int min_offsets = FFMIN(FFMAX(i + 1, 1024), entry_count);
6237  auxiliary_offsets = av_fast_realloc(
6238  encryption_index->auxiliary_offsets, &alloc_size,
6239  min_offsets * sizeof(*auxiliary_offsets));
6240  if (!auxiliary_offsets) {
6241  av_freep(&encryption_index->auxiliary_offsets);
6242  return AVERROR(ENOMEM);
6243  }
6244  encryption_index->auxiliary_offsets = auxiliary_offsets;
6245 
6246  if (version == 0) {
6247  encryption_index->auxiliary_offsets[i] = avio_rb32(pb);
6248  } else {
6249  encryption_index->auxiliary_offsets[i] = avio_rb64(pb);
6250  }
6251  if (c->frag_index.current >= 0) {
6252  encryption_index->auxiliary_offsets[i] += c->fragment.base_data_offset;
6253  }
6254  }
6255 
6256  if (pb->eof_reached) {
6257  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading saio\n");
6258  av_freep(&encryption_index->auxiliary_offsets);
6259  return AVERROR_INVALIDDATA;
6260  }
6261 
6262  encryption_index->auxiliary_offsets_count = entry_count;
6263 
6264  if (encryption_index->auxiliary_info_sample_count) {
6265  return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6266  }
6267 
6268  return 0;
6269 }
6270 
6272 {
6273  AVEncryptionInitInfo *info, *old_init_info;
6274  uint8_t **key_ids;
6275  AVStream *st;
6276  uint8_t *side_data, *extra_data, *old_side_data;
6277  size_t side_data_size;
6278  int ret = 0, old_side_data_size;
6279  unsigned int version, kid_count, extra_data_size, alloc_size = 0;
6280 
6281  if (c->fc->nb_streams < 1)
6282  return 0;
6283  st = c->fc->streams[c->fc->nb_streams-1];
6284 
6285  version = avio_r8(pb); /* version */
6286  avio_rb24(pb); /* flags */
6287 
6288  info = av_encryption_init_info_alloc(/* system_id_size */ 16, /* num_key_ids */ 0,
6289  /* key_id_size */ 16, /* data_size */ 0);
6290  if (!info)
6291  return AVERROR(ENOMEM);
6292 
6293  if (avio_read(pb, info->system_id, 16) != 16) {
6294  av_log(c->fc, AV_LOG_ERROR, "Failed to read the system id\n");
6295  ret = AVERROR_INVALIDDATA;
6296  goto finish;
6297  }
6298 
6299  if (version > 0) {
6300  kid_count = avio_rb32(pb);
6301  if (kid_count >= INT_MAX / sizeof(*key_ids))
6302  return AVERROR(ENOMEM);
6303 
6304  for (unsigned int i = 0; i < kid_count && !pb->eof_reached; i++) {
6305  unsigned int min_kid_count = FFMIN(FFMAX(i + 1, 1024), kid_count);
6306  key_ids = av_fast_realloc(info->key_ids, &alloc_size,
6307  min_kid_count * sizeof(*key_ids));
6308  if (!key_ids) {
6309  ret = AVERROR(ENOMEM);
6310  goto finish;
6311  }
6312  info->key_ids = key_ids;
6313 
6314  info->key_ids[i] = av_mallocz(16);
6315  if (!info->key_ids[i]) {
6316  ret = AVERROR(ENOMEM);
6317  goto finish;
6318  }
6319  info->num_key_ids = i + 1;
6320 
6321  if (avio_read(pb, info->key_ids[i], 16) != 16) {
6322  av_log(c->fc, AV_LOG_ERROR, "Failed to read the key id\n");
6323  ret = AVERROR_INVALIDDATA;
6324  goto finish;
6325  }
6326  }
6327 
6328  if (pb->eof_reached) {
6329  av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading pssh\n");
6330  ret = AVERROR_INVALIDDATA;
6331  goto finish;
6332  }
6333  }
6334 
6335  extra_data_size = avio_rb32(pb);
6336  ret = mov_try_read_block(pb, extra_data_size, &extra_data);
6337  if (ret < 0)
6338  goto finish;
6339 
6340  av_freep(&info->data); // malloc(0) may still allocate something.
6341  info->data = extra_data;
6342  info->data_size = extra_data_size;
6343 
6344  // If there is existing initialization data, append to the list.
6345  old_side_data = av_stream_get_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO, &old_side_data_size);
6346  if (old_side_data) {
6347  old_init_info = av_encryption_init_info_get_side_data(old_side_data, old_side_data_size);
6348  if (old_init_info) {
6349  // Append to the end of the list.
6350  for (AVEncryptionInitInfo *cur = old_init_info;; cur = cur->next) {
6351  if (!cur->next) {
6352  cur->next = info;
6353  break;
6354  }
6355  }
6356  info = old_init_info;
6357  } else {
6358  // Assume existing side-data will be valid, so the only error we could get is OOM.
6359  ret = AVERROR(ENOMEM);
6360  goto finish;
6361  }
6362  }
6363 
6364  side_data = av_encryption_init_info_add_side_data(info, &side_data_size);
6365  if (!side_data) {
6366  ret = AVERROR(ENOMEM);
6367  goto finish;
6368  }
6370  side_data, side_data_size);
6371  if (ret < 0)
6372  av_free(side_data);
6373 
6374 finish:
6376  return ret;
6377 }
6378 
6380 {
6381  AVStream *st;
6382  MOVStreamContext *sc;
6383 
6384  if (c->fc->nb_streams < 1)
6385  return 0;
6386  st = c->fc->streams[c->fc->nb_streams-1];
6387  sc = st->priv_data;
6388 
6389  if (sc->pseudo_stream_id != 0) {
6390  av_log(c->fc, AV_LOG_ERROR, "schm boxes are only supported in first sample descriptor\n");
6391  return AVERROR_PATCHWELCOME;
6392  }
6393 
6394  if (atom.size < 8)
6395  return AVERROR_INVALIDDATA;
6396 
6397  avio_rb32(pb); /* version and flags */
6398 
6399  if (!sc->cenc.default_encrypted_sample) {
6401  if (!sc->cenc.default_encrypted_sample) {
6402  return AVERROR(ENOMEM);
6403  }
6404  }
6405 
6407  return 0;
6408 }
6409 
6411 {
6412  AVStream *st;
6413  MOVStreamContext *sc;
6414  unsigned int version, pattern, is_protected, iv_size;
6415 
6416  if (c->fc->nb_streams < 1)
6417  return 0;
6418  st = c->fc->streams[c->fc->nb_streams-1];
6419  sc = st->priv_data;
6420 
6421  if (sc->pseudo_stream_id != 0) {
6422  av_log(c->fc, AV_LOG_ERROR, "tenc atom are only supported in first sample descriptor\n");
6423  return AVERROR_PATCHWELCOME;
6424  }
6425 
6426  if (!sc->cenc.default_encrypted_sample) {
6428  if (!sc->cenc.default_encrypted_sample) {
6429  return AVERROR(ENOMEM);
6430  }
6431  }
6432 
6433  if (atom.size < 20)
6434  return AVERROR_INVALIDDATA;
6435 
6436  version = avio_r8(pb); /* version */
6437  avio_rb24(pb); /* flags */
6438 
6439  avio_r8(pb); /* reserved */
6440  pattern = avio_r8(pb);
6441 
6442  if (version > 0) {
6443  sc->cenc.default_encrypted_sample->crypt_byte_block = pattern >> 4;
6444  sc->cenc.default_encrypted_sample->skip_byte_block = pattern & 0xf;
6445  }
6446 
6447  is_protected = avio_r8(pb);
6448  if (is_protected && !sc->cenc.encryption_index) {
6449  // The whole stream should be by-default encrypted.
6451  if (!sc->cenc.encryption_index)
6452  return AVERROR(ENOMEM);
6453  }
6454  sc->cenc.per_sample_iv_size = avio_r8(pb);
6455  if (sc->cenc.per_sample_iv_size != 0 && sc->cenc.per_sample_iv_size != 8 &&
6456  sc->cenc.per_sample_iv_size != 16) {
6457  av_log(c->fc, AV_LOG_ERROR, "invalid per-sample IV size value\n");
6458  return AVERROR_INVALIDDATA;
6459  }
6460  if (avio_read(pb, sc->cenc.default_encrypted_sample->key_id, 16) != 16) {
6461  av_log(c->fc, AV_LOG_ERROR, "failed to read the default key ID\n");
6462  return AVERROR_INVALIDDATA;
6463  }
6464 
6465  if (is_protected && !sc->cenc.per_sample_iv_size) {
6466  iv_size = avio_r8(pb);
6467  if (iv_size != 8 && iv_size != 16) {
6468  av_log(c->fc, AV_LOG_ERROR, "invalid default_constant_IV_size in tenc atom\n");
6469  return AVERROR_INVALIDDATA;
6470  }
6471 
6472  if (avio_read(pb, sc->cenc.default_encrypted_sample->iv, iv_size) != iv_size) {
6473  av_log(c->fc, AV_LOG_ERROR, "failed to read the default IV\n");
6474  return AVERROR_INVALIDDATA;
6475  }
6476  }
6477 
6478  return 0;
6479 }
6480 
6482 {
6483  AVStream *st;
6484  int last, type, size, ret;
6485  uint8_t buf[4];
6486 
6487  if (c->fc->nb_streams < 1)
6488  return 0;
6489  st = c->fc->streams[c->fc->nb_streams-1];
6490 
6491  if ((uint64_t)atom.size > (1<<30) || atom.size < 42)
6492  return AVERROR_INVALIDDATA;
6493 
6494  /* Check FlacSpecificBox version. */
6495  if (avio_r8(pb) != 0)
6496  return AVERROR_INVALIDDATA;
6497 
6498  avio_rb24(pb); /* Flags */
6499 
6500  avio_read(pb, buf, sizeof(buf));
6501  flac_parse_block_header(buf, &last, &type, &size);
6502 
6503  if (type != FLAC_METADATA_TYPE_STREAMINFO || size != FLAC_STREAMINFO_SIZE) {
6504  av_log(c->fc, AV_LOG_ERROR, "STREAMINFO must be first FLACMetadataBlock\n");
6505  return AVERROR_INVALIDDATA;
6506  }
6507 
6508  ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
6509  if (ret < 0)
6510  return ret;
6511 
6512  if (!last)
6513  av_log(c->fc, AV_LOG_WARNING, "non-STREAMINFO FLACMetadataBlock(s) ignored\n");
6514 
6515  return 0;
6516 }
6517 
6519 {
6520  int i, ret;
6521 
6522  if (sample->scheme != MKBETAG('c','e','n','c') || sample->crypt_byte_block != 0 || sample->skip_byte_block != 0) {
6523  av_log(c->fc, AV_LOG_ERROR, "Only the 'cenc' encryption scheme is supported\n");
6524  return AVERROR_PATCHWELCOME;
6525  }
6526 
6527  if (!sc->cenc.aes_ctr) {
6528  /* initialize the cipher */
6529  sc->cenc.aes_ctr = av_aes_ctr_alloc();
6530  if (!sc->cenc.aes_ctr) {
6531  return AVERROR(ENOMEM);
6532  }
6533 
6534  ret = av_aes_ctr_init(sc->cenc.aes_ctr, c->decryption_key);
6535  if (ret < 0) {
6536  return ret;
6537  }
6538  }
6539 
6540  av_aes_ctr_set_full_iv(sc->cenc.aes_ctr, sample->iv);
6541 
6542  if (!sample->subsample_count)
6543  {
6544  /* decrypt the whole packet */
6545  av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, size);
6546  return 0;
6547  }
6548 
6549  for (i = 0; i < sample->subsample_count; i++)
6550  {
6551  if (sample->subsamples[i].bytes_of_clear_data + sample->subsamples[i].bytes_of_protected_data > size) {
6552  av_log(c->fc, AV_LOG_ERROR, "subsample size exceeds the packet size left\n");
6553  return AVERROR_INVALIDDATA;
6554  }
6555 
6556  /* skip the clear bytes */
6557  input += sample->subsamples[i].bytes_of_clear_data;
6558  size -= sample->subsamples[i].bytes_of_clear_data;
6559 
6560  /* decrypt the encrypted bytes */
6561  av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, sample->subsamples[i].bytes_of_protected_data);
6562  input += sample->subsamples[i].bytes_of_protected_data;
6563  size -= sample->subsamples[i].bytes_of_protected_data;
6564  }
6565 
6566  if (size > 0) {
6567  av_log(c->fc, AV_LOG_ERROR, "leftover packet bytes after subsample processing\n");
6568  return AVERROR_INVALIDDATA;
6569  }
6570 
6571  return 0;
6572 }
6573 
6574 static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
6575 {
6576  MOVFragmentStreamInfo *frag_stream_info;
6577  MOVEncryptionIndex *encryption_index;
6578  AVEncryptionInfo *encrypted_sample;
6579  int encrypted_index, ret;
6580 
6581  frag_stream_info = get_frag_stream_info(&mov->frag_index, mov->frag_index.current, st->id);
6582  encrypted_index = current_index;
6583  encryption_index = NULL;
6584  if (frag_stream_info) {
6585  // Note this only supports encryption info in the first sample descriptor.
6586  if (mov->fragment.stsd_id == 1) {
6587  if (frag_stream_info->encryption_index) {
6588  encrypted_index = current_index - frag_stream_info->index_entry;
6589  encryption_index = frag_stream_info->encryption_index;
6590  } else {
6591  encryption_index = sc->cenc.encryption_index;
6592  }
6593  }
6594  } else {
6595  encryption_index = sc->cenc.encryption_index;
6596  }
6597 
6598  if (encryption_index) {
6599  if (encryption_index->auxiliary_info_sample_count &&
6600  !encryption_index->nb_encrypted_samples) {
6601  av_log(mov->fc, AV_LOG_ERROR, "saiz atom found without saio\n");
6602  return AVERROR_INVALIDDATA;
6603  }
6604  if (encryption_index->auxiliary_offsets_count &&
6605  !encryption_index->nb_encrypted_samples) {
6606  av_log(mov->fc, AV_LOG_ERROR, "saio atom found without saiz\n");
6607  return AVERROR_INVALIDDATA;
6608  }
6609 
6610  if (!encryption_index->nb_encrypted_samples) {
6611  // Full-sample encryption with default settings.
6612  encrypted_sample = sc->cenc.default_encrypted_sample;
6613  } else if (encrypted_index >= 0 && encrypted_index < encryption_index->nb_encrypted_samples) {
6614  // Per-sample setting override.
6615  encrypted_sample = encryption_index->encrypted_samples[encrypted_index];
6616  } else {
6617  av_log(mov->fc, AV_LOG_ERROR, "Incorrect number of samples in encryption info\n");
6618  return AVERROR_INVALIDDATA;
6619  }
6620 
6621  if (mov->decryption_key) {
6622  return cenc_decrypt(mov, sc, encrypted_sample, pkt->data, pkt->size);
6623  } else {
6624  size_t size;
6625  uint8_t *side_data = av_encryption_info_add_side_data(encrypted_sample, &size);
6626  if (!side_data)
6627  return AVERROR(ENOMEM);
6628  ret = av_packet_add_side_data(pkt, AV_PKT_DATA_ENCRYPTION_INFO, side_data, size);
6629  if (ret < 0)
6630  av_free(side_data);
6631  return ret;
6632  }
6633  }
6634 
6635  return 0;
6636 }
6637 
6639 {
6640  const int OPUS_SEEK_PREROLL_MS = 80;
6641  AVStream *st;
6642  size_t size;
6643  uint16_t pre_skip;
6644 
6645  if (c->fc->nb_streams < 1)
6646  return 0;
6647  st = c->fc->streams[c->fc->nb_streams-1];
6648 
6649  if ((uint64_t)atom.size > (1<<30) || atom.size < 11)
6650  return AVERROR_INVALIDDATA;
6651 
6652  /* Check OpusSpecificBox version. */
6653  if (avio_r8(pb) != 0) {
6654  av_log(c->fc, AV_LOG_ERROR, "unsupported OpusSpecificBox version\n");
6655  return AVERROR_INVALIDDATA;
6656  }
6657 
6658  /* OpusSpecificBox size plus magic for Ogg OpusHead header. */
6659  size = atom.size + 8;
6660 
6661  if (ff_alloc_extradata(st->codecpar, size))
6662  return AVERROR(ENOMEM);
6663 
6664  AV_WL32(st->codecpar->extradata, MKTAG('O','p','u','s'));
6665  AV_WL32(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
6666  AV_WB8(st->codecpar->extradata + 8, 1); /* OpusHead version */
6667  avio_read(pb, st->codecpar->extradata + 9, size - 9);
6668 
6669  /* OpusSpecificBox is stored in big-endian, but OpusHead is
6670  little-endian; aside from the preceeding magic and version they're
6671  otherwise currently identical. Data after output gain at offset 16
6672  doesn't need to be bytewapped. */
6673  pre_skip = AV_RB16(st->codecpar->extradata + 10);
6674  AV_WL16(st->codecpar->extradata + 10, pre_skip);
6675  AV_WL32(st->codecpar->extradata + 12, AV_RB32(st->codecpar->extradata + 12));
6676  AV_WL16(st->codecpar->extradata + 16, AV_RB16(st->codecpar->extradata + 16));
6677 
6678  st->codecpar->initial_padding = pre_skip;
6679  st->codecpar->seek_preroll = av_rescale_q(OPUS_SEEK_PREROLL_MS,
6680  (AVRational){1, 1000},
6681  (AVRational){1, 48000});
6682 
6683  return 0;
6684 }
6685 
6687 { MKTAG('A','C','L','R'), mov_read_aclr },
6688 { MKTAG('A','P','R','G'), mov_read_avid },
6689 { MKTAG('A','A','L','P'), mov_read_avid },
6690 { MKTAG('A','R','E','S'), mov_read_ares },
6691 { MKTAG('a','v','s','s'), mov_read_avss },
6692 { MKTAG('a','v','1','C'), mov_read_av1c },
6693 { MKTAG('c','h','p','l'), mov_read_chpl },
6694 { MKTAG('c','o','6','4'), mov_read_stco },
6695 { MKTAG('c','o','l','r'), mov_read_colr },
6696 { MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
6697 { MKTAG('d','i','n','f'), mov_read_default },
6698 { MKTAG('D','p','x','E'), mov_read_dpxe },
6699 { MKTAG('d','r','e','f'), mov_read_dref },
6700 { MKTAG('e','d','t','s'), mov_read_default },
6701 { MKTAG('e','l','s','t'), mov_read_elst },
6702 { MKTAG('e','n','d','a'), mov_read_enda },
6703 { MKTAG('f','i','e','l'), mov_read_fiel },
6704 { MKTAG('a','d','r','m'), mov_read_adrm },
6705 { MKTAG('f','t','y','p'), mov_read_ftyp },
6706 { MKTAG('g','l','b','l'), mov_read_glbl },
6707 { MKTAG('h','d','l','r'), mov_read_hdlr },
6708 { MKTAG('i','l','s','t'), mov_read_ilst },
6709 { MKTAG('j','p','2','h'), mov_read_jp2h },
6710 { MKTAG('m','d','a','t'), mov_read_mdat },
6711 { MKTAG('m','d','h','d'), mov_read_mdhd },
6712 { MKTAG('m','d','i','a'), mov_read_default },
6713 { MKTAG('m','e','t','a'), mov_read_meta },
6714 { MKTAG('m','i','n','f'), mov_read_default },
6715 { MKTAG('m','o','o','f'), mov_read_moof },
6716 { MKTAG('m','o','o','v'), mov_read_moov },
6717 { MKTAG('m','v','e','x'), mov_read_default },
6718 { MKTAG('m','v','h','d'), mov_read_mvhd },
6719 { MKTAG('S','M','I',' '), mov_read_svq3 },
6720 { MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */
6721 { MKTAG('a','v','c','C'), mov_read_glbl },
6722 { MKTAG('p','a','s','p'), mov_read_pasp },
6723 { MKTAG('s','i','d','x'), mov_read_sidx },
6724 { MKTAG('s','t','b','l'), mov_read_default },
6725 { MKTAG('s','t','c','o'), mov_read_stco },
6726 { MKTAG('s','t','p','s'), mov_read_stps },
6727 { MKTAG('s','t','r','f'), mov_read_strf },
6728 { MKTAG('s','t','s','c'), mov_read_stsc },
6729 { MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
6730 { MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
6731 { MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
6732 { MKTAG('s','t','t','s'), mov_read_stts },
6733 { MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
6734 { MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
6735 { MKTAG('t','f','d','t'), mov_read_tfdt },
6736 { MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
6737 { MKTAG('t','r','a','k'), mov_read_trak },
6738 { MKTAG('t','r','a','f'), mov_read_default },
6739 { MKTAG('t','r','e','f'), mov_read_default },
6740 { MKTAG('t','m','c','d'), mov_read_tmcd },
6741 { MKTAG('c','h','a','p'), mov_read_chap },
6742 { MKTAG('t','r','e','x'), mov_read_trex },
6743 { MKTAG('t','r','u','n'), mov_read_trun },
6744 { MKTAG('u','d','t','a'), mov_read_default },
6745 { MKTAG('w','a','v','e'), mov_read_wave },
6746 { MKTAG('e','s','d','s'), mov_read_esds },
6747 { MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */
6748 { MKTAG('d','e','c','3'), mov_read_dec3 }, /* EAC-3 info */
6749 { MKTAG('d','d','t','s'), mov_read_ddts }, /* DTS audio descriptor */
6750 { MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
6751 { MKTAG('w','f','e','x'), mov_read_wfex },
6752 { MKTAG('c','m','o','v'), mov_read_cmov },
6753 { MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */
6754 { MKTAG('d','v','c','1'), mov_read_dvc1 },
6755 { MKTAG('s','b','g','p'), mov_read_sbgp },
6756 { MKTAG('h','v','c','C'), mov_read_glbl },
6757 { MKTAG('u','u','i','d'), mov_read_uuid },
6758 { MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },
6759 { MKTAG('f','r','e','e'), mov_read_free },
6760 { MKTAG('-','-','-','-'), mov_read_custom },
6761 { MKTAG('s','i','n','f'), mov_read_default },
6762 { MKTAG('f','r','m','a'), mov_read_frma },
6763 { MKTAG('s','e','n','c'), mov_read_senc },
6764 { MKTAG('s','a','i','z'), mov_read_saiz },
6765 { MKTAG('s','a','i','o'), mov_read_saio },
6766 { MKTAG('p','s','s','h'), mov_read_pssh },
6767 { MKTAG('s','c','h','m'), mov_read_schm },
6768 { MKTAG('s','c','h','i'), mov_read_default },
6769 { MKTAG('t','e','n','c'), mov_read_tenc },
6770 { MKTAG('d','f','L','a'), mov_read_dfla },
6771 { MKTAG('s','t','3','d'), mov_read_st3d }, /* stereoscopic 3D video box */
6772 { MKTAG('s','v','3','d'), mov_read_sv3d }, /* spherical video box */
6773 { MKTAG('d','O','p','s'), mov_read_dops },
6774 { MKTAG('S','m','D','m'), mov_read_smdm },
6775 { MKTAG('C','o','L','L'), mov_read_coll },
6776 { MKTAG('v','p','c','C'), mov_read_vpcc },
6777 { MKTAG('m','d','c','v'), mov_read_mdcv },
6778 { MKTAG('c','l','l','i'), mov_read_clli },
6779 { 0, NULL }
6780 };
6781 
6783 {
6784  int64_t total_size = 0;
6785  MOVAtom a;
6786  int i;
6787 
6788  if (c->atom_depth > 10) {
6789  av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");
6790  return AVERROR_INVALIDDATA;
6791  }
6792  c->atom_depth ++;
6793 
6794  if (atom.size < 0)
6795  atom.size = INT64_MAX;
6796  while (total_size <= atom.size - 8 && !avio_feof(pb)) {
6798  a.size = atom.size;
6799  a.type=0;
6800  if (atom.size >= 8) {
6801  a.size = avio_rb32(pb);
6802  a.type = avio_rl32(pb);
6803  if (a.type == MKTAG('f','r','e','e') &&
6804  a.size >= 8 &&
6806  c->moov_retry) {
6807  uint8_t buf[8];
6808  uint32_t *type = (uint32_t *)buf + 1;
6809  if (avio_read(pb, buf, 8) != 8)
6810  return AVERROR_INVALIDDATA;
6811  avio_seek(pb, -8, SEEK_CUR);
6812  if (*type == MKTAG('m','v','h','d') ||
6813  *type == MKTAG('c','m','o','v')) {
6814  av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free atom.\n");
6815  a.type = MKTAG('m','o','o','v');
6816  }
6817  }
6818  if (atom.type != MKTAG('r','o','o','t') &&
6819  atom.type != MKTAG('m','o','o','v'))
6820  {
6821  if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))
6822  {
6823  av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
6824  avio_skip(pb, -8);
6825  c->atom_depth --;
6826  return 0;
6827  }
6828  }
6829  total_size += 8;
6830  if (a.size == 1 && total_size + 8 <= atom.size) { /* 64 bit extended size */
6831  a.size = avio_rb64(pb) - 8;
6832  total_size += 8;
6833  }
6834  }
6835  av_log(c->fc, AV_LOG_TRACE, "type:'%s' parent:'%s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
6836  av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
6837  if (a.size == 0) {
6838  a.size = atom.size - total_size + 8;
6839  }
6840  a.size -= 8;
6841  if (a.size < 0)
6842  break;
6843  a.size = FFMIN(a.size, atom.size - total_size);
6844 
6845  for (i = 0; mov_default_parse_table[i].type; i++)
6846  if (mov_default_parse_table[i].type == a.type) {
6847  parse = mov_default_parse_table[i].parse;
6848  break;
6849  }
6850 
6851  // container is user data
6852  if (!parse && (atom.type == MKTAG('u','d','t','a') ||
6853  atom.type == MKTAG('i','l','s','t')))
6855 
6856  // Supports parsing the QuickTime Metadata Keys.
6857  // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
6858  if (!parse && c->found_hdlr_mdta &&
6859  atom.type == MKTAG('m','e','t','a') &&
6860  a.type == MKTAG('k','e','y','s')) {
6861  parse = mov_read_keys;
6862  }
6863 
6864  if (!parse) { /* skip leaf atoms data */
6865  avio_skip(pb, a.size);
6866  } else {
6867  int64_t start_pos = avio_tell(pb);
6868  int64_t left;
6869  int err = parse(c, pb, a);
6870  if (err < 0) {
6871  c->atom_depth --;
6872  return err;
6873  }
6874  if (c->found_moov && c->found_mdat &&
6876  start_pos + a.size == avio_size(pb))) {
6878  c->next_root_atom = start_pos + a.size;
6879  c->atom_depth --;
6880  return 0;
6881  }
6882  left = a.size - avio_tell(pb) + start_pos;
6883  if (left > 0) /* skip garbage at atom end */
6884  avio_skip(pb, left);
6885  else if (left < 0) {
6886  av_log(c->fc, AV_LOG_WARNING,
6887  "overread end of atom '%.4s' by %"PRId64" bytes\n",
6888  (char*)&a.type, -left);
6889  avio_seek(pb, left, SEEK_CUR);
6890  }
6891  }
6892 
6893  total_size += a.size;
6894  }
6895 
6896  if (total_size < atom.size && atom.size < 0x7ffff)
6897  avio_skip(pb, atom.size - total_size);
6898 
6899  c->atom_depth --;
6900  return 0;
6901 }
6902 
6903 static int mov_probe(const AVProbeData *p)
6904 {
6905  int64_t offset;
6906  uint32_t tag;
6907  int score = 0;
6908  int moov_offset = -1;
6909 
6910  /* check file header */
6911  offset = 0;
6912  for (;;) {
6913  /* ignore invalid offset */
6914  if ((offset + 8) > (unsigned int)p->buf_size)
6915  break;
6916  tag = AV_RL32(p->buf + offset + 4);
6917  switch(tag) {
6918  /* check for obvious tags */
6919  case MKTAG('m','o','o','v'):
6920  moov_offset = offset + 4;
6921  case MKTAG('m','d','a','t'):
6922  case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
6923  case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
6924  case MKTAG('f','t','y','p'):
6925  if (AV_RB32(p->buf+offset) < 8 &&
6926  (AV_RB32(p->buf+offset) != 1 ||
6927  offset + 12 > (unsigned int)p->buf_size ||
6928  AV_RB64(p->buf+offset + 8) == 0)) {
6929  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
6930  } else if (tag == MKTAG('f','t','y','p') &&
6931  ( AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')
6932  || AV_RL32(p->buf + offset + 8) == MKTAG('j','p','x',' ')
6933  )) {
6934  score = FFMAX(score, 5);
6935  } else {
6936  score = AVPROBE_SCORE_MAX;
6937  }
6938  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6939  break;
6940  /* those are more common words, so rate then a bit less */
6941  case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
6942  case MKTAG('w','i','d','e'):
6943  case MKTAG('f','r','e','e'):
6944  case MKTAG('j','u','n','k'):
6945  case MKTAG('p','i','c','t'):
6946  score = FFMAX(score, AVPROBE_SCORE_MAX - 5);
6947  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6948  break;
6949  case MKTAG(0x82,0x82,0x7f,0x7d):
6950  case MKTAG('s','k','i','p'):
6951  case MKTAG('u','u','i','d'):
6952  case MKTAG('p','r','f','l'):
6953  /* if we only find those cause probedata is too small at least rate them */
6954  score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
6955  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6956  break;
6957  default:
6958  offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
6959  }
6960  }
6961  if(score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
6962  /* moov atom in the header - we should make sure that this is not a
6963  * MOV-packed MPEG-PS */
6964  offset = moov_offset;
6965 
6966  while(offset < (p->buf_size - 16)){ /* Sufficient space */
6967  /* We found an actual hdlr atom */
6968  if(AV_RL32(p->buf + offset ) == MKTAG('h','d','l','r') &&
6969  AV_RL32(p->buf + offset + 8) == MKTAG('m','h','l','r') &&
6970  AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
6971  av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
6972  /* We found a media handler reference atom describing an
6973  * MPEG-PS-in-MOV, return a
6974  * low score to force expanding the probe window until
6975  * mpegps_probe finds what it needs */
6976  return 5;
6977  }else
6978  /* Keep looking */
6979  offset+=2;
6980  }
6981  }
6982 
6983  return score;
6984 }
6985 
6986 // must be done after parsing all trak because there's no order requirement
6988 {
6989  MOVContext *mov = s->priv_data;
6990  AVStream *st;
6991  MOVStreamContext *sc;
6992  int64_t cur_pos;
6993  int i, j;
6994  int chapter_track;
6995 
6996  for (j = 0; j < mov->nb_chapter_tracks; j++) {
6997  chapter_track = mov->chapter_tracks[j];
6998  st = NULL;
6999  for (i = 0; i < s->nb_streams; i++)
7000  if (s->streams[i]->id == chapter_track) {
7001  st = s->streams[i];
7002  break;
7003  }
7004  if (!st) {
7005  av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
7006  continue;
7007  }
7008 
7009  sc = st->priv_data;
7010  cur_pos = avio_tell(sc->pb);
7011 
7012  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
7014  if (st->nb_index_entries) {
7015  // Retrieve the first frame, if possible
7016  AVPacket pkt;
7017  AVIndexEntry *sample = &st->index_entries[0];
7018  if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7019  av_log(s, AV_LOG_ERROR, "Failed to retrieve first frame\n");
7020  goto finish;
7021  }
7022 
7023  if (av_get_packet(sc->pb, &pkt, sample->size) < 0)
7024  goto finish;
7025 
7026  st->attached_pic = pkt;
7027  st->attached_pic.stream_index = st->index;
7029  }
7030  } else {
7033  st->discard = AVDISCARD_ALL;
7034  for (i = 0; i < st->nb_index_entries; i++) {
7036  int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
7037  uint8_t *title;
7038  uint16_t ch;
7039  int len, title_len;
7040 
7041  if (end < sample->timestamp) {
7042  av_log(s, AV_LOG_WARNING, "ignoring stream duration which is shorter than chapters\n");
7043  end = AV_NOPTS_VALUE;
7044  }
7045 
7046  if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7047  av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
7048  goto finish;
7049  }
7050 
7051  // the first two bytes are the length of the title
7052  len = avio_rb16(sc->pb);
7053  if (len > sample->size-2)
7054  continue;
7055  title_len = 2*len + 1;
7056  if (!(title = av_mallocz(title_len)))
7057  goto finish;
7058 
7059  // The samples could theoretically be in any encoding if there's an encd
7060  // atom following, but in practice are only utf-8 or utf-16, distinguished
7061  // instead by the presence of a BOM
7062  if (!len) {
7063  title[0] = 0;
7064  } else {
7065  ch = avio_rb16(sc->pb);
7066  if (ch == 0xfeff)
7067  avio_get_str16be(sc->pb, len, title, title_len);
7068  else if (ch == 0xfffe)
7069  avio_get_str16le(sc->pb, len, title, title_len);
7070  else {
7071  AV_WB16(title, ch);
7072  if (len == 1 || len == 2)
7073  title[len] = 0;
7074  else
7075  avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
7076  }
7077  }
7078 
7079  avpriv_new_chapter(s, i, st->time_base, sample->timestamp, end, title);
7080  av_freep(&title);
7081  }
7082  }
7083 finish:
7084  avio_seek(sc->pb, cur_pos, SEEK_SET);
7085  }
7086 }
7087 
7089  uint32_t value, int flags)
7090 {
7091  AVTimecode tc;
7092  char buf[AV_TIMECODE_STR_SIZE];
7093  AVRational rate = st->avg_frame_rate;
7094  int ret = av_timecode_init(&tc, rate, flags, 0, s);
7095  if (ret < 0)
7096  return ret;
7097  av_dict_set(&st->metadata, "timecode",
7098  av_timecode_make_string(&tc, buf, value), 0);
7099  return 0;
7100 }
7101 
7103 {
7104  MOVStreamContext *sc = st->priv_data;
7105  char buf[AV_TIMECODE_STR_SIZE];
7106  int64_t cur_pos = avio_tell(sc->pb);
7107  int hh, mm, ss, ff, drop;
7108 
7109  if (!st->nb_index_entries)
7110  return -1;
7111 
7112  avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7113  avio_skip(s->pb, 13);
7114  hh = avio_r8(s->pb);
7115  mm = avio_r8(s->pb);
7116  ss = avio_r8(s->pb);
7117  drop = avio_r8(s->pb);
7118  ff = avio_r8(s->pb);
7119  snprintf(buf, AV_TIMECODE_STR_SIZE, "%02d:%02d:%02d%c%02d",
7120  hh, mm, ss, drop ? ';' : ':', ff);
7121  av_dict_set(&st->metadata, "timecode", buf, 0);
7122 
7123  avio_seek(sc->pb, cur_pos, SEEK_SET);
7124  return 0;
7125 }
7126 
7128 {
7129  MOVStreamContext *sc = st->priv_data;
7130  int flags = 0;
7131  int64_t cur_pos = avio_tell(sc->pb);
7132  uint32_t value;
7133 
7134  if (!st->nb_index_entries)
7135  return -1;
7136 
7137  avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7138  value = avio_rb32(s->pb);
7139 
7140  if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
7141  if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
7142  if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
7143 
7144  /* Assume Counter flag is set to 1 in tmcd track (even though it is likely
7145  * not the case) and thus assume "frame number format" instead of QT one.
7146  * No sample with tmcd track can be found with a QT timecode at the moment,
7147  * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
7148  * format). */
7149  parse_timecode_in_framenum_format(s, st, value, flags);
7150 
7151  avio_seek(sc->pb, cur_pos, SEEK_SET);
7152  return 0;
7153 }
7154 
7156  int i;
7157  if (!index || !*index) return;
7158  for (i = 0; i < (*index)->nb_encrypted_samples; i++) {
7159  av_encryption_info_free((*index)->encrypted_samples[i]);
7160  }
7161  av_freep(&(*index)->encrypted_samples);
7162  av_freep(&(*index)->auxiliary_info_sizes);
7163  av_freep(&(*index)->auxiliary_offsets);
7164  av_freep(index);
7165 }
7166 
7168 {
7169  MOVContext *mov = s->priv_data;
7170  int i, j;
7171 
7172  for (i = 0; i < s->nb_streams; i++) {
7173  AVStream *st = s->streams[i];
7174  MOVStreamContext *sc = st->priv_data;
7175 
7176  if (!sc)
7177  continue;
7178 
7179  av_freep(&sc->ctts_data);
7180  for (j = 0; j < sc->drefs_count; j++) {
7181  av_freep(&sc->drefs[j].path);
7182  av_freep(&sc->drefs[j].dir);
7183  }
7184  av_freep(&sc->drefs);
7185 
7186  sc->drefs_count = 0;
7187 
7188  if (!sc->pb_is_copied)
7189  ff_format_io_close(s, &sc->pb);
7190 
7191  sc->pb = NULL;
7192  av_freep(&sc->chunk_offsets);
7193  av_freep(&sc->stsc_data);
7194  av_freep(&sc->sample_sizes);
7195  av_freep(&sc->keyframes);
7196  av_freep(&sc->stts_data);
7197  av_freep(&sc->stps_data);
7198  av_freep(&sc->elst_data);
7199  av_freep(&sc->rap_group);
7200  av_freep(&sc->display_matrix);
7201  av_freep(&sc->index_ranges);
7202 
7203  if (sc->extradata)
7204  for (j = 0; j < sc->stsd_count; j++)
7205  av_free(sc->extradata[j]);
7206  av_freep(&sc->extradata);
7207  av_freep(&sc->extradata_size);
7208 
7212 
7213  av_freep(&sc->stereo3d);
7214  av_freep(&sc->spherical);
7215  av_freep(&sc->mastering);
7216  av_freep(&sc->coll);
7217  }
7218 
7219  if (mov->dv_demux) {
7221  mov->dv_fctx = NULL;
7222  }
7223 
7224  if (mov->meta_keys) {
7225  for (i = 1; i < mov->meta_keys_count; i++) {
7226  av_freep(&mov->meta_keys[i]);
7227  }
7228  av_freep(&mov->meta_keys);
7229  }
7230 
7231  av_freep(&mov->trex_data);
7232  av_freep(&mov->bitrates);
7233 
7234  for (i = 0; i < mov->frag_index.nb_items; i++) {
7236  for (j = 0; j < mov->frag_index.item[i].nb_stream_info; j++) {
7237  mov_free_encryption_index(&frag[j].encryption_index);
7238  }
7239  av_freep(&mov->frag_index.item[i].stream_info);
7240  }
7241  av_freep(&mov->frag_index.item);
7242 
7243  av_freep(&mov->aes_decrypt);
7244  av_freep(&mov->chapter_tracks);
7245 
7246  return 0;
7247 }
7248 
7249 static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
7250 {
7251  int i;
7252 
7253  for (i = 0; i < s->nb_streams; i++) {
7254  AVStream *st = s->streams[i];
7255  MOVStreamContext *sc = st->priv_data;
7256 
7257  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
7258  sc->timecode_track == tmcd_id)
7259  return 1;
7260  }
7261  return 0;
7262 }
7263 
7264 /* look for a tmcd track not referenced by any video track, and export it globally */
7266 {
7267  int i;
7268 
7269  for (i = 0; i < s->nb_streams; i++) {
7270  AVStream *st = s->streams[i];
7271 
7272  if (st->codecpar->codec_tag == MKTAG('t','m','c','d') &&
7273  !tmcd_is_referenced(s, i + 1)) {
7274  AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
7275  if (tcr) {
7276  av_dict_set(&s->metadata, "timecode", tcr->value, 0);
7277  break;
7278  }
7279  }
7280  }
7281 }
7282 
7283 static int read_tfra(MOVContext *mov, AVIOContext *f)
7284 {
7285  int version, fieldlength, i, j;
7286  int64_t pos = avio_tell(f);
7287  uint32_t size = avio_rb32(f);
7288  unsigned track_id, item_count;
7289 
7290  if (avio_rb32(f) != MKBETAG('t', 'f', 'r', 'a')) {
7291  return 1;
7292  }
7293  av_log(mov->fc, AV_LOG_VERBOSE, "found tfra\n");
7294 
7295  version = avio_r8(f);
7296  avio_rb24(f);
7297  track_id = avio_rb32(f);
7298  fieldlength = avio_rb32(f);
7299  item_count = avio_rb32(f);
7300  for (i = 0; i < item_count; i++) {
7301  int64_t time, offset;
7302  int index;
7303  MOVFragmentStreamInfo * frag_stream_info;
7304 
7305  if (avio_feof(f)) {
7306  return AVERROR_INVALIDDATA;
7307  }
7308 
7309  if (version == 1) {
7310  time = avio_rb64(f);
7311  offset = avio_rb64(f);
7312  } else {
7313  time = avio_rb32(f);
7314  offset = avio_rb32(f);
7315  }
7316 
7317  // The first sample of each stream in a fragment is always a random
7318  // access sample. So it's entry in the tfra can be used as the
7319  // initial PTS of the fragment.
7320  index = update_frag_index(mov, offset);
7321  frag_stream_info = get_frag_stream_info(&mov->frag_index, index, track_id);
7322  if (frag_stream_info &&
7323  frag_stream_info->first_tfra_pts == AV_NOPTS_VALUE)
7324  frag_stream_info->first_tfra_pts = time;
7325 
7326  for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
7327  avio_r8(f);
7328  for (j = 0; j < ((fieldlength >> 2) & 3) + 1; j++)
7329  avio_r8(f);
7330  for (j = 0; j < ((fieldlength >> 0) & 3) + 1; j++)
7331  avio_r8(f);
7332  }
7333 
7334  avio_seek(f, pos + size, SEEK_SET);
7335  return 0;
7336 }
7337 
7339 {
7340  int64_t stream_size = avio_size(f);
7341  int64_t original_pos = avio_tell(f);
7342  int64_t seek_ret;
7343  int32_t mfra_size;
7344  int ret = -1;
7345  if ((seek_ret = avio_seek(f, stream_size - 4, SEEK_SET)) < 0) {
7346  ret = seek_ret;
7347  goto fail;
7348  }
7349  mfra_size = avio_rb32(f);
7350  if (mfra_size < 0 || mfra_size > stream_size) {
7351  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (unreasonable size)\n");
7352  goto fail;
7353  }
7354  if ((seek_ret = avio_seek(f, -mfra_size, SEEK_CUR)) < 0) {
7355  ret = seek_ret;
7356  goto fail;
7357  }
7358  if (avio_rb32(f) != mfra_size) {
7359  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (size mismatch)\n");
7360  goto fail;
7361  }
7362  if (avio_rb32(f) != MKBETAG('m', 'f', 'r', 'a')) {
7363  av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (tag mismatch)\n");
7364  goto fail;
7365  }
7366  av_log(c->fc, AV_LOG_VERBOSE, "stream has mfra\n");
7367  do {
7368  ret = read_tfra(c, f);
7369  if (ret < 0)
7370  goto fail;
7371  } while (!ret);
7372  ret = 0;
7373 fail:
7374  seek_ret = avio_seek(f, original_pos, SEEK_SET);
7375  if (seek_ret < 0) {
7376  av_log(c->fc, AV_LOG_ERROR,
7377  "failed to seek back after looking for mfra\n");
7378  ret = seek_ret;
7379  }
7380  return ret;
7381 }
7382 
7384 {
7385  MOVContext *mov = s->priv_data;
7386  AVIOContext *pb = s->pb;
7387  int j, err;
7388  MOVAtom atom = { AV_RL32("root") };
7389  int i;
7390 
7391  if (mov->decryption_key_len != 0 && mov->decryption_key_len != AES_CTR_KEY_SIZE) {
7392  av_log(s, AV_LOG_ERROR, "Invalid decryption key len %d expected %d\n",
7394  return AVERROR(EINVAL);
7395  }
7396 
7397  mov->fc = s;
7398  mov->trak_index = -1;
7399  /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
7400  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
7401  atom.size = avio_size(pb);
7402  else
7403  atom.size = INT64_MAX;
7404 
7405  /* check MOV header */
7406  do {
7407  if (mov->moov_retry)
7408  avio_seek(pb, 0, SEEK_SET);
7409  if ((err = mov_read_default(mov, pb, atom)) < 0) {
7410  av_log(s, AV_LOG_ERROR, "error reading header\n");
7411  mov_read_close(s);
7412  return err;
7413  }
7414  } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->moov_retry++);
7415  if (!mov->found_moov) {
7416  av_log(s, AV_LOG_ERROR, "moov atom not found\n");
7417  mov_read_close(s);
7418  return AVERROR_INVALIDDATA;
7419  }
7420  av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
7421 
7422  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
7423  if (mov->nb_chapter_tracks > 0 && !mov->ignore_chapters)
7424  mov_read_chapters(s);
7425  for (i = 0; i < s->nb_streams; i++)
7426  if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {
7427  mov_read_timecode_track(s, s->streams[i]);
7428  } else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
7429  mov_read_rtmd_track(s, s->streams[i]);
7430  }
7431  }
7432 
7433  /* copy timecode metadata from tmcd tracks to the related video streams */
7434  for (i = 0; i < s->nb_streams; i++) {
7435  AVStream *st = s->streams[i];
7436  MOVStreamContext *sc = st->priv_data;
7437  if (sc->timecode_track > 0) {
7438  AVDictionaryEntry *tcr;
7439  int tmcd_st_id = -1;
7440 
7441  for (j = 0; j < s->nb_streams; j++)
7442  if (s->streams[j]->id == sc->timecode_track)
7443  tmcd_st_id = j;
7444 
7445  if (tmcd_st_id < 0 || tmcd_st_id == i)
7446  continue;
7447  tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
7448  if (tcr)
7449  av_dict_set(&st->metadata, "timecode", tcr->value, 0);
7450  }
7451  }
7453 
7454  for (i = 0; i < s->nb_streams; i++) {
7455  AVStream *st = s->streams[i];
7456  MOVStreamContext *sc = st->priv_data;
7457  fix_timescale(mov, sc);
7459  st->skip_samples = sc->start_pad;
7460  }
7461  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)
7463  sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
7465  if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
7466  st->codecpar->width = sc->width;
7467  st->codecpar->height = sc->height;
7468  }
7470  if ((err = mov_rewrite_dvd_sub_extradata(st)) < 0)
7471  return err;
7472  }
7473  }
7474  if (mov->handbrake_version &&
7475  mov->handbrake_version <= 1000000*0 + 1000*10 + 2 && // 0.10.2
7477  ) {
7478  av_log(s, AV_LOG_VERBOSE, "Forcing full parsing for mp3 stream\n");
7480  }
7481  }
7482 
7483  if (mov->trex_data) {
7484  for (i = 0; i < s->nb_streams; i++) {
7485  AVStream *st = s->streams[i];
7486  MOVStreamContext *sc = st->priv_data;
7487  if (st->duration > 0) {
7488  if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7489  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7490  sc->data_size, sc->time_scale);
7491  mov_read_close(s);
7492  return AVERROR_INVALIDDATA;
7493  }
7494  st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
7495  }
7496  }
7497  }
7498 
7499  if (mov->use_mfra_for > 0) {
7500  for (i = 0; i < s->nb_streams; i++) {
7501  AVStream *st = s->streams[i];
7502  MOVStreamContext *sc = st->priv_data;
7503  if (sc->duration_for_fps > 0) {
7504  if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7505  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7506  sc->data_size, sc->time_scale);
7507  mov_read_close(s);
7508  return AVERROR_INVALIDDATA;
7509  }
7510  st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale /
7511  sc->duration_for_fps;
7512  }
7513  }
7514  }
7515 
7516  for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {
7517  if (mov->bitrates[i]) {
7518  s->streams[i]->codecpar->bit_rate = mov->bitrates[i];
7519  }
7520  }
7521 
7522  ff_rfps_calculate(s);
7523 
7524  for (i = 0; i < s->nb_streams; i++) {
7525  AVStream *st = s->streams[i];
7526  MOVStreamContext *sc = st->priv_data;
7527 
7528  switch (st->codecpar->codec_type) {
7529  case AVMEDIA_TYPE_AUDIO:
7530  err = ff_replaygain_export(st, s->metadata);
7531  if (err < 0) {
7532  mov_read_close(s);
7533  return err;
7534  }
7535  break;
7536  case AVMEDIA_TYPE_VIDEO:
7537  if (sc->display_matrix) {
7539  sizeof(int32_t) * 9);
7540  if (err < 0)
7541  return err;
7542 
7543  sc->display_matrix = NULL;
7544  }
7545  if (sc->stereo3d) {
7547  (uint8_t *)sc->stereo3d,
7548  sizeof(*sc->stereo3d));
7549  if (err < 0)
7550  return err;
7551 
7552  sc->stereo3d = NULL;
7553  }
7554  if (sc->spherical) {
7556  (uint8_t *)sc->spherical,
7557  sc->spherical_size);
7558  if (err < 0)
7559  return err;
7560 
7561  sc->spherical = NULL;
7562  }
7563  if (sc->mastering) {
7565  (uint8_t *)sc->mastering,
7566  sizeof(*sc->mastering));
7567  if (err < 0)
7568  return err;
7569 
7570  sc->mastering = NULL;
7571  }
7572  if (sc->coll) {
7574  (uint8_t *)sc->coll,
7575  sc->coll_size);
7576  if (err < 0)
7577  return err;
7578 
7579  sc->coll = NULL;
7580  }
7581  break;
7582  }
7583  }
7585 
7586  for (i = 0; i < mov->frag_index.nb_items; i++)
7587  if (mov->frag_index.item[i].moof_offset <= mov->fragment.moof_offset)
7588  mov->frag_index.item[i].headers_read = 1;
7589 
7590  return 0;
7591 }
7592 
7594 {
7596  int64_t best_dts = INT64_MAX;
7597  int i;
7598  for (i = 0; i < s->nb_streams; i++) {
7599  AVStream *avst = s->streams[i];
7600  MOVStreamContext *msc = avst->priv_data;
7601  if (msc->pb && msc->current_sample < avst->nb_index_entries) {
7602  AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
7603  int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
7604  av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
7605  if (!sample || (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && current_sample->pos < sample->pos) ||
7606  ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
7607  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
7608  ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
7609  (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
7610  sample = current_sample;
7611  best_dts = dts;
7612  *st = avst;
7613  }
7614  }
7615  }
7616  return sample;
7617 }
7618 
7619 static int should_retry(AVIOContext *pb, int error_code) {
7620  if (error_code == AVERROR_EOF || avio_feof(pb))
7621  return 0;
7622 
7623  return 1;
7624 }
7625 
7626 static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
7627 {
7628  int ret;
7629  MOVContext *mov = s->priv_data;
7630 
7631  if (index >= 0 && index < mov->frag_index.nb_items)
7632  target = mov->frag_index.item[index].moof_offset;
7633  if (avio_seek(s->pb, target, SEEK_SET) != target) {
7634  av_log(mov->fc, AV_LOG_ERROR, "root atom offset 0x%"PRIx64": partial file\n", target);
7635  return AVERROR_INVALIDDATA;
7636  }
7637 
7638  mov->next_root_atom = 0;
7639  if (index < 0 || index >= mov->frag_index.nb_items)
7640  index = search_frag_moof_offset(&mov->frag_index, target);
7641  if (index < mov->frag_index.nb_items) {
7642  if (index + 1 < mov->frag_index.nb_items)
7643  mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
7644  if (mov->frag_index.item[index].headers_read)
7645  return 0;
7646  mov->frag_index.item[index].headers_read = 1;
7647  }
7648 
7649  mov->found_mdat = 0;
7650 
7651  ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
7652  if (ret < 0)
7653  return ret;
7654  if (avio_feof(s->pb))
7655  return AVERROR_EOF;
7656  av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
7657 
7658  return 1;
7659 }
7660 
7662 {
7663  uint8_t *side, *extradata;
7664  int extradata_size;
7665 
7666  /* Save the current index. */
7667  sc->last_stsd_index = sc->stsc_data[sc->stsc_index].id - 1;
7668 
7669  /* Notify the decoder that extradata changed. */
7670  extradata_size = sc->extradata_size[sc->last_stsd_index];
7671  extradata = sc->extradata[sc->last_stsd_index];
7672  if (extradata_size > 0 && extradata) {
7673  side = av_packet_new_side_data(pkt,
7675  extradata_size);
7676  if (!side)
7677  return AVERROR(ENOMEM);
7678  memcpy(side, extradata, extradata_size);
7679  }
7680 
7681  return 0;
7682 }
7683 
7685 {
7686  MOVContext *mov = s->priv_data;
7687  MOVStreamContext *sc;
7689  AVStream *st = NULL;
7690  int64_t current_index;
7691  int ret;
7692  mov->fc = s;
7693  retry:
7694  sample = mov_find_next_sample(s, &st);
7695  if (!sample || (mov->next_root_atom && sample->pos > mov->next_root_atom)) {
7696  if (!mov->next_root_atom)
7697  return AVERROR_EOF;
7698  if ((ret = mov_switch_root(s, mov->next_root_atom, -1)) < 0)
7699  return ret;
7700  goto retry;
7701  }
7702  sc = st->priv_data;
7703  /* must be done just before reading, to avoid infinite loop on sample */
7704  current_index = sc->current_index;
7706 
7707  if (mov->next_root_atom) {
7708  sample->pos = FFMIN(sample->pos, mov->next_root_atom);
7709  sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));
7710  }
7711 
7712  if (st->discard != AVDISCARD_ALL) {
7713  int64_t ret64 = avio_seek(sc->pb, sample->pos, SEEK_SET);
7714  if (ret64 != sample->pos) {
7715  av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
7716  sc->ffindex, sample->pos);
7717  if (should_retry(sc->pb, ret64)) {
7719  }
7720  return AVERROR_INVALIDDATA;
7721  }
7722 
7723  if( st->discard == AVDISCARD_NONKEY && 0==(sample->flags & AVINDEX_KEYFRAME) ) {
7724  av_log(mov->fc, AV_LOG_DEBUG, "Nonkey frame from stream %d discarded due to AVDISCARD_NONKEY\n", sc->ffindex);
7725  goto retry;
7726  }
7727 
7728  ret = av_get_packet(sc->pb, pkt, sample->size);
7729  if (ret < 0) {
7730  if (should_retry(sc->pb, ret)) {
7732  }
7733  return ret;
7734  }
7735  if (sc->has_palette) {
7736  uint8_t *pal;
7737 
7739  if (!pal) {
7740  av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
7741  } else {
7742  memcpy(pal, sc->palette, AVPALETTE_SIZE);
7743  sc->has_palette = 0;
7744  }
7745  }
7746 #if CONFIG_DV_DEMUXER
7747  if (mov->dv_demux && sc->dv_audio_container) {
7748  avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);
7749  av_freep(&pkt->data);
7750  pkt->size = 0;
7751  ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
7752  if (ret < 0)
7753  return ret;
7754  }
7755 #endif
7756  if (st->codecpar->codec_id == AV_CODEC_ID_MP3 && !st->need_parsing && pkt->size > 4) {
7757  if (ff_mpa_check_header(AV_RB32(pkt->data)) < 0)
7759  }
7760  }
7761 
7762  pkt->stream_index = sc->ffindex;
7763  pkt->dts = sample->timestamp;
7764  if (sample->flags & AVINDEX_DISCARD_FRAME) {
7765  pkt->flags |= AV_PKT_FLAG_DISCARD;
7766  }
7767  if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {
7768  pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
7769  /* update ctts context */
7770  sc->ctts_sample++;
7771  if (sc->ctts_index < sc->ctts_count &&
7772  sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
7773  sc->ctts_index++;
7774  sc->ctts_sample = 0;
7775  }
7776  } else {
7777  int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
7779 
7780  if (next_dts >= pkt->dts)
7781  pkt->duration = next_dts - pkt->dts;
7782  pkt->pts = pkt->dts;
7783  }
7784  if (st->discard == AVDISCARD_ALL)
7785  goto retry;
7786  pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
7787  pkt->pos = sample->pos;
7788 
7789  /* Multiple stsd handling. */
7790  if (sc->stsc_data) {
7791  /* Keep track of the stsc index for the given sample, then check
7792  * if the stsd index is different from the last used one. */
7793  sc->stsc_sample++;
7794  if (mov_stsc_index_valid(sc->stsc_index, sc->stsc_count) &&
7795  mov_get_stsc_samples(sc, sc->stsc_index) == sc->stsc_sample) {
7796  sc->stsc_index++;
7797  sc->stsc_sample = 0;
7798  /* Do not check indexes after a switch. */
7799  } else if (sc->stsc_data[sc->stsc_index].id > 0 &&
7800  sc->stsc_data[sc->stsc_index].id - 1 < sc->stsd_count &&
7801  sc->stsc_data[sc->stsc_index].id - 1 != sc->last_stsd_index) {
7802  ret = mov_change_extradata(sc, pkt);
7803  if (ret < 0)
7804  return ret;
7805  }
7806  }
7807 
7808  if (mov->aax_mode)
7809  aax_filter(pkt->data, pkt->size, mov);
7810 
7811  ret = cenc_filter(mov, st, sc, pkt, current_index);
7812  if (ret < 0)
7813  return ret;
7814 
7815  return 0;
7816 }
7817 
7818 static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
7819 {
7820  MOVContext *mov = s->priv_data;
7821  int index;
7822 
7823  if (!mov->frag_index.complete)
7824  return 0;
7825 
7826  index = search_frag_timestamp(&mov->frag_index, st, timestamp);
7827  if (index < 0)
7828  index = 0;
7829  if (!mov->frag_index.item[index].headers_read)
7830  return mov_switch_root(s, -1, index);
7831  if (index + 1 < mov->frag_index.nb_items)
7832  mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
7833 
7834  return 0;
7835 }
7836 
7837 static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
7838 {
7839  MOVStreamContext *sc = st->priv_data;
7840  int sample, time_sample, ret;
7841  unsigned int i;
7842 
7843  // Here we consider timestamp to be PTS, hence try to offset it so that we
7844  // can search over the DTS timeline.
7845  timestamp -= (sc->min_corrected_pts + sc->dts_shift);
7846 
7847  ret = mov_seek_fragment(s, st, timestamp);
7848  if (ret < 0)
7849  return ret;
7850 
7851  sample = av_index_search_timestamp(st, timestamp, flags);
7852  av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
7853  if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
7854  sample = 0;
7855  if (sample < 0) /* not sure what to do */
7856  return AVERROR_INVALIDDATA;
7857  mov_current_sample_set(sc, sample);
7858  av_log(s, AV_LOG_TRACE, "stream %d, found sample %d\n", st->index, sc->current_sample);
7859  /* adjust ctts index */
7860  if (sc->ctts_data) {
7861  time_sample = 0;
7862  for (i = 0; i < sc->ctts_count; i++) {
7863  int next = time_sample + sc->ctts_data[i].count;
7864  if (next > sc->current_sample) {
7865  sc->ctts_index = i;
7866  sc->ctts_sample = sc->current_sample - time_sample;
7867  break;
7868  }
7869  time_sample = next;
7870  }
7871  }
7872 
7873  /* adjust stsd index */
7874  if (sc->chunk_count) {
7875  time_sample = 0;
7876  for (i = 0; i < sc->stsc_count; i++) {
7877  int64_t next = time_sample + mov_get_stsc_samples(sc, i);
7878  if (next > sc->current_sample) {
7879  sc->stsc_index = i;
7880  sc->stsc_sample = sc->current_sample - time_sample;
7881  break;
7882  }
7883  av_assert0(next == (int)next);
7884  time_sample = next;
7885  }
7886  }
7887 
7888  return sample;
7889 }
7890 
7891 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
7892 {
7893  MOVContext *mc = s->priv_data;
7894  AVStream *st;
7895  int sample;
7896  int i;
7897 
7898  if (stream_index >= s->nb_streams)
7899  return AVERROR_INVALIDDATA;
7900 
7901  st = s->streams[stream_index];
7902  sample = mov_seek_stream(s, st, sample_time, flags);
7903  if (sample < 0)
7904  return sample;
7905 
7906  if (mc->seek_individually) {
7907  /* adjust seek timestamp to found sample timestamp */
7908  int64_t seek_timestamp = st->index_entries[sample].timestamp;
7909 
7910  for (i = 0; i < s->nb_streams; i++) {
7911  int64_t timestamp;
7912  MOVStreamContext *sc = s->streams[i]->priv_data;
7913  st = s->streams[i];
7914  st->skip_samples = (sample_time <= 0) ? sc->start_pad : 0;
7915 
7916  if (stream_index == i)
7917  continue;
7918 
7919  timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
7920  mov_seek_stream(s, st, timestamp, flags);
7921  }
7922  } else {
7923  for (i = 0; i < s->nb_streams; i++) {
7924  MOVStreamContext *sc;
7925  st = s->streams[i];
7926  sc = st->priv_data;
7927  mov_current_sample_set(sc, 0);
7928  }
7929  while (1) {
7930  MOVStreamContext *sc;
7931  AVIndexEntry *entry = mov_find_next_sample(s, &st);
7932  if (!entry)
7933  return AVERROR_INVALIDDATA;
7934  sc = st->priv_data;
7935  if (sc->ffindex == stream_index && sc->current_sample == sample)
7936  break;
7938  }
7939  }
7940  return 0;
7941 }
7942 
7943 #define OFFSET(x) offsetof(MOVContext, x)
7944 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
7945 static const AVOption mov_options[] = {
7946  {"use_absolute_path",
7947  "allow using absolute path when opening alias, this is a possible security issue",
7948  OFFSET(use_absolute_path), AV_OPT_TYPE_BOOL, {.i64 = 0},
7949  0, 1, FLAGS},
7950  {"seek_streams_individually",
7951  "Seek each stream individually to the to the closest point",
7952  OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
7953  0, 1, FLAGS},
7954  {"ignore_editlist", "Ignore the edit list atom.", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
7955  0, 1, FLAGS},
7956  {"advanced_editlist",
7957  "Modify the AVIndex according to the editlists. Use this option to decode in the order specified by the edits.",
7958  OFFSET(advanced_editlist), AV_OPT_TYPE_BOOL, {.i64 = 1},
7959  0, 1, FLAGS},
7960  {"ignore_chapters", "", OFFSET(ignore_chapters), AV_OPT_TYPE_BOOL, {.i64 = 0},
7961  0, 1, FLAGS},
7962  {"use_mfra_for",
7963  "use mfra for fragment timestamps",
7964  OFFSET(use_mfra_for), AV_OPT_TYPE_INT, {.i64 = FF_MOV_FLAG_MFRA_AUTO},
7966  "use_mfra_for"},
7967  {"auto", "auto", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_AUTO}, 0, 0,
7968  FLAGS, "use_mfra_for" },
7969  {"dts", "dts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_DTS}, 0, 0,
7970  FLAGS, "use_mfra_for" },
7971  {"pts", "pts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_PTS}, 0, 0,
7972  FLAGS, "use_mfra_for" },
7973  { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
7974  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
7975  { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
7976  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
7977  { "activation_bytes", "Secret bytes for Audible AAX files", OFFSET(activation_bytes),
7979  { "audible_fixed_key", // extracted from libAAX_SDK.so and AAXSDKWin.dll files!
7980  "Fixed key used for handling Audible AAX files", OFFSET(audible_fixed_key),
7981  AV_OPT_TYPE_BINARY, {.str="77214d4b196a87cd520045fd20a51d67"},
7982  .flags = AV_OPT_FLAG_DECODING_PARAM },
7983  { "decryption_key", "The media decryption key (hex)", OFFSET(decryption_key), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
7984  { "enable_drefs", "Enable external track support.", OFFSET(enable_drefs), AV_OPT_TYPE_BOOL,
7985  {.i64 = 0}, 0, 1, FLAGS },
7986 
7987  { NULL },
7988 };
7989 
7990 static const AVClass mov_class = {
7991  .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
7992  .item_name = av_default_item_name,
7993  .option = mov_options,
7994  .version = LIBAVUTIL_VERSION_INT,
7995 };
7996 
7998  .name = "mov,mp4,m4a,3gp,3g2,mj2",
7999  .long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
8000  .priv_class = &mov_class,
8001  .priv_data_size = sizeof(MOVContext),
8002  .extensions = "mov,mp4,m4a,3gp,3g2,mj2",
8003  .read_probe = mov_probe,
8009 };
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:7626
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:5066
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:7661
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:7593
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:7155
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:7249
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:6104
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:5609
#define IS_MATRIX_IDENT(matrix)
Definition: mov.c:4433
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:5672
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:7265
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:7619
#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:5429
Format I/O context.
Definition: avformat.h:1358
static int mov_read_header(AVFormatContext *s)
Definition: mov.c:7383
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:7945
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:6638
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:7997
unsigned int count
Definition: isom.h:110
static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5086
static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVStreamContext *sc, AVEncryptionInfo **sample, int use_subsamples)
Definition: mov.c:5905
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:5855
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:5808
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:6077
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:1514
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:5248
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:5334
static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:5140
static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOContext *pb, MOVEncryptionIndex *encryption_index)
Definition: mov.c:6010
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:5373
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:4683
#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:4958
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:4441
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:6782
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:7837
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:5405
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:4600
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:5209
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:5956
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:6574
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:7944
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:7127
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:4559
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:4645
#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:7943
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:7684
static int mov_read_close(AVFormatContext *s)
Definition: mov.c:7167
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:6518
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:5220
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:6481
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:7891
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:6271
static void mov_read_chapters(AVFormatContext *s)
Definition: mov.c:6987
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:7283
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:5786
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:6903
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:6379
static int mov_read_tenc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Definition: mov.c:6410
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:7102
#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:5292
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:6686
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:7088
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:7818
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:5472
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:7338
uint8_t file_iv[20]
Definition: isom.h:281
static const AVClass mov_class
Definition: mov.c:7990
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:4619
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:6176