3 * Copyright (c) 2001 Fabrice Bellard.
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "libavcodec/mpeg4audio.h"
31 #include "libavcodec/mpegaudiodata.h"
38 * First version by Francois Revol revol@free.fr
39 * Seek function by Gael Chardon gael.dev@4now.net
41 * Features and limitations:
42 * - reads most of the QT files I have (at least the structure),
43 * Sample QuickTime files with mp3 audio can be found at: http://www.3ivx.com/showcase.html
44 * - the code is quite ugly... maybe I won't do it recursive next time :-)
46 * Funny I didn't know about http://sourceforge.net/projects/qt-ffmpeg/
47 * when coding this :) (it's a writer anyway)
49 * Reference documents:
50 * http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt
52 * http://developer.apple.com/documentation/QuickTime/QTFF/
53 * http://developer.apple.com/documentation/QuickTime/QTFF/qtff.pdf
54 * QuickTime is a trademark of Apple (AFAIK :))
57 #include "qtpalette.h"
63 /* the QuickTime file format is quite convoluted...
64 * it has lots of index tables, each indexing something in another one...
65 * Here we just use what is needed to read the chunks
82 int64_t size
; /* total size (excluding the size and type fields) */
85 struct MOVParseTableEntry
;
89 uint64_t base_data_offset
;
105 typedef struct MOVStreamContext
{
107 int ffindex
; /* the ffmpeg stream id */
109 unsigned int chunk_count
;
110 int64_t *chunk_offsets
;
111 unsigned int stts_count
;
112 MOV_stts_t
*stts_data
;
113 unsigned int ctts_count
;
114 MOV_stts_t
*ctts_data
;
115 unsigned int edit_count
; /* number of 'edit' (elst atom) */
116 unsigned int sample_to_chunk_sz
;
117 MOV_stsc_t
*sample_to_chunk
;
118 int sample_to_ctime_index
;
119 int sample_to_ctime_sample
;
120 unsigned int sample_size
;
121 unsigned int sample_count
;
123 unsigned int keyframe_count
;
128 unsigned int bytes_per_frame
;
129 unsigned int samples_per_frame
;
130 int dv_audio_container
;
131 int pseudo_stream_id
; ///< -1 means demux all ids
132 int16_t audio_cid
; ///< stsd audio compression id
133 unsigned drefs_count
;
138 typedef struct MOVContext
{
141 int64_t duration
; /* duration of the longest track */
142 int found_moov
; /* when both 'moov' and 'mdat' sections has been found */
143 int found_mdat
; /* we suppose we have enough data to read the file */
144 AVPaletteControl palette_control
;
145 DVDemuxContext
*dv_demux
;
146 AVFormatContext
*dv_fctx
;
147 int isom
; /* 1 if file is ISO Media (mp4/3gp) */
148 MOVFragment fragment
; ///< current fragment in moof atom
149 MOVTrackExt
*trex_data
;
154 /* XXX: it's the first time I make a recursive parser I think... sorry if it's ugly :P */
156 /* those functions parse an atom */
158 0: continue to parse next atom
159 <0: error occurred, exit
161 /* links atom IDs to parse functions */
162 typedef struct MOVParseTableEntry
{
164 int (*parse
)(MOVContext
*ctx
, ByteIOContext
*pb
, MOV_atom_t atom
);
165 } MOVParseTableEntry
;
167 static const MOVParseTableEntry mov_default_parse_table
[];
169 static int mov_read_default(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
171 int64_t total_size
= 0;
176 a
.offset
= atom
.offset
;
179 atom
.size
= INT64_MAX
;
180 while(((total_size
+ 8) < atom
.size
) && !url_feof(pb
) && !err
) {
184 a
.size
= get_be32(pb
);
185 a
.type
= get_le32(pb
);
189 dprintf(c
->fc
, "type: %08x %.4s sz: %"PRIx64
" %"PRIx64
" %"PRIx64
"\n",
190 a
.type
, (char*)&a
.type
, a
.size
, atom
.size
, total_size
);
191 if (a
.size
== 1) { /* 64 bit extended size */
192 a
.size
= get_be64(pb
) - 8;
197 a
.size
= atom
.size
- total_size
;
204 a
.size
= FFMIN(a
.size
, atom
.size
- total_size
);
206 for (i
= 0; mov_default_parse_table
[i
].type
!= 0
207 && mov_default_parse_table
[i
].type
!= a
.type
; i
++)
210 if (mov_default_parse_table
[i
].type
== 0) { /* skip leaf atoms data */
211 url_fskip(pb
, a
.size
);
213 offset_t start_pos
= url_ftell(pb
);
215 err
= mov_default_parse_table
[i
].parse(c
, pb
, a
);
216 if (url_is_streamed(pb
) && c
->found_moov
&& c
->found_mdat
)
218 left
= a
.size
- url_ftell(pb
) + start_pos
;
219 if (left
> 0) /* skip garbage at atom end */
224 total_size
+= a
.size
;
227 if (!err
&& total_size
< atom
.size
&& atom
.size
< 0x7ffff)
228 url_fskip(pb
, atom
.size
- total_size
);
233 static int mov_read_dref(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
235 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
236 MOVStreamContext
*sc
= st
->priv_data
;
239 get_be32(pb
); // version + flags
240 entries
= get_be32(pb
);
241 if (entries
>= UINT_MAX
/ sizeof(*sc
->drefs
))
243 sc
->drefs_count
= entries
;
244 sc
->drefs
= av_mallocz(entries
* sizeof(*sc
->drefs
));
246 for (i
= 0; i
< sc
->drefs_count
; i
++) {
247 MOV_dref_t
*dref
= &sc
->drefs
[i
];
248 uint32_t size
= get_be32(pb
);
249 offset_t next
= url_ftell(pb
) + size
- 4;
251 dref
->type
= get_le32(pb
);
252 get_be32(pb
); // version + flags
253 dprintf(c
->fc
, "type %.4s size %d\n", (char*)&dref
->type
, size
);
255 if (dref
->type
== MKTAG('a','l','i','s') && size
> 150) {
256 /* macintosh alias record */
257 uint16_t volume_len
, len
;
263 volume_len
= get_byte(pb
);
264 volume_len
= FFMIN(volume_len
, 27);
265 get_buffer(pb
, volume
, 27);
266 volume
[volume_len
] = 0;
267 av_log(c
->fc
, AV_LOG_DEBUG
, "volume %s, len %d\n", volume
, volume_len
);
271 for (type
= 0; type
!= -1 && url_ftell(pb
) < next
; ) {
274 av_log(c
->fc
, AV_LOG_DEBUG
, "type %d, len %d\n", type
, len
);
277 if (type
== 2) { // absolute path
279 dref
->path
= av_mallocz(len
+1);
281 return AVERROR(ENOMEM
);
282 get_buffer(pb
, dref
->path
, len
);
283 if (len
> volume_len
&& !strncmp(dref
->path
, volume
, volume_len
)) {
285 memmove(dref
->path
, dref
->path
+volume_len
, len
);
288 for (j
= 0; j
< len
; j
++)
289 if (dref
->path
[j
] == ':')
291 av_log(c
->fc
, AV_LOG_DEBUG
, "path %s\n", dref
->path
);
296 url_fseek(pb
, next
, SEEK_SET
);
301 static int mov_read_hdlr(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
303 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
307 get_byte(pb
); /* version */
308 get_be24(pb
); /* flags */
311 ctype
= get_le32(pb
);
312 type
= get_le32(pb
); /* component subtype */
314 dprintf(c
->fc
, "ctype= %c%c%c%c (0x%08x)\n", *((char *)&ctype
), ((char *)&ctype
)[1],
315 ((char *)&ctype
)[2], ((char *)&ctype
)[3], (int) ctype
);
316 dprintf(c
->fc
, "stype= %c%c%c%c\n",
317 *((char *)&type
), ((char *)&type
)[1], ((char *)&type
)[2], ((char *)&type
)[3]);
320 if (type
== MKTAG('v','i','d','e'))
321 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
322 else if(type
== MKTAG('s','o','u','n'))
323 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
324 else if(type
== MKTAG('m','1','a',' '))
325 st
->codec
->codec_id
= CODEC_ID_MP2
;
326 else if(type
== MKTAG('s','u','b','p')) {
327 st
->codec
->codec_type
= CODEC_TYPE_SUBTITLE
;
329 get_be32(pb
); /* component manufacture */
330 get_be32(pb
); /* component flags */
331 get_be32(pb
); /* component flags mask */
334 return 0; /* nothing left to read */
336 url_fskip(pb
, atom
.size
- (url_ftell(pb
) - atom
.offset
));
340 static int mp4_read_descr_len(ByteIOContext
*pb
)
345 int c
= get_byte(pb
);
346 len
= (len
<< 7) | (c
& 0x7f);
353 static int mp4_read_descr(MOVContext
*c
, ByteIOContext
*pb
, int *tag
)
357 len
= mp4_read_descr_len(pb
);
358 dprintf(c
->fc
, "MPEG4 description: tag=0x%02x len=%d\n", *tag
, len
);
362 #define MP4ESDescrTag 0x03
363 #define MP4DecConfigDescrTag 0x04
364 #define MP4DecSpecificDescrTag 0x05
366 static const AVCodecTag mp4_audio_types
[] = {
367 { CODEC_ID_MP3ON4
, 29 }, /* old mp3on4 draft */
368 { CODEC_ID_MP3ON4
, 32 }, /* layer 1 */
369 { CODEC_ID_MP3ON4
, 33 }, /* layer 2 */
370 { CODEC_ID_MP3ON4
, 34 }, /* layer 3 */
371 { CODEC_ID_NONE
, 0 },
374 static int mov_read_esds(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
376 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
379 get_be32(pb
); /* version + flags */
380 len
= mp4_read_descr(c
, pb
, &tag
);
381 if (tag
== MP4ESDescrTag
) {
382 get_be16(pb
); /* ID */
383 get_byte(pb
); /* priority */
385 get_be16(pb
); /* ID */
387 len
= mp4_read_descr(c
, pb
, &tag
);
388 if (tag
== MP4DecConfigDescrTag
) {
389 int object_type_id
= get_byte(pb
);
390 get_byte(pb
); /* stream type */
391 get_be24(pb
); /* buffer size db */
392 get_be32(pb
); /* max bitrate */
393 get_be32(pb
); /* avg bitrate */
395 st
->codec
->codec_id
= codec_get_id(ff_mp4_obj_type
, object_type_id
);
396 dprintf(c
->fc
, "esds object type id %d\n", object_type_id
);
397 len
= mp4_read_descr(c
, pb
, &tag
);
398 if (tag
== MP4DecSpecificDescrTag
) {
399 dprintf(c
->fc
, "Specific MPEG4 header len=%d\n", len
);
400 if((uint64_t)len
> (1<<30))
402 st
->codec
->extradata
= av_mallocz(len
+ FF_INPUT_BUFFER_PADDING_SIZE
);
403 if (!st
->codec
->extradata
)
404 return AVERROR(ENOMEM
);
405 get_buffer(pb
, st
->codec
->extradata
, len
);
406 st
->codec
->extradata_size
= len
;
407 if (st
->codec
->codec_id
== CODEC_ID_AAC
) {
408 MPEG4AudioConfig cfg
;
409 ff_mpeg4audio_get_config(&cfg
, st
->codec
->extradata
,
410 st
->codec
->extradata_size
);
411 if (cfg
.chan_config
> 7)
413 st
->codec
->channels
= ff_mpeg4audio_channels
[cfg
.chan_config
];
414 if (cfg
.object_type
== 29 && cfg
.sampling_index
< 3) // old mp3on4
415 st
->codec
->sample_rate
= ff_mpa_freq_tab
[cfg
.sampling_index
];
417 st
->codec
->sample_rate
= cfg
.sample_rate
; // ext sample rate ?
418 dprintf(c
->fc
, "mp4a config channels %d obj %d ext obj %d "
419 "sample rate %d ext sample rate %d\n", st
->codec
->channels
,
420 cfg
.object_type
, cfg
.ext_object_type
,
421 cfg
.sample_rate
, cfg
.ext_sample_rate
);
422 if (!(st
->codec
->codec_id
= codec_get_id(mp4_audio_types
,
424 st
->codec
->codec_id
= CODEC_ID_AAC
;
431 /* this atom contains actual media data */
432 static int mov_read_mdat(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
434 if(atom
.size
== 0) /* wrong one (MP4) */
437 return 0; /* now go for moov */
440 static int mov_read_ftyp(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
442 uint32_t type
= get_le32(pb
);
444 if (type
!= MKTAG('q','t',' ',' '))
446 av_log(c
->fc
, AV_LOG_DEBUG
, "ISO: File Type Major Brand: %.4s\n",(char *)&type
);
447 get_be32(pb
); /* minor version */
448 url_fskip(pb
, atom
.size
- 8);
452 /* this atom should contain all header atoms */
453 static int mov_read_moov(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
455 if (mov_read_default(c
, pb
, atom
) < 0)
457 /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
458 /* so we don't parse the whole file if over a network */
460 return 0; /* now go for mdat */
463 static int mov_read_moof(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
465 c
->fragment
.moof_offset
= url_ftell(pb
) - 8;
466 dprintf(c
->fc
, "moof offset %llx\n", c
->fragment
.moof_offset
);
467 return mov_read_default(c
, pb
, atom
);
470 static int mov_read_mdhd(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
472 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
473 MOVStreamContext
*sc
= st
->priv_data
;
474 int version
= get_byte(pb
);
478 return -1; /* unsupported */
480 get_be24(pb
); /* flags */
485 get_be32(pb
); /* creation time */
486 get_be32(pb
); /* modification time */
489 sc
->time_scale
= get_be32(pb
);
490 st
->duration
= (version
== 1) ? get_be64(pb
) : get_be32(pb
); /* duration */
492 lang
= get_be16(pb
); /* language */
493 ff_mov_lang_to_iso639(lang
, st
->language
);
494 get_be16(pb
); /* quality */
499 static int mov_read_mvhd(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
501 int version
= get_byte(pb
); /* version */
502 get_be24(pb
); /* flags */
508 get_be32(pb
); /* creation time */
509 get_be32(pb
); /* modification time */
511 c
->time_scale
= get_be32(pb
); /* time scale */
513 dprintf(c
->fc
, "time scale = %i\n", c
->time_scale
);
515 c
->duration
= (version
== 1) ? get_be64(pb
) : get_be32(pb
); /* duration */
516 get_be32(pb
); /* preferred scale */
518 get_be16(pb
); /* preferred volume */
520 url_fskip(pb
, 10); /* reserved */
522 url_fskip(pb
, 36); /* display matrix */
524 get_be32(pb
); /* preview time */
525 get_be32(pb
); /* preview duration */
526 get_be32(pb
); /* poster time */
527 get_be32(pb
); /* selection time */
528 get_be32(pb
); /* selection duration */
529 get_be32(pb
); /* current time */
530 get_be32(pb
); /* next track ID */
535 static int mov_read_smi(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
537 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
539 if((uint64_t)atom
.size
> (1<<30))
542 // currently SVQ3 decoder expect full STSD header - so let's fake it
543 // this should be fixed and just SMI header should be passed
544 av_free(st
->codec
->extradata
);
545 st
->codec
->extradata
= av_mallocz(atom
.size
+ 0x5a + FF_INPUT_BUFFER_PADDING_SIZE
);
546 if (!st
->codec
->extradata
)
547 return AVERROR(ENOMEM
);
548 st
->codec
->extradata_size
= 0x5a + atom
.size
;
549 memcpy(st
->codec
->extradata
, "SVQ3", 4); // fake
550 get_buffer(pb
, st
->codec
->extradata
+ 0x5a, atom
.size
);
551 dprintf(c
->fc
, "Reading SMI %"PRId64
" %s\n", atom
.size
, st
->codec
->extradata
+ 0x5a);
555 static int mov_read_enda(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
557 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
558 int little_endian
= get_be16(pb
);
561 switch (st
->codec
->codec_id
) {
562 case CODEC_ID_PCM_S24BE
:
563 st
->codec
->codec_id
= CODEC_ID_PCM_S24LE
;
565 case CODEC_ID_PCM_S32BE
:
566 st
->codec
->codec_id
= CODEC_ID_PCM_S32LE
;
568 case CODEC_ID_PCM_F32BE
:
569 st
->codec
->codec_id
= CODEC_ID_PCM_F32LE
;
571 case CODEC_ID_PCM_F64BE
:
572 st
->codec
->codec_id
= CODEC_ID_PCM_F64LE
;
581 /* FIXME modify qdm2/svq3/h264 decoders to take full atom as extradata */
582 static int mov_read_extradata(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
584 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
585 uint64_t size
= (uint64_t)st
->codec
->extradata_size
+ atom
.size
+ 8 + FF_INPUT_BUFFER_PADDING_SIZE
;
587 if(size
> INT_MAX
|| (uint64_t)atom
.size
> INT_MAX
)
589 buf
= av_realloc(st
->codec
->extradata
, size
);
592 st
->codec
->extradata
= buf
;
593 buf
+= st
->codec
->extradata_size
;
594 st
->codec
->extradata_size
= size
- FF_INPUT_BUFFER_PADDING_SIZE
;
595 AV_WB32( buf
, atom
.size
+ 8);
596 AV_WL32( buf
+ 4, atom
.type
);
597 get_buffer(pb
, buf
+ 8, atom
.size
);
601 static int mov_read_wave(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
603 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
605 if((uint64_t)atom
.size
> (1<<30))
608 if (st
->codec
->codec_id
== CODEC_ID_QDM2
) {
609 // pass all frma atom to codec, needed at least for QDM2
610 av_free(st
->codec
->extradata
);
611 st
->codec
->extradata
= av_mallocz(atom
.size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
612 if (!st
->codec
->extradata
)
613 return AVERROR(ENOMEM
);
614 st
->codec
->extradata_size
= atom
.size
;
615 get_buffer(pb
, st
->codec
->extradata
, atom
.size
);
616 } else if (atom
.size
> 8) { /* to read frma, esds atoms */
617 if (mov_read_default(c
, pb
, atom
) < 0)
620 url_fskip(pb
, atom
.size
);
625 * This function reads atom content and puts data in extradata without tag
626 * nor size unlike mov_read_extradata.
628 static int mov_read_glbl(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
630 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
632 if((uint64_t)atom
.size
> (1<<30))
635 av_free(st
->codec
->extradata
);
636 st
->codec
->extradata
= av_mallocz(atom
.size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
637 if (!st
->codec
->extradata
)
638 return AVERROR(ENOMEM
);
639 st
->codec
->extradata_size
= atom
.size
;
640 get_buffer(pb
, st
->codec
->extradata
, atom
.size
);
644 static int mov_read_stco(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
646 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
647 MOVStreamContext
*sc
= st
->priv_data
;
648 unsigned int i
, entries
;
650 get_byte(pb
); /* version */
651 get_be24(pb
); /* flags */
653 entries
= get_be32(pb
);
655 if(entries
>= UINT_MAX
/sizeof(int64_t))
658 sc
->chunk_count
= entries
;
659 sc
->chunk_offsets
= av_malloc(entries
* sizeof(int64_t));
660 if (!sc
->chunk_offsets
)
662 if (atom
.type
== MKTAG('s','t','c','o'))
663 for(i
=0; i
<entries
; i
++)
664 sc
->chunk_offsets
[i
] = get_be32(pb
);
665 else if (atom
.type
== MKTAG('c','o','6','4'))
666 for(i
=0; i
<entries
; i
++)
667 sc
->chunk_offsets
[i
] = get_be64(pb
);
675 * Compute codec id for 'lpcm' tag.
676 * See CoreAudioTypes and AudioStreamBasicDescription at Apple.
678 static int mov_get_lpcm_codec_id(int bps
, int flags
)
680 if (flags
& 1) { // floating point
681 if (flags
& 2) { // big endian
682 if (bps
== 32) return CODEC_ID_PCM_F32BE
;
683 else if (bps
== 64) return CODEC_ID_PCM_F64BE
;
685 if (bps
== 32) return CODEC_ID_PCM_F32LE
;
686 else if (bps
== 64) return CODEC_ID_PCM_F64LE
;
692 if (flags
& 4) return CODEC_ID_PCM_S8
;
693 else return CODEC_ID_PCM_U8
;
694 else if (bps
== 16) return CODEC_ID_PCM_S16BE
;
695 else if (bps
== 24) return CODEC_ID_PCM_S24BE
;
696 else if (bps
== 32) return CODEC_ID_PCM_S32BE
;
699 if (flags
& 4) return CODEC_ID_PCM_S8
;
700 else return CODEC_ID_PCM_U8
;
701 else if (bps
== 16) return CODEC_ID_PCM_S16LE
;
702 else if (bps
== 24) return CODEC_ID_PCM_S24LE
;
703 else if (bps
== 32) return CODEC_ID_PCM_S32LE
;
709 static int mov_read_stsd(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
711 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
712 MOVStreamContext
*sc
= st
->priv_data
;
713 int j
, entries
, pseudo_stream_id
;
715 get_byte(pb
); /* version */
716 get_be24(pb
); /* flags */
718 entries
= get_be32(pb
);
720 for(pseudo_stream_id
=0; pseudo_stream_id
<entries
; pseudo_stream_id
++) {
721 //Parsing Sample description table
724 MOV_atom_t a
= { 0, 0, 0 };
725 offset_t start_pos
= url_ftell(pb
);
726 int size
= get_be32(pb
); /* size */
727 uint32_t format
= get_le32(pb
); /* data format */
729 get_be32(pb
); /* reserved */
730 get_be16(pb
); /* reserved */
731 dref_id
= get_be16(pb
);
733 if (st
->codec
->codec_tag
&&
734 st
->codec
->codec_tag
!= format
&&
735 (c
->fc
->video_codec_id
? codec_get_id(codec_movvideo_tags
, format
) != c
->fc
->video_codec_id
736 : st
->codec
->codec_tag
!= MKTAG('j','p','e','g'))
738 /* Multiple fourcc, we skip JPEG. This is not correct, we should
739 * export it as a separate AVStream but this needs a few changes
740 * in the MOV demuxer, patch welcome. */
741 av_log(c
->fc
, AV_LOG_WARNING
, "multiple fourcc not supported\n");
742 url_fskip(pb
, size
- (url_ftell(pb
) - start_pos
));
745 sc
->pseudo_stream_id
= st
->codec
->codec_tag
? -1 : pseudo_stream_id
;
746 sc
->dref_id
= dref_id
;
748 st
->codec
->codec_tag
= format
;
749 id
= codec_get_id(codec_movaudio_tags
, format
);
750 if (id
<=0 && (format
&0xFFFF) == 'm'+('s'<<8))
751 id
= codec_get_id(codec_wav_tags
, bswap_32(format
)&0xFFFF);
753 if (st
->codec
->codec_type
!= CODEC_TYPE_VIDEO
&& id
> 0) {
754 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
755 } else if (st
->codec
->codec_type
!= CODEC_TYPE_AUDIO
&& /* do not overwrite codec type */
756 format
&& format
!= MKTAG('m','p','4','s')) { /* skip old asf mpeg4 tag */
757 id
= codec_get_id(codec_movvideo_tags
, format
);
759 id
= codec_get_id(codec_bmp_tags
, format
);
761 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
762 else if(st
->codec
->codec_type
== CODEC_TYPE_DATA
){
763 id
= codec_get_id(ff_codec_movsubtitle_tags
, format
);
765 st
->codec
->codec_type
= CODEC_TYPE_SUBTITLE
;
769 dprintf(c
->fc
, "size=%d 4CC= %c%c%c%c codec_type=%d\n", size
,
770 (format
>> 0) & 0xff, (format
>> 8) & 0xff, (format
>> 16) & 0xff,
771 (format
>> 24) & 0xff, st
->codec
->codec_type
);
773 if(st
->codec
->codec_type
==CODEC_TYPE_VIDEO
) {
774 uint8_t codec_name
[32];
775 unsigned int color_depth
;
778 st
->codec
->codec_id
= id
;
779 get_be16(pb
); /* version */
780 get_be16(pb
); /* revision level */
781 get_be32(pb
); /* vendor */
782 get_be32(pb
); /* temporal quality */
783 get_be32(pb
); /* spatial quality */
785 st
->codec
->width
= get_be16(pb
); /* width */
786 st
->codec
->height
= get_be16(pb
); /* height */
788 get_be32(pb
); /* horiz resolution */
789 get_be32(pb
); /* vert resolution */
790 get_be32(pb
); /* data size, always 0 */
791 get_be16(pb
); /* frames per samples */
793 get_buffer(pb
, codec_name
, 32); /* codec name, pascal string */
794 if (codec_name
[0] <= 31) {
795 memcpy(st
->codec
->codec_name
, &codec_name
[1],codec_name
[0]);
796 st
->codec
->codec_name
[codec_name
[0]] = 0;
799 st
->codec
->bits_per_coded_sample
= get_be16(pb
); /* depth */
800 st
->codec
->color_table_id
= get_be16(pb
); /* colortable id */
801 dprintf(c
->fc
, "depth %d, ctab id %d\n",
802 st
->codec
->bits_per_coded_sample
, st
->codec
->color_table_id
);
803 /* figure out the palette situation */
804 color_depth
= st
->codec
->bits_per_coded_sample
& 0x1F;
805 color_greyscale
= st
->codec
->bits_per_coded_sample
& 0x20;
807 /* if the depth is 2, 4, or 8 bpp, file is palettized */
808 if ((color_depth
== 2) || (color_depth
== 4) ||
809 (color_depth
== 8)) {
810 /* for palette traversal */
811 unsigned int color_start
, color_count
, color_end
;
812 unsigned char r
, g
, b
;
814 if (color_greyscale
) {
815 int color_index
, color_dec
;
816 /* compute the greyscale palette */
817 st
->codec
->bits_per_coded_sample
= color_depth
;
818 color_count
= 1 << color_depth
;
820 color_dec
= 256 / (color_count
- 1);
821 for (j
= 0; j
< color_count
; j
++) {
822 r
= g
= b
= color_index
;
823 c
->palette_control
.palette
[j
] =
824 (r
<< 16) | (g
<< 8) | (b
);
825 color_index
-= color_dec
;
829 } else if (st
->codec
->color_table_id
) {
830 const uint8_t *color_table
;
831 /* if flag bit 3 is set, use the default palette */
832 color_count
= 1 << color_depth
;
833 if (color_depth
== 2)
834 color_table
= ff_qt_default_palette_4
;
835 else if (color_depth
== 4)
836 color_table
= ff_qt_default_palette_16
;
838 color_table
= ff_qt_default_palette_256
;
840 for (j
= 0; j
< color_count
; j
++) {
841 r
= color_table
[j
* 4 + 0];
842 g
= color_table
[j
* 4 + 1];
843 b
= color_table
[j
* 4 + 2];
844 c
->palette_control
.palette
[j
] =
845 (r
<< 16) | (g
<< 8) | (b
);
848 /* load the palette from the file */
849 color_start
= get_be32(pb
);
850 color_count
= get_be16(pb
);
851 color_end
= get_be16(pb
);
852 if ((color_start
<= 255) &&
853 (color_end
<= 255)) {
854 for (j
= color_start
; j
<= color_end
; j
++) {
855 /* each R, G, or B component is 16 bits;
856 * only use the top 8 bits; skip alpha bytes
866 c
->palette_control
.palette
[j
] =
867 (r
<< 16) | (g
<< 8) | (b
);
871 st
->codec
->palctrl
= &c
->palette_control
;
872 st
->codec
->palctrl
->palette_changed
= 1;
874 st
->codec
->palctrl
= NULL
;
875 } else if(st
->codec
->codec_type
==CODEC_TYPE_AUDIO
) {
876 int bits_per_sample
, flags
;
877 uint16_t version
= get_be16(pb
);
879 st
->codec
->codec_id
= id
;
880 get_be16(pb
); /* revision level */
881 get_be32(pb
); /* vendor */
883 st
->codec
->channels
= get_be16(pb
); /* channel count */
884 dprintf(c
->fc
, "audio channels %d\n", st
->codec
->channels
);
885 st
->codec
->bits_per_coded_sample
= get_be16(pb
); /* sample size */
887 sc
->audio_cid
= get_be16(pb
);
888 get_be16(pb
); /* packet size = 0 */
890 st
->codec
->sample_rate
= ((get_be32(pb
) >> 16));
892 //Read QT version 1 fields. In version 0 these do not exist.
893 dprintf(c
->fc
, "version =%d, isom =%d\n",version
,c
->isom
);
896 sc
->samples_per_frame
= get_be32(pb
);
897 get_be32(pb
); /* bytes per packet */
898 sc
->bytes_per_frame
= get_be32(pb
);
899 get_be32(pb
); /* bytes per sample */
900 } else if(version
==2) {
901 get_be32(pb
); /* sizeof struct only */
902 st
->codec
->sample_rate
= av_int2dbl(get_be64(pb
)); /* float 64 */
903 st
->codec
->channels
= get_be32(pb
);
904 get_be32(pb
); /* always 0x7F000000 */
905 st
->codec
->bits_per_coded_sample
= get_be32(pb
); /* bits per channel if sound is uncompressed */
906 flags
= get_be32(pb
); /* lcpm format specific flag */
907 sc
->bytes_per_frame
= get_be32(pb
); /* bytes per audio packet if constant */
908 sc
->samples_per_frame
= get_be32(pb
); /* lpcm frames per audio packet if constant */
909 if (format
== MKTAG('l','p','c','m'))
910 st
->codec
->codec_id
= mov_get_lpcm_codec_id(st
->codec
->bits_per_coded_sample
, flags
);
914 switch (st
->codec
->codec_id
) {
915 case CODEC_ID_PCM_S8
:
916 case CODEC_ID_PCM_U8
:
917 if (st
->codec
->bits_per_coded_sample
== 16)
918 st
->codec
->codec_id
= CODEC_ID_PCM_S16BE
;
920 case CODEC_ID_PCM_S16LE
:
921 case CODEC_ID_PCM_S16BE
:
922 if (st
->codec
->bits_per_coded_sample
== 8)
923 st
->codec
->codec_id
= CODEC_ID_PCM_S8
;
924 else if (st
->codec
->bits_per_coded_sample
== 24)
925 st
->codec
->codec_id
=
926 st
->codec
->codec_id
== CODEC_ID_PCM_S16BE
?
927 CODEC_ID_PCM_S24BE
: CODEC_ID_PCM_S24LE
;
929 /* set values for old format before stsd version 1 appeared */
931 sc
->samples_per_frame
= 6;
932 sc
->bytes_per_frame
= 2*st
->codec
->channels
;
935 sc
->samples_per_frame
= 6;
936 sc
->bytes_per_frame
= 1*st
->codec
->channels
;
938 case CODEC_ID_ADPCM_IMA_QT
:
939 sc
->samples_per_frame
= 64;
940 sc
->bytes_per_frame
= 34*st
->codec
->channels
;
943 sc
->samples_per_frame
= 160;
944 sc
->bytes_per_frame
= 33;
950 bits_per_sample
= av_get_bits_per_sample(st
->codec
->codec_id
);
951 if (bits_per_sample
) {
952 st
->codec
->bits_per_coded_sample
= bits_per_sample
;
953 sc
->sample_size
= (bits_per_sample
>> 3) * st
->codec
->channels
;
955 } else if(st
->codec
->codec_type
==CODEC_TYPE_SUBTITLE
){
956 st
->codec
->codec_id
= id
;
958 /* other codec type, just skip (rtp, mp4s, tmcd ...) */
959 url_fskip(pb
, size
- (url_ftell(pb
) - start_pos
));
961 /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */
962 a
.size
= size
- (url_ftell(pb
) - start_pos
);
964 if (mov_read_default(c
, pb
, a
) < 0)
966 } else if (a
.size
> 0)
967 url_fskip(pb
, a
.size
);
970 if(st
->codec
->codec_type
==CODEC_TYPE_AUDIO
&& st
->codec
->sample_rate
==0 && sc
->time_scale
>1)
971 st
->codec
->sample_rate
= sc
->time_scale
;
973 /* special codec parameters handling */
974 switch (st
->codec
->codec_id
) {
975 #ifdef CONFIG_DV_DEMUXER
976 case CODEC_ID_DVAUDIO
:
977 c
->dv_fctx
= av_alloc_format_context();
978 c
->dv_demux
= dv_init_demux(c
->dv_fctx
);
980 av_log(c
->fc
, AV_LOG_ERROR
, "dv demux context init error\n");
983 sc
->dv_audio_container
= 1;
984 st
->codec
->codec_id
= CODEC_ID_PCM_S16LE
;
987 /* no ifdef since parameters are always those */
988 case CODEC_ID_AMR_WB
:
989 st
->codec
->sample_rate
= 16000;
990 st
->codec
->channels
= 1; /* really needed */
993 case CODEC_ID_AMR_NB
:
994 st
->codec
->frame_size
= sc
->samples_per_frame
;
995 st
->codec
->sample_rate
= 8000;
996 st
->codec
->channels
= 1; /* really needed */
1000 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
; /* force type after stsd for m1a hdlr */
1001 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
1004 case CODEC_ID_ADPCM_MS
:
1005 case CODEC_ID_ADPCM_IMA_WAV
:
1006 st
->codec
->block_align
= sc
->bytes_per_frame
;
1009 if (st
->codec
->extradata_size
== 36)
1010 st
->codec
->frame_size
= AV_RB32((st
->codec
->extradata
+12));
1019 static int mov_read_stsc(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1021 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
1022 MOVStreamContext
*sc
= st
->priv_data
;
1023 unsigned int i
, entries
;
1025 get_byte(pb
); /* version */
1026 get_be24(pb
); /* flags */
1028 entries
= get_be32(pb
);
1030 if(entries
>= UINT_MAX
/ sizeof(MOV_stsc_t
))
1033 dprintf(c
->fc
, "track[%i].stsc.entries = %i\n", c
->fc
->nb_streams
-1, entries
);
1035 sc
->sample_to_chunk_sz
= entries
;
1036 sc
->sample_to_chunk
= av_malloc(entries
* sizeof(MOV_stsc_t
));
1037 if (!sc
->sample_to_chunk
)
1039 for(i
=0; i
<entries
; i
++) {
1040 sc
->sample_to_chunk
[i
].first
= get_be32(pb
);
1041 sc
->sample_to_chunk
[i
].count
= get_be32(pb
);
1042 sc
->sample_to_chunk
[i
].id
= get_be32(pb
);
1047 static int mov_read_stss(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1049 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
1050 MOVStreamContext
*sc
= st
->priv_data
;
1051 unsigned int i
, entries
;
1053 get_byte(pb
); /* version */
1054 get_be24(pb
); /* flags */
1056 entries
= get_be32(pb
);
1058 if(entries
>= UINT_MAX
/ sizeof(int))
1061 sc
->keyframe_count
= entries
;
1063 dprintf(c
->fc
, "keyframe_count = %d\n", sc
->keyframe_count
);
1065 sc
->keyframes
= av_malloc(entries
* sizeof(int));
1068 for(i
=0; i
<entries
; i
++) {
1069 sc
->keyframes
[i
] = get_be32(pb
);
1070 //dprintf(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
1075 static int mov_read_stsz(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1077 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
1078 MOVStreamContext
*sc
= st
->priv_data
;
1079 unsigned int i
, entries
, sample_size
;
1081 get_byte(pb
); /* version */
1082 get_be24(pb
); /* flags */
1084 sample_size
= get_be32(pb
);
1085 if (!sc
->sample_size
) /* do not overwrite value computed in stsd */
1086 sc
->sample_size
= sample_size
;
1087 entries
= get_be32(pb
);
1088 if(entries
>= UINT_MAX
/ sizeof(int))
1091 sc
->sample_count
= entries
;
1095 dprintf(c
->fc
, "sample_size = %d sample_count = %d\n", sc
->sample_size
, sc
->sample_count
);
1097 sc
->sample_sizes
= av_malloc(entries
* sizeof(int));
1098 if (!sc
->sample_sizes
)
1100 for(i
=0; i
<entries
; i
++)
1101 sc
->sample_sizes
[i
] = get_be32(pb
);
1105 static int mov_read_stts(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1107 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
1108 MOVStreamContext
*sc
= st
->priv_data
;
1109 unsigned int i
, entries
;
1111 int64_t total_sample_count
=0;
1113 get_byte(pb
); /* version */
1114 get_be24(pb
); /* flags */
1115 entries
= get_be32(pb
);
1116 if(entries
>= UINT_MAX
/ sizeof(MOV_stts_t
))
1119 sc
->stts_count
= entries
;
1120 sc
->stts_data
= av_malloc(entries
* sizeof(MOV_stts_t
));
1123 dprintf(c
->fc
, "track[%i].stts.entries = %i\n", c
->fc
->nb_streams
-1, entries
);
1127 for(i
=0; i
<entries
; i
++) {
1128 int sample_duration
;
1131 sample_count
=get_be32(pb
);
1132 sample_duration
= get_be32(pb
);
1133 sc
->stts_data
[i
].count
= sample_count
;
1134 sc
->stts_data
[i
].duration
= sample_duration
;
1136 sc
->time_rate
= ff_gcd(sc
->time_rate
, sample_duration
);
1138 dprintf(c
->fc
, "sample_count=%d, sample_duration=%d\n",sample_count
,sample_duration
);
1140 duration
+=(int64_t)sample_duration
*sample_count
;
1141 total_sample_count
+=sample_count
;
1144 st
->nb_frames
= total_sample_count
;
1146 st
->duration
= duration
;
1150 static int mov_read_ctts(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1152 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
1153 MOVStreamContext
*sc
= st
->priv_data
;
1154 unsigned int i
, entries
;
1156 get_byte(pb
); /* version */
1157 get_be24(pb
); /* flags */
1158 entries
= get_be32(pb
);
1159 if(entries
>= UINT_MAX
/ sizeof(MOV_stts_t
))
1162 sc
->ctts_count
= entries
;
1163 sc
->ctts_data
= av_malloc(entries
* sizeof(MOV_stts_t
));
1166 dprintf(c
->fc
, "track[%i].ctts.entries = %i\n", c
->fc
->nb_streams
-1, entries
);
1168 for(i
=0; i
<entries
; i
++) {
1169 int count
=get_be32(pb
);
1170 int duration
=get_be32(pb
);
1173 av_log(c
->fc
, AV_LOG_WARNING
, "negative ctts, ignoring\n");
1175 url_fskip(pb
, 8 * (entries
- i
- 1));
1178 sc
->ctts_data
[i
].count
= count
;
1179 sc
->ctts_data
[i
].duration
= duration
;
1181 sc
->time_rate
= ff_gcd(sc
->time_rate
, duration
);
1186 static void mov_build_index(MOVContext
*mov
, AVStream
*st
)
1188 MOVStreamContext
*sc
= st
->priv_data
;
1189 offset_t current_offset
;
1190 int64_t current_dts
= 0;
1191 unsigned int stts_index
= 0;
1192 unsigned int stsc_index
= 0;
1193 unsigned int stss_index
= 0;
1196 /* only use old uncompressed audio chunk demuxing when stts specifies it */
1197 if (!(st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&&
1198 sc
->stts_count
== 1 && sc
->stts_data
[0].duration
== 1)) {
1199 unsigned int current_sample
= 0;
1200 unsigned int stts_sample
= 0;
1201 unsigned int keyframe
, sample_size
;
1202 unsigned int distance
= 0;
1203 int key_off
= sc
->keyframes
&& sc
->keyframes
[0] == 1;
1205 st
->nb_frames
= sc
->sample_count
;
1206 for (i
= 0; i
< sc
->chunk_count
; i
++) {
1207 current_offset
= sc
->chunk_offsets
[i
];
1208 if (stsc_index
+ 1 < sc
->sample_to_chunk_sz
&&
1209 i
+ 1 == sc
->sample_to_chunk
[stsc_index
+ 1].first
)
1211 for (j
= 0; j
< sc
->sample_to_chunk
[stsc_index
].count
; j
++) {
1212 if (current_sample
>= sc
->sample_count
) {
1213 av_log(mov
->fc
, AV_LOG_ERROR
, "wrong sample count\n");
1216 keyframe
= !sc
->keyframe_count
|| current_sample
+key_off
== sc
->keyframes
[stss_index
];
1219 if (stss_index
+ 1 < sc
->keyframe_count
)
1222 sample_size
= sc
->sample_size
> 0 ? sc
->sample_size
: sc
->sample_sizes
[current_sample
];
1223 if(sc
->pseudo_stream_id
== -1 ||
1224 sc
->sample_to_chunk
[stsc_index
].id
- 1 == sc
->pseudo_stream_id
) {
1225 av_add_index_entry(st
, current_offset
, current_dts
, sample_size
, distance
,
1226 keyframe
? AVINDEX_KEYFRAME
: 0);
1227 dprintf(mov
->fc
, "AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
1228 "size %d, distance %d, keyframe %d\n", st
->index
, current_sample
,
1229 current_offset
, current_dts
, sample_size
, distance
, keyframe
);
1231 current_offset
+= sample_size
;
1232 assert(sc
->stts_data
[stts_index
].duration
% sc
->time_rate
== 0);
1233 current_dts
+= sc
->stts_data
[stts_index
].duration
/ sc
->time_rate
;
1237 if (stts_index
+ 1 < sc
->stts_count
&& stts_sample
== sc
->stts_data
[stts_index
].count
) {
1243 } else { /* read whole chunk */
1244 unsigned int chunk_samples
, chunk_size
, chunk_duration
;
1245 unsigned int frames
= 1;
1246 for (i
= 0; i
< sc
->chunk_count
; i
++) {
1247 current_offset
= sc
->chunk_offsets
[i
];
1248 if (stsc_index
+ 1 < sc
->sample_to_chunk_sz
&&
1249 i
+ 1 == sc
->sample_to_chunk
[stsc_index
+ 1].first
)
1251 chunk_samples
= sc
->sample_to_chunk
[stsc_index
].count
;
1252 /* get chunk size, beware of alaw/ulaw/mace */
1253 if (sc
->samples_per_frame
> 0 &&
1254 (chunk_samples
* sc
->bytes_per_frame
% sc
->samples_per_frame
== 0)) {
1255 if (sc
->samples_per_frame
< 160)
1256 chunk_size
= chunk_samples
* sc
->bytes_per_frame
/ sc
->samples_per_frame
;
1258 chunk_size
= sc
->bytes_per_frame
;
1259 frames
= chunk_samples
/ sc
->samples_per_frame
;
1260 chunk_samples
= sc
->samples_per_frame
;
1263 chunk_size
= chunk_samples
* sc
->sample_size
;
1264 for (j
= 0; j
< frames
; j
++) {
1265 av_add_index_entry(st
, current_offset
, current_dts
, chunk_size
, 0, AVINDEX_KEYFRAME
);
1266 /* get chunk duration */
1268 while (chunk_samples
> 0) {
1269 if (chunk_samples
< sc
->stts_data
[stts_index
].count
) {
1270 chunk_duration
+= sc
->stts_data
[stts_index
].duration
* chunk_samples
;
1271 sc
->stts_data
[stts_index
].count
-= chunk_samples
;
1274 chunk_duration
+= sc
->stts_data
[stts_index
].duration
* chunk_samples
;
1275 chunk_samples
-= sc
->stts_data
[stts_index
].count
;
1276 if (stts_index
+ 1 < sc
->stts_count
)
1280 current_offset
+= sc
->bytes_per_frame
;
1281 dprintf(mov
->fc
, "AVIndex stream %d, chunk %d, offset %"PRIx64
", dts %"PRId64
", "
1282 "size %d, duration %d\n", st
->index
, i
, current_offset
, current_dts
,
1283 chunk_size
, chunk_duration
);
1284 assert(chunk_duration
% sc
->time_rate
== 0);
1285 current_dts
+= chunk_duration
/ sc
->time_rate
;
1290 /* adjust sample count to avindex entries */
1291 sc
->sample_count
= st
->nb_index_entries
;
1294 static int mov_read_trak(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1297 MOVStreamContext
*sc
;
1300 st
= av_new_stream(c
->fc
, c
->fc
->nb_streams
);
1301 if (!st
) return AVERROR(ENOMEM
);
1302 sc
= av_mallocz(sizeof(MOVStreamContext
));
1303 if (!sc
) return AVERROR(ENOMEM
);
1306 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
1307 st
->start_time
= 0; /* XXX: check */
1309 if ((ret
= mov_read_default(c
, pb
, atom
)) < 0)
1313 if(sc
->chunk_count
&& (!sc
->stts_count
|| !sc
->sample_to_chunk_sz
||
1314 (!sc
->sample_size
&& !sc
->sample_count
))){
1315 av_log(c
->fc
, AV_LOG_ERROR
, "stream %d, missing mandatory atoms, broken header\n",
1317 sc
->sample_count
= 0; //ignore track
1323 sc
->time_scale
= c
->time_scale
;
1324 av_set_pts_info(st
, 64, sc
->time_rate
, sc
->time_scale
);
1326 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&&
1327 !st
->codec
->frame_size
&& sc
->stts_count
== 1)
1328 st
->codec
->frame_size
= av_rescale(sc
->time_rate
, st
->codec
->sample_rate
, sc
->time_scale
);
1330 if(st
->duration
!= AV_NOPTS_VALUE
){
1331 assert(st
->duration
% sc
->time_rate
== 0);
1332 st
->duration
/= sc
->time_rate
;
1334 sc
->ffindex
= st
->index
;
1335 mov_build_index(c
, st
);
1337 if (sc
->dref_id
-1 < sc
->drefs_count
&& sc
->drefs
[sc
->dref_id
-1].path
) {
1338 if (url_fopen(&sc
->pb
, sc
->drefs
[sc
->dref_id
-1].path
, URL_RDONLY
) < 0)
1339 av_log(c
->fc
, AV_LOG_ERROR
, "stream %d, error opening file %s: %s\n",
1340 st
->index
, sc
->drefs
[sc
->dref_id
-1].path
, strerror(errno
));
1344 switch (st
->codec
->codec_id
) {
1345 #ifdef CONFIG_H261_DECODER
1348 #ifdef CONFIG_H263_DECODER
1351 #ifdef CONFIG_MPEG4_DECODER
1352 case CODEC_ID_MPEG4
:
1354 st
->codec
->width
= 0; /* let decoder init width/height */
1355 st
->codec
->height
= 0;
1359 /* Do not need those anymore. */
1360 av_freep(&sc
->chunk_offsets
);
1361 av_freep(&sc
->sample_to_chunk
);
1362 av_freep(&sc
->sample_sizes
);
1363 av_freep(&sc
->keyframes
);
1364 av_freep(&sc
->stts_data
);
1369 static void mov_parse_udta_string(ByteIOContext
*pb
, char *str
, int size
)
1371 uint16_t str_size
= get_be16(pb
); /* string length */;
1373 get_be16(pb
); /* skip language */
1374 get_buffer(pb
, str
, FFMIN(size
, str_size
));
1377 static int mov_read_udta(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1379 uint64_t end
= url_ftell(pb
) + atom
.size
;
1381 while (url_ftell(pb
) + 8 < end
) {
1382 uint32_t tag_size
= get_be32(pb
);
1383 uint32_t tag
= get_le32(pb
);
1384 uint64_t next
= url_ftell(pb
) + tag_size
- 8;
1386 if (next
> end
) // stop if tag_size is wrong
1390 case MKTAG(0xa9,'n','a','m'):
1391 mov_parse_udta_string(pb
, c
->fc
->title
, sizeof(c
->fc
->title
));
1393 case MKTAG(0xa9,'w','r','t'):
1394 mov_parse_udta_string(pb
, c
->fc
->author
, sizeof(c
->fc
->author
));
1396 case MKTAG(0xa9,'c','p','y'):
1397 mov_parse_udta_string(pb
, c
->fc
->copyright
, sizeof(c
->fc
->copyright
));
1399 case MKTAG(0xa9,'i','n','f'):
1400 mov_parse_udta_string(pb
, c
->fc
->comment
, sizeof(c
->fc
->comment
));
1406 url_fseek(pb
, next
, SEEK_SET
);
1412 static int mov_read_tkhd(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1417 int64_t disp_transform
[2];
1418 int display_matrix
[3][2];
1419 AVStream
*st
= c
->fc
->streams
[c
->fc
->nb_streams
-1];
1420 int version
= get_byte(pb
);
1422 get_be24(pb
); /* flags */
1424 MOV_TRACK_ENABLED 0x0001
1425 MOV_TRACK_IN_MOVIE 0x0002
1426 MOV_TRACK_IN_PREVIEW 0x0004
1427 MOV_TRACK_IN_POSTER 0x0008
1434 get_be32(pb
); /* creation time */
1435 get_be32(pb
); /* modification time */
1437 st
->id
= (int)get_be32(pb
); /* track id (NOT 0 !)*/
1438 get_be32(pb
); /* reserved */
1439 st
->start_time
= 0; /* check */
1440 /* highlevel (considering edits) duration in movie timebase */
1441 (version
== 1) ? get_be64(pb
) : get_be32(pb
);
1442 get_be32(pb
); /* reserved */
1443 get_be32(pb
); /* reserved */
1445 get_be16(pb
); /* layer */
1446 get_be16(pb
); /* alternate group */
1447 get_be16(pb
); /* volume */
1448 get_be16(pb
); /* reserved */
1450 //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
1451 // they're kept in fixed point format through all calculations
1452 // ignore u,v,z b/c we don't need the scale factor to calc aspect ratio
1453 for (i
= 0; i
< 3; i
++) {
1454 display_matrix
[i
][0] = get_be32(pb
); // 16.16 fixed point
1455 display_matrix
[i
][1] = get_be32(pb
); // 16.16 fixed point
1456 get_be32(pb
); // 2.30 fixed point (not used)
1459 width
= get_be32(pb
); // 16.16 fixed point track width
1460 height
= get_be32(pb
); // 16.16 fixed point track height
1462 //transform the display width/height according to the matrix
1463 // skip this if the display matrix is the default identity matrix
1464 // to keep the same scale, use [width height 1<<16]
1465 if (width
&& height
&&
1466 (display_matrix
[0][0] != 65536 || display_matrix
[0][1] ||
1467 display_matrix
[1][0] || display_matrix
[1][1] != 65536 ||
1468 display_matrix
[2][0] || display_matrix
[2][1])) {
1469 for (i
= 0; i
< 2; i
++)
1471 (int64_t) width
* display_matrix
[0][i
] +
1472 (int64_t) height
* display_matrix
[1][i
] +
1473 ((int64_t) display_matrix
[2][i
] << 16);
1475 //sample aspect ratio is new width/height divided by old width/height
1476 st
->sample_aspect_ratio
= av_d2q(
1477 ((double) disp_transform
[0] * height
) /
1478 ((double) disp_transform
[1] * width
), INT_MAX
);
1483 static int mov_read_tfhd(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1485 MOVFragment
*frag
= &c
->fragment
;
1486 MOVTrackExt
*trex
= NULL
;
1487 int flags
, track_id
, i
;
1489 get_byte(pb
); /* version */
1490 flags
= get_be24(pb
);
1492 track_id
= get_be32(pb
);
1493 if (!track_id
|| track_id
> c
->fc
->nb_streams
)
1495 frag
->track_id
= track_id
;
1496 for (i
= 0; i
< c
->trex_count
; i
++)
1497 if (c
->trex_data
[i
].track_id
== frag
->track_id
) {
1498 trex
= &c
->trex_data
[i
];
1502 av_log(c
->fc
, AV_LOG_ERROR
, "could not find corresponding trex\n");
1506 if (flags
& 0x01) frag
->base_data_offset
= get_be64(pb
);
1507 else frag
->base_data_offset
= frag
->moof_offset
;
1508 if (flags
& 0x02) frag
->stsd_id
= get_be32(pb
);
1509 else frag
->stsd_id
= trex
->stsd_id
;
1511 frag
->duration
= flags
& 0x08 ? get_be32(pb
) : trex
->duration
;
1512 frag
->size
= flags
& 0x10 ? get_be32(pb
) : trex
->size
;
1513 frag
->flags
= flags
& 0x20 ? get_be32(pb
) : trex
->flags
;
1514 dprintf(c
->fc
, "frag flags 0x%x\n", frag
->flags
);
1518 static int mov_read_trex(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1522 if ((uint64_t)c
->trex_count
+1 >= UINT_MAX
/ sizeof(*c
->trex_data
))
1524 c
->trex_data
= av_realloc(c
->trex_data
, (c
->trex_count
+1)*sizeof(*c
->trex_data
));
1526 return AVERROR(ENOMEM
);
1527 trex
= &c
->trex_data
[c
->trex_count
++];
1528 get_byte(pb
); /* version */
1529 get_be24(pb
); /* flags */
1530 trex
->track_id
= get_be32(pb
);
1531 trex
->stsd_id
= get_be32(pb
);
1532 trex
->duration
= get_be32(pb
);
1533 trex
->size
= get_be32(pb
);
1534 trex
->flags
= get_be32(pb
);
1538 static int mov_read_trun(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1540 MOVFragment
*frag
= &c
->fragment
;
1542 MOVStreamContext
*sc
;
1545 int data_offset
= 0;
1546 unsigned entries
, first_sample_flags
= frag
->flags
;
1547 int flags
, distance
, i
;
1549 if (!frag
->track_id
|| frag
->track_id
> c
->fc
->nb_streams
)
1551 st
= c
->fc
->streams
[frag
->track_id
-1];
1553 if (sc
->pseudo_stream_id
+1 != frag
->stsd_id
)
1555 get_byte(pb
); /* version */
1556 flags
= get_be24(pb
);
1557 entries
= get_be32(pb
);
1558 dprintf(c
->fc
, "flags 0x%x entries %d\n", flags
, entries
);
1559 if (flags
& 0x001) data_offset
= get_be32(pb
);
1560 if (flags
& 0x004) first_sample_flags
= get_be32(pb
);
1561 if (flags
& 0x800) {
1562 if ((uint64_t)entries
+sc
->ctts_count
>= UINT_MAX
/sizeof(*sc
->ctts_data
))
1564 sc
->ctts_data
= av_realloc(sc
->ctts_data
,
1565 (entries
+sc
->ctts_count
)*sizeof(*sc
->ctts_data
));
1567 return AVERROR(ENOMEM
);
1570 offset
= frag
->base_data_offset
+ data_offset
;
1572 dprintf(c
->fc
, "first sample flags 0x%x\n", first_sample_flags
);
1573 for (i
= 0; i
< entries
; i
++) {
1574 unsigned sample_size
= frag
->size
;
1575 int sample_flags
= i
? frag
->flags
: first_sample_flags
;
1576 unsigned sample_duration
= frag
->duration
;
1579 if (flags
& 0x100) sample_duration
= get_be32(pb
);
1580 if (flags
& 0x200) sample_size
= get_be32(pb
);
1581 if (flags
& 0x400) sample_flags
= get_be32(pb
);
1582 if (flags
& 0x800) {
1583 sc
->ctts_data
[sc
->ctts_count
].count
= 1;
1584 sc
->ctts_data
[sc
->ctts_count
].duration
= get_be32(pb
);
1587 if ((keyframe
= st
->codec
->codec_type
== CODEC_TYPE_AUDIO
||
1588 (flags
& 0x004 && !i
&& !sample_flags
) || sample_flags
& 0x2000000))
1590 av_add_index_entry(st
, offset
, dts
, sample_size
, distance
,
1591 keyframe
? AVINDEX_KEYFRAME
: 0);
1592 dprintf(c
->fc
, "AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
1593 "size %d, distance %d, keyframe %d\n", st
->index
, sc
->sample_count
+i
,
1594 offset
, dts
, sample_size
, distance
, keyframe
);
1596 assert(sample_duration
% sc
->time_rate
== 0);
1597 dts
+= sample_duration
/ sc
->time_rate
;
1598 offset
+= sample_size
;
1600 frag
->moof_offset
= offset
;
1601 sc
->sample_count
= st
->nb_index_entries
;
1606 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
1607 /* like the files created with Adobe Premiere 5.0, for samples see */
1608 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
1609 static int mov_read_wide(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1614 return 0; /* continue */
1615 if (get_be32(pb
) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
1616 url_fskip(pb
, atom
.size
- 4);
1619 atom
.type
= get_le32(pb
);
1622 if (atom
.type
!= MKTAG('m','d','a','t')) {
1623 url_fskip(pb
, atom
.size
);
1626 err
= mov_read_mdat(c
, pb
, atom
);
1630 static int mov_read_cmov(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1635 uint8_t *moov_data
; /* uncompressed data */
1636 long cmov_len
, moov_len
;
1639 get_be32(pb
); /* dcom atom */
1640 if (get_le32(pb
) != MKTAG('d','c','o','m'))
1642 if (get_le32(pb
) != MKTAG('z','l','i','b')) {
1643 av_log(NULL
, AV_LOG_ERROR
, "unknown compression for cmov atom !");
1646 get_be32(pb
); /* cmvd atom */
1647 if (get_le32(pb
) != MKTAG('c','m','v','d'))
1649 moov_len
= get_be32(pb
); /* uncompressed size */
1650 cmov_len
= atom
.size
- 6 * 4;
1652 cmov_data
= av_malloc(cmov_len
);
1655 moov_data
= av_malloc(moov_len
);
1660 get_buffer(pb
, cmov_data
, cmov_len
);
1661 if(uncompress (moov_data
, (uLongf
*) &moov_len
, (const Bytef
*)cmov_data
, cmov_len
) != Z_OK
)
1662 goto free_and_return
;
1663 if(init_put_byte(&ctx
, moov_data
, moov_len
, 0, NULL
, NULL
, NULL
, NULL
) != 0)
1664 goto free_and_return
;
1665 atom
.type
= MKTAG('m','o','o','v');
1667 atom
.size
= moov_len
;
1669 // { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
1671 ret
= mov_read_default(c
, &ctx
, atom
);
1677 av_log(c
->fc
, AV_LOG_ERROR
, "this file requires zlib support compiled in\n");
1682 /* edit list atom */
1683 static int mov_read_elst(MOVContext
*c
, ByteIOContext
*pb
, MOV_atom_t atom
)
1685 MOVStreamContext
*sc
= c
->fc
->streams
[c
->fc
->nb_streams
-1]->priv_data
;
1688 get_byte(pb
); /* version */
1689 get_be24(pb
); /* flags */
1690 edit_count
= sc
->edit_count
= get_be32(pb
); /* entries */
1692 for(i
=0; i
<edit_count
; i
++){
1694 get_be32(pb
); /* Track duration */
1695 time
= get_be32(pb
); /* Media time */
1696 get_be32(pb
); /* Media rate */
1698 av_log(c
->fc
, AV_LOG_WARNING
, "edit list not starting at 0, "
1699 "a/v desync might occur, patch welcome\n");
1701 dprintf(c
->fc
, "track[%i].edit_count = %i\n", c
->fc
->nb_streams
-1, sc
->edit_count
);
1705 static const MOVParseTableEntry mov_default_parse_table
[] = {
1706 { MKTAG('a','v','s','s'), mov_read_extradata
},
1707 { MKTAG('c','o','6','4'), mov_read_stco
},
1708 { MKTAG('c','t','t','s'), mov_read_ctts
}, /* composition time to sample */
1709 { MKTAG('d','i','n','f'), mov_read_default
},
1710 { MKTAG('d','r','e','f'), mov_read_dref
},
1711 { MKTAG('e','d','t','s'), mov_read_default
},
1712 { MKTAG('e','l','s','t'), mov_read_elst
},
1713 { MKTAG('e','n','d','a'), mov_read_enda
},
1714 { MKTAG('f','i','e','l'), mov_read_extradata
},
1715 { MKTAG('f','t','y','p'), mov_read_ftyp
},
1716 { MKTAG('g','l','b','l'), mov_read_glbl
},
1717 { MKTAG('h','d','l','r'), mov_read_hdlr
},
1718 { MKTAG('j','p','2','h'), mov_read_extradata
},
1719 { MKTAG('m','d','a','t'), mov_read_mdat
},
1720 { MKTAG('m','d','h','d'), mov_read_mdhd
},
1721 { MKTAG('m','d','i','a'), mov_read_default
},
1722 { MKTAG('m','i','n','f'), mov_read_default
},
1723 { MKTAG('m','o','o','f'), mov_read_moof
},
1724 { MKTAG('m','o','o','v'), mov_read_moov
},
1725 { MKTAG('m','v','e','x'), mov_read_default
},
1726 { MKTAG('m','v','h','d'), mov_read_mvhd
},
1727 { MKTAG('S','M','I',' '), mov_read_smi
}, /* Sorenson extension ??? */
1728 { MKTAG('a','l','a','c'), mov_read_extradata
}, /* alac specific atom */
1729 { MKTAG('a','v','c','C'), mov_read_glbl
},
1730 { MKTAG('s','t','b','l'), mov_read_default
},
1731 { MKTAG('s','t','c','o'), mov_read_stco
},
1732 { MKTAG('s','t','s','c'), mov_read_stsc
},
1733 { MKTAG('s','t','s','d'), mov_read_stsd
}, /* sample description */
1734 { MKTAG('s','t','s','s'), mov_read_stss
}, /* sync sample */
1735 { MKTAG('s','t','s','z'), mov_read_stsz
}, /* sample size */
1736 { MKTAG('s','t','t','s'), mov_read_stts
},
1737 { MKTAG('t','k','h','d'), mov_read_tkhd
}, /* track header */
1738 { MKTAG('t','f','h','d'), mov_read_tfhd
}, /* track fragment header */
1739 { MKTAG('t','r','a','k'), mov_read_trak
},
1740 { MKTAG('t','r','a','f'), mov_read_default
},
1741 { MKTAG('t','r','e','x'), mov_read_trex
},
1742 { MKTAG('t','r','u','n'), mov_read_trun
},
1743 { MKTAG('u','d','t','a'), mov_read_udta
},
1744 { MKTAG('w','a','v','e'), mov_read_wave
},
1745 { MKTAG('e','s','d','s'), mov_read_esds
},
1746 { MKTAG('w','i','d','e'), mov_read_wide
}, /* place holder */
1747 { MKTAG('c','m','o','v'), mov_read_cmov
},
1751 static int mov_probe(AVProbeData
*p
)
1753 unsigned int offset
;
1757 /* check file header */
1760 /* ignore invalid offset */
1761 if ((offset
+ 8) > (unsigned int)p
->buf_size
)
1763 tag
= AV_RL32(p
->buf
+ offset
+ 4);
1765 /* check for obvious tags */
1766 case MKTAG('j','P',' ',' '): /* jpeg 2000 signature */
1767 case MKTAG('m','o','o','v'):
1768 case MKTAG('m','d','a','t'):
1769 case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
1770 case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
1771 case MKTAG('f','t','y','p'):
1772 return AVPROBE_SCORE_MAX
;
1773 /* those are more common words, so rate then a bit less */
1774 case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
1775 case MKTAG('w','i','d','e'):
1776 case MKTAG('f','r','e','e'):
1777 case MKTAG('j','u','n','k'):
1778 case MKTAG('p','i','c','t'):
1779 return AVPROBE_SCORE_MAX
- 5;
1780 case MKTAG(0x82,0x82,0x7f,0x7d):
1781 case MKTAG('s','k','i','p'):
1782 case MKTAG('u','u','i','d'):
1783 case MKTAG('p','r','f','l'):
1784 offset
= AV_RB32(p
->buf
+offset
) + offset
;
1785 /* if we only find those cause probedata is too small at least rate them */
1786 score
= AVPROBE_SCORE_MAX
- 50;
1789 /* unrecognized tag */
1796 static int mov_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
1798 MOVContext
*mov
= s
->priv_data
;
1799 ByteIOContext
*pb
= s
->pb
;
1801 MOV_atom_t atom
= { 0, 0, 0 };
1804 /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
1805 if(!url_is_streamed(pb
))
1806 atom
.size
= url_fsize(pb
);
1808 atom
.size
= INT64_MAX
;
1810 /* check MOV header */
1811 if ((err
= mov_read_default(mov
, pb
, atom
)) < 0) {
1812 av_log(s
, AV_LOG_ERROR
, "error reading header: %d\n", err
);
1815 if (!mov
->found_moov
) {
1816 av_log(s
, AV_LOG_ERROR
, "moov atom not found\n");
1819 dprintf(mov
->fc
, "on_parse_exit_offset=%lld\n", url_ftell(pb
));
1824 static int mov_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1826 MOVContext
*mov
= s
->priv_data
;
1827 MOVStreamContext
*sc
= 0;
1828 AVIndexEntry
*sample
= 0;
1829 int64_t best_dts
= INT64_MAX
;
1832 for (i
= 0; i
< s
->nb_streams
; i
++) {
1833 AVStream
*st
= s
->streams
[i
];
1834 MOVStreamContext
*msc
= st
->priv_data
;
1835 if (st
->discard
!= AVDISCARD_ALL
&& msc
->pb
&& msc
->current_sample
< msc
->sample_count
) {
1836 AVIndexEntry
*current_sample
= &st
->index_entries
[msc
->current_sample
];
1837 int64_t dts
= av_rescale(current_sample
->timestamp
* (int64_t)msc
->time_rate
,
1838 AV_TIME_BASE
, msc
->time_scale
);
1839 dprintf(s
, "stream %d, sample %d, dts %"PRId64
"\n", i
, msc
->current_sample
, dts
);
1840 if (!sample
|| (url_is_streamed(s
->pb
) && current_sample
->pos
< sample
->pos
) ||
1841 (!url_is_streamed(s
->pb
) &&
1842 ((msc
->pb
!= s
->pb
&& dts
< best_dts
) || (msc
->pb
== s
->pb
&&
1843 ((FFABS(best_dts
- dts
) <= AV_TIME_BASE
&& current_sample
->pos
< sample
->pos
) ||
1844 (FFABS(best_dts
- dts
) > AV_TIME_BASE
&& dts
< best_dts
)))))) {
1845 sample
= current_sample
;
1852 mov
->found_mdat
= 0;
1853 if (!url_is_streamed(s
->pb
) ||
1854 mov_read_default(mov
, s
->pb
, (MOV_atom_t
){ 0, 0, INT64_MAX
}) < 0 ||
1857 dprintf(s
, "read fragments, offset 0x%llx\n", url_ftell(s
->pb
));
1860 /* must be done just before reading, to avoid infinite loop on sample */
1861 sc
->current_sample
++;
1862 if (url_fseek(sc
->pb
, sample
->pos
, SEEK_SET
) != sample
->pos
) {
1863 av_log(mov
->fc
, AV_LOG_ERROR
, "stream %d, offset 0x%"PRIx64
": partial file\n",
1864 sc
->ffindex
, sample
->pos
);
1867 av_get_packet(sc
->pb
, pkt
, sample
->size
);
1868 #ifdef CONFIG_DV_DEMUXER
1869 if (mov
->dv_demux
&& sc
->dv_audio_container
) {
1870 dv_produce_packet(mov
->dv_demux
, pkt
, pkt
->data
, pkt
->size
);
1873 if (dv_get_packet(mov
->dv_demux
, pkt
) < 0)
1877 pkt
->stream_index
= sc
->ffindex
;
1878 pkt
->dts
= sample
->timestamp
;
1879 if (sc
->ctts_data
) {
1880 assert(sc
->ctts_data
[sc
->sample_to_ctime_index
].duration
% sc
->time_rate
== 0);
1881 pkt
->pts
= pkt
->dts
+ sc
->ctts_data
[sc
->sample_to_ctime_index
].duration
/ sc
->time_rate
;
1882 /* update ctts context */
1883 sc
->sample_to_ctime_sample
++;
1884 if (sc
->sample_to_ctime_index
< sc
->ctts_count
&&
1885 sc
->ctts_data
[sc
->sample_to_ctime_index
].count
== sc
->sample_to_ctime_sample
) {
1886 sc
->sample_to_ctime_index
++;
1887 sc
->sample_to_ctime_sample
= 0;
1890 AVStream
*st
= s
->streams
[sc
->ffindex
];
1891 int64_t next_dts
= (sc
->current_sample
< sc
->sample_count
) ?
1892 st
->index_entries
[sc
->current_sample
].timestamp
: st
->duration
;
1893 pkt
->duration
= next_dts
- pkt
->dts
;
1894 pkt
->pts
= pkt
->dts
;
1896 pkt
->flags
|= sample
->flags
& AVINDEX_KEYFRAME
? PKT_FLAG_KEY
: 0;
1897 pkt
->pos
= sample
->pos
;
1898 dprintf(s
, "stream %d, pts %"PRId64
", dts %"PRId64
", pos 0x%"PRIx64
", duration %d\n",
1899 pkt
->stream_index
, pkt
->pts
, pkt
->dts
, pkt
->pos
, pkt
->duration
);
1903 static int mov_seek_stream(AVStream
*st
, int64_t timestamp
, int flags
)
1905 MOVStreamContext
*sc
= st
->priv_data
;
1906 int sample
, time_sample
;
1909 sample
= av_index_search_timestamp(st
, timestamp
, flags
);
1910 dprintf(st
->codec
, "stream %d, timestamp %"PRId64
", sample %d\n", st
->index
, timestamp
, sample
);
1911 if (sample
< 0) /* not sure what to do */
1913 sc
->current_sample
= sample
;
1914 dprintf(st
->codec
, "stream %d, found sample %d\n", st
->index
, sc
->current_sample
);
1915 /* adjust ctts index */
1916 if (sc
->ctts_data
) {
1918 for (i
= 0; i
< sc
->ctts_count
; i
++) {
1919 int next
= time_sample
+ sc
->ctts_data
[i
].count
;
1920 if (next
> sc
->current_sample
) {
1921 sc
->sample_to_ctime_index
= i
;
1922 sc
->sample_to_ctime_sample
= sc
->current_sample
- time_sample
;
1931 static int mov_read_seek(AVFormatContext
*s
, int stream_index
, int64_t sample_time
, int flags
)
1934 int64_t seek_timestamp
, timestamp
;
1938 if (stream_index
>= s
->nb_streams
)
1941 st
= s
->streams
[stream_index
];
1942 sample
= mov_seek_stream(st
, sample_time
, flags
);
1946 /* adjust seek timestamp to found sample timestamp */
1947 seek_timestamp
= st
->index_entries
[sample
].timestamp
;
1949 for (i
= 0; i
< s
->nb_streams
; i
++) {
1951 if (stream_index
== i
|| st
->discard
== AVDISCARD_ALL
)
1954 timestamp
= av_rescale_q(seek_timestamp
, s
->streams
[stream_index
]->time_base
, st
->time_base
);
1955 mov_seek_stream(st
, timestamp
, flags
);
1960 static int mov_read_close(AVFormatContext
*s
)
1963 MOVContext
*mov
= s
->priv_data
;
1964 for(i
=0; i
<s
->nb_streams
; i
++) {
1965 MOVStreamContext
*sc
= s
->streams
[i
]->priv_data
;
1966 av_freep(&sc
->ctts_data
);
1967 for (j
=0; j
<sc
->drefs_count
; j
++)
1968 av_freep(&sc
->drefs
[j
].path
);
1969 av_freep(&sc
->drefs
);
1970 if (sc
->pb
&& sc
->pb
!= s
->pb
)
1974 for(i
=0; i
<mov
->dv_fctx
->nb_streams
; i
++){
1975 av_freep(&mov
->dv_fctx
->streams
[i
]->codec
);
1976 av_freep(&mov
->dv_fctx
->streams
[i
]);
1978 av_freep(&mov
->dv_fctx
);
1979 av_freep(&mov
->dv_demux
);
1981 av_freep(&mov
->trex_data
);
1985 AVInputFormat mov_demuxer
= {
1986 "mov,mp4,m4a,3gp,3g2,mj2",
1987 NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),