Mercurial > libavformat.hg
annotate mov.c @ 1779:de2cf54eb68f libavformat
mxf aes decryption support, patch by Reimar, simplified to only look for first crypto context, will be extended once we get files with multiple cryptocontext, and hope that they won't have broken container ul
author | bcoudurier |
---|---|
date | Sun, 11 Feb 2007 12:50:33 +0000 |
parents | fc243e5a290e |
children | 746ff3525dd7 |
rev | line source |
---|---|
0 | 1 /* |
1415
3b00fb8ef8e4
replace coder/decoder file description in libavformat by muxer/demuxer
aurel
parents:
1410
diff
changeset
|
2 * MOV demuxer |
0 | 3 * Copyright (c) 2001 Fabrice Bellard. |
4 * | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1353
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1353
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1353
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
0 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1353
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1353
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 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. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1353
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
890
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
395
c1ed10f3b052
cleanup frame_rate code, this may also fix some large file bugs
michael
parents:
383
diff
changeset
|
21 |
c1ed10f3b052
cleanup frame_rate code, this may also fix some large file bugs
michael
parents:
383
diff
changeset
|
22 #include <limits.h> |
885 | 23 |
1072 | 24 //#define DEBUG |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
25 |
0 | 26 #include "avformat.h" |
1172
6a5e58d2114b
move common stuff from avienc.c and wav.c to new file riff.c
mru
parents:
1169
diff
changeset
|
27 #include "riff.h" |
1216
fec0a3d5408f
move common code from mov.c and movenc.c to isom.c
bcoudurier
parents:
1215
diff
changeset
|
28 #include "isom.h" |
1268 | 29 #include "dv.h" |
0 | 30 |
31 #ifdef CONFIG_ZLIB | |
32 #include <zlib.h> | |
33 #endif | |
34 | |
35 /* | |
36 * First version by Francois Revol revol@free.fr | |
885 | 37 * Seek function by Gael Chardon gael.dev@4now.net |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
38 * |
0 | 39 * Features and limitations: |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
40 * - reads most of the QT files I have (at least the structure), |
0 | 41 * the exceptions are .mov with zlib compressed headers ('cmov' section). It shouldn't be hard to implement. |
42 * FIXED, Francois Revol, 07/17/2002 | |
43 * - ffmpeg has nearly none of the usual QuickTime codecs, | |
44 * although I succesfully dumped raw and mp3 audio tracks off .mov files. | |
45 * Sample QuickTime files with mp3 audio can be found at: http://www.3ivx.com/showcase.html | |
46 * - .mp4 parsing is still hazardous, although the format really is QuickTime with some minor changes | |
47 * (to make .mov parser crash maybe ?), despite what they say in the MPEG FAQ at | |
48 * http://mpeg.telecomitalialab.com/faq.htm | |
49 * - the code is quite ugly... maybe I won't do it recursive next time :-) | |
491 | 50 * - seek is not supported with files that contain edit list |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
51 * |
0 | 52 * Funny I didn't know about http://sourceforge.net/projects/qt-ffmpeg/ |
53 * when coding this :) (it's a writer anyway) | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
54 * |
0 | 55 * Reference documents: |
56 * http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt | |
57 * Apple: | |
491 | 58 * http://developer.apple.com/documentation/QuickTime/QTFF/ |
506
74ad3aa6749c
2000/00/00 to 2001/03/01 QT fileformat documentation patch by (Sebastien Bechet <s.bechet at av7 dot net>)
michael
parents:
500
diff
changeset
|
59 * http://developer.apple.com/documentation/QuickTime/QTFF/qtff.pdf |
0 | 60 * QuickTime is a trademark of Apple (AFAIK :)) |
61 */ | |
62 | |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
63 #include "qtpalette.h" |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
64 |
491 | 65 |
928 | 66 #undef NDEBUG |
67 #include <assert.h> | |
68 | |
1677
2a85c82b8538
add codec_id <-> codec_tag tables to AVIn/OutputFormat
michael
parents:
1673
diff
changeset
|
69 static const AVCodecTag mov_video_tags[] = { |
0 | 70 /* { CODEC_ID_, MKTAG('c', 'v', 'i', 'd') }, *//* Cinepak */ |
71 /* { CODEC_ID_H263, MKTAG('r', 'a', 'w', ' ') }, *//* Uncompressed RGB */ | |
72 /* { CODEC_ID_H263, MKTAG('Y', 'u', 'v', '2') }, *//* Uncompressed YUV422 */ | |
101
0865b0aaa2af
QT AVID 4CCs patch by ("Sebastien Bechet" <s dot bechet at av7 dot net>) (not tested)
mmu_man
parents:
85
diff
changeset
|
73 /* { CODEC_ID_RAWVIDEO, MKTAG('A', 'V', 'U', 'I') }, *//* YUV with alpha-channel (AVID Uncompressed) */ |
0 | 74 /* Graphics */ |
75 /* Animation */ | |
76 /* Apple video */ | |
77 /* Kodak Photo CD */ | |
78 { CODEC_ID_MJPEG, MKTAG('j', 'p', 'e', 'g') }, /* PhotoJPEG */ | |
79 { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'e', 'g') }, /* MPEG */ | |
80 { CODEC_ID_MJPEG, MKTAG('m', 'j', 'p', 'a') }, /* Motion-JPEG (format A) */ | |
1071 | 81 { CODEC_ID_MJPEGB, MKTAG('m', 'j', 'p', 'b') }, /* Motion-JPEG (format B) */ |
101
0865b0aaa2af
QT AVID 4CCs patch by ("Sebastien Bechet" <s dot bechet at av7 dot net>) (not tested)
mmu_man
parents:
85
diff
changeset
|
82 { CODEC_ID_MJPEG, MKTAG('A', 'V', 'D', 'J') }, /* MJPEG with alpha-channel (AVID JFIF meridien compressed) */ |
0865b0aaa2af
QT AVID 4CCs patch by ("Sebastien Bechet" <s dot bechet at av7 dot net>) (not tested)
mmu_man
parents:
85
diff
changeset
|
83 /* { CODEC_ID_MJPEG, MKTAG('A', 'V', 'R', 'n') }, *//* MJPEG with alpha-channel (AVID ABVB/Truevision NuVista) */ |
1410
b22de1465a33
activate gif decoder, seems to work fine on showdown2.mov
bcoudurier
parents:
1404
diff
changeset
|
84 { CODEC_ID_GIF, MKTAG('g', 'i', 'f', ' ') }, /* embedded gif files as frames (usually one "click to play movie" frame) */ |
0 | 85 /* Sorenson video */ |
86 { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') }, /* Sorenson Video v1 */ | |
87 { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', '1') }, /* Sorenson Video v1 */ | |
88 { CODEC_ID_SVQ1, MKTAG('s', 'v', 'q', 'i') }, /* Sorenson Video v1 (from QT specs)*/ | |
129 | 89 { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') }, /* Sorenson Video v3 */ |
0 | 90 { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') }, |
91 { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') }, /* OpenDiVX *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */ | |
289 | 92 { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, |
697
c7e1501cc306
Add 3IV2 4CC by "Rob Coenen" <rob AT massive-interactive DOT nl>
mmu_man
parents:
695
diff
changeset
|
93 { CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') }, /* experimental: 3IVX files before ivx D4 4.5.1 */ |
0 | 94 /* { CODEC_ID_, MKTAG('I', 'V', '5', '0') }, *//* Indeo 5.0 */ |
95 { CODEC_ID_H263, MKTAG('h', '2', '6', '3') }, /* H263 */ | |
133 | 96 { CODEC_ID_H263, MKTAG('s', '2', '6', '3') }, /* H263 ?? works */ |
0 | 97 { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') }, /* DV NTSC */ |
98 { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', 'p') }, /* DV PAL */ | |
124 | 99 { CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, /* On2 VP3 */ |
266
8bb470d85249
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
258
diff
changeset
|
100 { CODEC_ID_RPZA, MKTAG('r', 'p', 'z', 'a') }, /* Apple Video (RPZA) */ |
8bb470d85249
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
258
diff
changeset
|
101 { CODEC_ID_CINEPAK, MKTAG('c', 'v', 'i', 'd') }, /* Cinepak */ |
301 | 102 { CODEC_ID_8BPS, MKTAG('8', 'B', 'P', 'S') }, /* Planar RGB (8BPS) */ |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
103 { CODEC_ID_SMC, MKTAG('s', 'm', 'c', ' ') }, /* Apple Graphics (SMC) */ |
358
d18a2b1fc182
initial commit for Quicktime Animation (RLE) video decoder; bit depths
melanson
parents:
308
diff
changeset
|
104 { CODEC_ID_QTRLE, MKTAG('r', 'l', 'e', ' ') }, /* Apple Animation (RLE) */ |
1662 | 105 { CODEC_ID_MSRLE, MKTAG('W', 'R', 'L', 'E') }, |
533
59da52e5f5a5
support for Sierra Online audio files and Apple QuickDraw codec,
melanson
parents:
506
diff
changeset
|
106 { CODEC_ID_QDRAW, MKTAG('q', 'd', 'r', 'w') }, /* QuickDraw */ |
615 | 107 { CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') }, /* AVC-1/H.264 */ |
805 | 108 { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '2') }, /* MPEG2 produced by Sony HD camera */ |
998
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
109 { CODEC_ID_MPEG2VIDEO, MKTAG('h', 'd', 'v', '3') }, /* HDV produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
110 { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'n') }, /* MPEG2 IMX NTSC 525/60 50mb/s produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
111 { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '5', 'p') }, /* MPEG2 IMX PAL 625/50 50mb/s produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
112 { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'n') }, /* MPEG2 IMX NTSC 525/60 30mb/s produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
113 { CODEC_ID_MPEG2VIDEO, MKTAG('m', 'x', '3', 'p') }, /* MPEG2 IMX PAL 625/50 30mb/s produced by FCP */ |
959
b0a6f09d8d38
mov fourccs for handling FCP files by (Baptiste COUDURIER )(baptiste.coudurier smartjog com)
michael
parents:
956
diff
changeset
|
114 { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'p', 'p') }, /* DVCPRO PAL produced by FCP */ |
998
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
115 //{ CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '5') }, /* DVCPRO HD 50i produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
116 //{ CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', '6') }, /* DVCPRO HD 60i produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
117 { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'p') }, /* DVCPRO50 PAL produced by FCP */ |
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
118 { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '5', 'n') }, /* DVCPRO50 NTSC produced by FCP */ |
1062 | 119 { CODEC_ID_DVVIDEO, MKTAG('A', 'V', 'd', 'v') }, /* AVID DV */ |
998
ea685f7f9ba7
referencing more FCP fourccs patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
997
diff
changeset
|
120 //{ CODEC_ID_JPEG2000, MKTAG('m', 'j', 'p', '2') }, /* JPEG 2000 produced by FCP */ |
1372 | 121 { CODEC_ID_TARGA, MKTAG('t', 'g', 'a', ' ') }, /* Truevision Targa */ |
1384 | 122 { CODEC_ID_TIFF, MKTAG('t', 'i', 'f', 'f') }, /* TIFF embedded in MOV */ |
1086 | 123 { CODEC_ID_RAWVIDEO, MKTAG('2', 'v', 'u', 'y') }, /* UNCOMPRESSED 8BIT 4:2:2 */ |
1628 | 124 { CODEC_ID_VC1, MKTAG('v', 'c', '-', '1') }, /* SMPTE RP 2025 */ |
125 { CODEC_ID_WMV3, MKTAG('v', 'c', '-', '1') }, /* SMPTE RP 2025 */ | |
1661 | 126 { CODEC_ID_PNG, MKTAG('p', 'n', 'g', ' ') }, |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
127 { CODEC_ID_NONE, 0 }, |
0 | 128 }; |
129 | |
1677
2a85c82b8538
add codec_id <-> codec_tag tables to AVIn/OutputFormat
michael
parents:
1673
diff
changeset
|
130 static const AVCodecTag mov_audio_tags[] = { |
964
583f564da55b
add 'in32' fourcc support patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
963
diff
changeset
|
131 { CODEC_ID_PCM_S32BE, MKTAG('i', 'n', '3', '2') }, |
959
b0a6f09d8d38
mov fourccs for handling FCP files by (Baptiste COUDURIER )(baptiste.coudurier smartjog com)
michael
parents:
956
diff
changeset
|
132 { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4') }, |
1248 | 133 { CODEC_ID_PCM_S16BE, MKTAG('N', 'O', 'N', 'E') }, /* uncompressed */ |
0 | 134 { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') }, /* 16 bits */ |
118 | 135 { CODEC_ID_PCM_U8, MKTAG('r', 'a', 'w', ' ') }, /* 8 bits unsigned */ |
0 | 136 { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') }, /* */ |
137 { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') }, /* */ | |
138 { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') }, /* */ | |
139 { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') }, /* IMA-4 ADPCM */ | |
1157 | 140 { CODEC_ID_ADPCM_MS, MKTAG('m', 's', 0x00, 0x02) }, /* MS ADPCM */ |
0 | 141 { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') }, /* Macintosh Audio Compression and Expansion 3:1 */ |
142 { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') }, /* Macintosh Audio Compression and Expansion 6:1 */ | |
143 | |
1168 | 144 { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') }, /* MPEG layer 3 */ /* sample files at http://www.3ivx.com/showcase.html use this tag */ |
0 | 145 { CODEC_ID_MP2, 0x6D730055 }, /* MPEG layer 3 */ |
146 { CODEC_ID_MP2, 0x5500736D }, /* MPEG layer 3 *//* XXX: check endianness */ | |
147 /* { CODEC_ID_OGG_VORBIS, MKTAG('O', 'g', 'g', 'S') }, *//* sample files at http://heroinewarrior.com/xmovie.php3 use this tag */ | |
148 /* MP4 tags */ | |
655
7cba02909808
AAC fix by Thomas Raivio <tjraivio AT cc DOT hut DOT fi>
mmu_man
parents:
654
diff
changeset
|
149 { CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') }, /* MPEG-4 AAC */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
150 /* The standard for mpeg4 audio is still not normalised AFAIK anyway */ |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
151 { CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') }, /* AMR-NB 3gp */ |
258
59c2e84817a1
AMR-WB support by (Johannes Carlsson <joca at rixmail dot se>)
michaelni
parents:
191
diff
changeset
|
152 { CODEC_ID_AMR_WB, MKTAG('s', 'a', 'w', 'b') }, /* AMR-WB 3gp */ |
289 | 153 { CODEC_ID_AC3, MKTAG('m', 's', 0x20, 0x00) }, /* Dolby AC-3 */ |
691
28af25a9a897
first pass at ALAC decoder from David Hammerton; while David's original
melanson
parents:
690
diff
changeset
|
154 { CODEC_ID_ALAC,MKTAG('a', 'l', 'a', 'c') }, /* Apple Lossless */ |
865 | 155 { CODEC_ID_QDM2,MKTAG('Q', 'D', 'M', '2') }, /* QDM2 */ |
1268 | 156 { CODEC_ID_DVAUDIO, MKTAG('v', 'd', 'v', 'a') }, |
157 { CODEC_ID_DVAUDIO, MKTAG('d', 'v', 'c', 'a') }, | |
1335 | 158 { CODEC_ID_PCM_S16LE, MKTAG('l', 'p', 'c', 'm') }, |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
159 { CODEC_ID_NONE, 0 }, |
0 | 160 }; |
161 | |
162 /* the QuickTime file format is quite convoluted... | |
163 * it has lots of index tables, each indexing something in another one... | |
164 * Here we just use what is needed to read the chunks | |
165 */ | |
166 | |
167 typedef struct MOV_sample_to_chunk_tbl { | |
168 long first; | |
169 long count; | |
170 long id; | |
171 } MOV_sample_to_chunk_tbl; | |
172 | |
118 | 173 typedef struct { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
174 uint32_t type; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
175 int64_t offset; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
176 int64_t size; /* total size (excluding the size and type fields) */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
177 } MOV_atom_t; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
178 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
179 typedef struct { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
180 int seed; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
181 int flags; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
182 int size; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
183 void* clrs; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
184 } MOV_ctab_t; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
185 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
186 typedef struct MOV_mdat_atom_s { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
187 offset_t offset; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
188 int64_t size; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
189 } MOV_mdat_atom_t; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
190 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
191 typedef struct { |
118 | 192 uint8_t version; |
193 uint32_t flags; // 24bit | |
194 | |
195 /* 0x03 ESDescrTag */ | |
196 uint16_t es_id; | |
887 | 197 #define MP4ODescrTag 0x01 |
198 #define MP4IODescrTag 0x02 | |
199 #define MP4ESDescrTag 0x03 | |
200 #define MP4DecConfigDescrTag 0x04 | |
201 #define MP4DecSpecificDescrTag 0x05 | |
202 #define MP4SLConfigDescrTag 0x06 | |
203 #define MP4ContentIdDescrTag 0x07 | |
204 #define MP4SupplContentIdDescrTag 0x08 | |
205 #define MP4IPIPtrDescrTag 0x09 | |
206 #define MP4IPMPPtrDescrTag 0x0A | |
207 #define MP4IPMPDescrTag 0x0B | |
208 #define MP4RegistrationDescrTag 0x0D | |
209 #define MP4ESIDIncDescrTag 0x0E | |
210 #define MP4ESIDRefDescrTag 0x0F | |
211 #define MP4FileIODescrTag 0x10 | |
212 #define MP4FileODescrTag 0x11 | |
213 #define MP4ExtProfileLevelDescrTag 0x13 | |
214 #define MP4ExtDescrTagsStart 0x80 | |
215 #define MP4ExtDescrTagsEnd 0xFE | |
118 | 216 uint8_t stream_priority; |
217 | |
218 /* 0x04 DecConfigDescrTag */ | |
219 uint8_t object_type_id; | |
220 uint8_t stream_type; | |
221 /* XXX: really streamType is | |
222 * only 6bit, followed by: | |
223 * 1bit upStream | |
224 * 1bit reserved | |
225 */ | |
226 uint32_t buffer_size_db; // 24 | |
227 uint32_t max_bitrate; | |
228 uint32_t avg_bitrate; | |
229 | |
230 /* 0x05 DecSpecificDescrTag */ | |
231 uint8_t decoder_cfg_len; | |
232 uint8_t *decoder_cfg; | |
233 | |
234 /* 0x06 SLConfigDescrTag */ | |
235 uint8_t sl_config_len; | |
236 uint8_t *sl_config; | |
237 } MOV_esds_t; | |
238 | |
121 | 239 struct MOVParseTableEntry; |
240 | |
0 | 241 typedef struct MOVStreamContext { |
242 int ffindex; /* the ffmpeg stream id */ | |
243 long next_chunk; | |
1728 | 244 unsigned int chunk_count; |
65 | 245 int64_t *chunk_offsets; |
1728 | 246 unsigned int stts_count; |
670 | 247 Time2Sample *stts_data; |
1728 | 248 unsigned int ctts_count; |
671 | 249 Time2Sample *ctts_data; |
1728 | 250 unsigned int edit_count; /* number of 'edit' (elst atom) */ |
251 unsigned int sample_to_chunk_sz; | |
0 | 252 MOV_sample_to_chunk_tbl *sample_to_chunk; |
671 | 253 int sample_to_ctime_index; |
254 int sample_to_ctime_sample; | |
1728 | 255 unsigned int sample_size; |
256 unsigned int sample_count; | |
0 | 257 long *sample_sizes; |
1728 | 258 unsigned int keyframe_count; |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
259 long *keyframes; |
118 | 260 int time_scale; |
928 | 261 int time_rate; |
0 | 262 long current_sample; |
118 | 263 MOV_esds_t esds; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
264 AVRational sample_size_v1; |
1268 | 265 int dv_audio_container; |
0 | 266 } MOVStreamContext; |
267 | |
268 typedef struct MOVContext { | |
269 AVFormatContext *fc; | |
118 | 270 int time_scale; |
1027 | 271 int64_t duration; /* duration of the longest track */ |
0 | 272 int found_moov; /* when both 'moov' and 'mdat' sections has been found */ |
273 int found_mdat; /* we suppose we have enough data to read the file */ | |
65 | 274 int64_t mdat_offset; |
0 | 275 int total_streams; |
276 MOVStreamContext *streams[MAX_STREAMS]; | |
118 | 277 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
278 int ctab_size; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
279 MOV_ctab_t **ctab; /* color tables */ |
121 | 280 const struct MOVParseTableEntry *parse_table; /* could be eventually used to change the table */ |
281 /* NOTE: for recursion save to/ restore from local variable! */ | |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
282 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
283 AVPaletteControl palette_control; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
284 MOV_mdat_atom_t *mdat_list; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
285 int mdat_count; |
1268 | 286 DVDemuxContext *dv_demux; |
287 AVFormatContext *dv_fctx; | |
1446
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
288 int isom; /* 1 if file is ISO Media (mp4/3gp) */ |
0 | 289 } MOVContext; |
290 | |
291 | |
292 /* XXX: it's the first time I make a recursive parser I think... sorry if it's ugly :P */ | |
293 | |
294 /* those functions parse an atom */ | |
295 /* return code: | |
296 1: found what I wanted, exit | |
297 0: continue to parse next atom | |
298 -1: error occured, exit | |
299 */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
300 typedef int (*mov_parse_function)(MOVContext *ctx, ByteIOContext *pb, MOV_atom_t atom); |
0 | 301 |
302 /* links atom IDs to parse functions */ | |
303 typedef struct MOVParseTableEntry { | |
65 | 304 uint32_t type; |
0 | 305 mov_parse_function func; |
306 } MOVParseTableEntry; | |
307 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
308 static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 309 { |
121 | 310 int64_t total_size = 0; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
311 MOV_atom_t a; |
0 | 312 int i; |
313 int err = 0; | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
314 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
315 a.offset = atom.offset; |
0 | 316 |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
317 if (atom.size < 0) |
887 | 318 atom.size = 0x7fffffffffffffffLL; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
319 while(((total_size + 8) < atom.size) && !url_feof(pb) && !err) { |
887 | 320 a.size = atom.size; |
321 a.type=0L; | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
322 if(atom.size >= 8) { |
887 | 323 a.size = get_be32(pb); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
324 a.type = get_le32(pb); |
0 | 325 } |
887 | 326 total_size += 8; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
327 a.offset += 8; |
1010 | 328 dprintf("type: %08x %.4s sz: %"PRIx64" %"PRIx64" %"PRIx64"\n", a.type, (char*)&a.type, a.size, atom.size, total_size); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
329 if (a.size == 1) { /* 64 bit extended size */ |
887 | 330 a.size = get_be64(pb) - 8; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
331 a.offset += 8; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
332 total_size += 8; |
0 | 333 } |
887 | 334 if (a.size == 0) { |
335 a.size = atom.size - total_size; | |
336 if (a.size <= 8) | |
118 | 337 break; |
887 | 338 } |
339 for (i = 0; c->parse_table[i].type != 0L | |
340 && c->parse_table[i].type != a.type; i++) | |
341 /* empty */; | |
118 | 342 |
887 | 343 a.size -= 8; |
885 | 344 |
639 | 345 if(a.size < 0) |
346 break; | |
885 | 347 |
887 | 348 if (c->parse_table[i].type == 0) { /* skip leaf atoms data */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
349 url_fskip(pb, a.size); |
887 | 350 } else { |
1060 | 351 offset_t start_pos = url_ftell(pb); |
352 int64_t left; | |
887 | 353 err = (c->parse_table[i].func)(c, pb, a); |
1060 | 354 left = a.size - url_ftell(pb) + start_pos; |
355 if (left > 0) /* skip garbage at atom end */ | |
356 url_fskip(pb, left); | |
887 | 357 } |
0 | 358 |
887 | 359 a.offset += a.size; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
360 total_size += a.size; |
0 | 361 } |
362 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
363 if (!err && total_size < atom.size && atom.size < 0x7ffff) { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
364 url_fskip(pb, atom.size - total_size); |
118 | 365 } |
366 | |
0 | 367 return err; |
368 } | |
369 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
370 static int mov_read_ctab(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 371 { |
639 | 372 #if 1 |
373 url_fskip(pb, atom.size); // for now | |
374 #else | |
375 VERY VERY BROKEN, NEVER execute this, needs rewrite | |
683
095009fc2f35
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
677
diff
changeset
|
376 unsigned int len; |
095009fc2f35
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
677
diff
changeset
|
377 MOV_ctab_t *t; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
378 c->ctab = av_realloc(c->ctab, ++c->ctab_size); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
379 t = c->ctab[c->ctab_size]; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
380 t->seed = get_be32(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
381 t->flags = get_be16(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
382 t->size = get_be16(pb) + 1; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
383 len = 2 * t->size * 4; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
384 if (len > 0) { |
887 | 385 t->clrs = av_malloc(len); // 16bit A R G B |
386 if (t->clrs) | |
387 get_buffer(pb, t->clrs, len); | |
0 | 388 } |
639 | 389 #endif |
118 | 390 |
0 | 391 return 0; |
392 } | |
393 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
394 static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 395 { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
396 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
65 | 397 uint32_t type; |
398 uint32_t ctype; | |
121 | 399 |
0 | 400 get_byte(pb); /* version */ |
401 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
402 | |
403 /* component type */ | |
404 ctype = get_le32(pb); | |
405 type = get_le32(pb); /* component subtype */ | |
406 | |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
407 dprintf("ctype= %c%c%c%c (0x%08lx)\n", *((char *)&ctype), ((char *)&ctype)[1], ((char *)&ctype)[2], ((char *)&ctype)[3], (long) ctype); |
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
408 dprintf("stype= %c%c%c%c\n", *((char *)&type), ((char *)&type)[1], ((char *)&type)[2], ((char *)&type)[3]); |
1446
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
409 if(!ctype) |
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
410 c->isom = 1; |
965
d3b4919dd5ec
simplify mov_read_hdlr patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
964
diff
changeset
|
411 if(type == MKTAG('v', 'i', 'd', 'e')) |
d3b4919dd5ec
simplify mov_read_hdlr patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
964
diff
changeset
|
412 st->codec->codec_type = CODEC_TYPE_VIDEO; |
d3b4919dd5ec
simplify mov_read_hdlr patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
964
diff
changeset
|
413 else if(type == MKTAG('s', 'o', 'u', 'n')) |
d3b4919dd5ec
simplify mov_read_hdlr patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
964
diff
changeset
|
414 st->codec->codec_type = CODEC_TYPE_AUDIO; |
1471
ad18f1010f47
support m1a hdlr mpeg elementary audio handler, fix Po-Slow_Death_64K.mov
bcoudurier
parents:
1448
diff
changeset
|
415 else if(type == MKTAG('m', '1', 'a', ' ')) |
ad18f1010f47
support m1a hdlr mpeg elementary audio handler, fix Po-Slow_Death_64K.mov
bcoudurier
parents:
1448
diff
changeset
|
416 st->codec->codec_id = CODEC_ID_MP2; |
1495
04909cf98da7
partial support for vobsub in mp4, used by nero, unsupported-embedded-subs-2.mp4
bcoudurier
parents:
1471
diff
changeset
|
417 else if(type == MKTAG('s', 'u', 'b', 'p')) { |
04909cf98da7
partial support for vobsub in mp4, used by nero, unsupported-embedded-subs-2.mp4
bcoudurier
parents:
1471
diff
changeset
|
418 st->codec->codec_type = CODEC_TYPE_SUBTITLE; |
04909cf98da7
partial support for vobsub in mp4, used by nero, unsupported-embedded-subs-2.mp4
bcoudurier
parents:
1471
diff
changeset
|
419 st->codec->codec_id = CODEC_ID_DVD_SUBTITLE; |
04909cf98da7
partial support for vobsub in mp4, used by nero, unsupported-embedded-subs-2.mp4
bcoudurier
parents:
1471
diff
changeset
|
420 } |
0 | 421 get_be32(pb); /* component manufacture */ |
422 get_be32(pb); /* component flags */ | |
423 get_be32(pb); /* component flags mask */ | |
424 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
425 if(atom.size <= 24) |
0 | 426 return 0; /* nothing left to read */ |
118 | 427 |
489
aeb69a5f3756
The atom 'skip' should be handled by 'mov_read_leaf()', not by
michael
parents:
438
diff
changeset
|
428 url_fskip(pb, atom.size - (url_ftell(pb) - atom.offset)); |
0 | 429 return 0; |
430 } | |
431 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
432 static int mov_mp4_read_descr_len(ByteIOContext *pb) |
0 | 433 { |
118 | 434 int len = 0; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
435 int count = 4; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
436 while (count--) { |
118 | 437 int c = get_byte(pb); |
887 | 438 len = (len << 7) | (c & 0x7f); |
439 if (!(c & 0x80)) | |
440 break; | |
0 | 441 } |
442 return len; | |
443 } | |
444 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
445 static int mov_mp4_read_descr(ByteIOContext *pb, int *tag) |
0 | 446 { |
447 int len; | |
448 *tag = get_byte(pb); | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
449 len = mov_mp4_read_descr_len(pb); |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
450 dprintf("MPEG4 description: tag=0x%02x len=%d\n", *tag, len); |
0 | 451 return len; |
452 } | |
453 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
454 static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
118 | 455 { |
456 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; | |
457 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; | |
458 int tag, len; | |
121 | 459 |
118 | 460 /* Well, broken but suffisant for some MP4 streams */ |
461 get_be32(pb); /* version + flags */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
462 len = mov_mp4_read_descr(pb, &tag); |
118 | 463 if (tag == MP4ESDescrTag) { |
887 | 464 get_be16(pb); /* ID */ |
465 get_byte(pb); /* priority */ | |
118 | 466 } else |
887 | 467 get_be16(pb); /* ID */ |
118 | 468 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
469 len = mov_mp4_read_descr(pb, &tag); |
118 | 470 if (tag == MP4DecConfigDescrTag) { |
887 | 471 sc->esds.object_type_id = get_byte(pb); |
472 sc->esds.stream_type = get_byte(pb); | |
473 sc->esds.buffer_size_db = get_be24(pb); | |
474 sc->esds.max_bitrate = get_be32(pb); | |
475 sc->esds.avg_bitrate = get_be32(pb); | |
118 | 476 |
943
4e7a66723f1d
mp4 codecs objecttype handling patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
928
diff
changeset
|
477 st->codec->codec_id= codec_get_id(ff_mov_obj_type, sc->esds.object_type_id); |
1215 | 478 dprintf("esds object type id %d\n", sc->esds.object_type_id); |
887 | 479 len = mov_mp4_read_descr(pb, &tag); |
480 if (tag == MP4DecSpecificDescrTag) { | |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
481 dprintf("Specific MPEG4 header len=%d\n", len); |
1338 | 482 st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE); |
887 | 483 if (st->codec->extradata) { |
484 get_buffer(pb, st->codec->extradata, len); | |
485 st->codec->extradata_size = len; | |
1039 | 486 /* from mplayer */ |
1353 | 487 if ((*st->codec->extradata >> 3) == 29) { |
1039 | 488 st->codec->codec_id = CODEC_ID_MP3ON4; |
489 } | |
887 | 490 } |
491 } | |
118 | 492 } |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
493 return 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
494 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
495 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
496 /* this atom contains actual media data */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
497 static int mov_read_mdat(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
498 { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
499 if(atom.size == 0) /* wrong one (MP4) */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
500 return 0; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
501 c->mdat_list = av_realloc(c->mdat_list, (c->mdat_count + 1) * sizeof(*c->mdat_list)); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
502 c->mdat_list[c->mdat_count].offset = atom.offset; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
503 c->mdat_list[c->mdat_count].size = atom.size; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
504 c->mdat_count++; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
505 c->found_mdat=1; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
506 c->mdat_offset = atom.offset; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
507 if(c->found_moov) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
508 return 1; /* found both, just go */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
509 url_fskip(pb, atom.size); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
510 return 0; /* now go for moov */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
511 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
512 |
963
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
513 static int mov_read_ftyp(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
514 { |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
515 uint32_t type = get_le32(pb); |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
516 |
1446
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
517 if (type != MKTAG('q','t',' ',' ')) |
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
518 c->isom = 1; |
1440 | 519 av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type); |
963
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
520 get_be32(pb); /* minor version */ |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
521 url_fskip(pb, atom.size - 8); |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
522 return 0; |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
523 } |
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
524 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
525 /* this atom should contain all header atoms */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
526 static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
527 { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
528 int err; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
529 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
530 err = mov_read_default(c, pb, atom); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
531 /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
532 /* so we don't parse the whole file if over a network */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
533 c->found_moov=1; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
534 if(c->found_mdat) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
535 return 1; /* found both, just go */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
536 return 0; /* now go for mdat */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
537 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
538 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
539 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
540 static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
541 { |
1023 | 542 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
543 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; | |
544 int version = get_byte(pb); | |
889
22b044eeeaed
fix parsing version 1 mdhd atom (64 bit) as suggested by b-o-n-d AT gmx DOT net (unstested); added code to map language codes to stream->language[]
mmu_man
parents:
887
diff
changeset
|
545 int lang; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
546 |
889
22b044eeeaed
fix parsing version 1 mdhd atom (64 bit) as suggested by b-o-n-d AT gmx DOT net (unstested); added code to map language codes to stream->language[]
mmu_man
parents:
887
diff
changeset
|
547 if (version > 1) |
22b044eeeaed
fix parsing version 1 mdhd atom (64 bit) as suggested by b-o-n-d AT gmx DOT net (unstested); added code to map language codes to stream->language[]
mmu_man
parents:
887
diff
changeset
|
548 return 1; /* unsupported */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
549 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
550 get_byte(pb); get_byte(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
551 get_byte(pb); /* flags */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
552 |
1023 | 553 if (version == 1) { |
554 get_be64(pb); | |
555 get_be64(pb); | |
556 } else { | |
557 get_be32(pb); /* creation time */ | |
558 get_be32(pb); /* modification time */ | |
559 } | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
560 |
1023 | 561 sc->time_scale = get_be32(pb); |
562 st->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
563 |
889
22b044eeeaed
fix parsing version 1 mdhd atom (64 bit) as suggested by b-o-n-d AT gmx DOT net (unstested); added code to map language codes to stream->language[]
mmu_man
parents:
887
diff
changeset
|
564 lang = get_be16(pb); /* language */ |
1023 | 565 ff_mov_lang_to_iso639(lang, st->language); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
566 get_be16(pb); /* quality */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
567 |
118 | 568 return 0; |
569 } | |
570 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
571 static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
572 { |
1022 | 573 int version = get_byte(pb); /* version */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
574 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
575 |
1022 | 576 if (version == 1) { |
577 get_be64(pb); | |
578 get_be64(pb); | |
579 } else { | |
580 get_be32(pb); /* creation time */ | |
581 get_be32(pb); /* modification time */ | |
582 } | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
583 c->time_scale = get_be32(pb); /* time scale */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
584 #ifdef DEBUG |
491 | 585 av_log(NULL, AV_LOG_DEBUG, "time scale = %i\n", c->time_scale); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
586 #endif |
1022 | 587 c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
588 get_be32(pb); /* preferred scale */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
589 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
590 get_be16(pb); /* preferred volume */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
591 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
592 url_fskip(pb, 10); /* reserved */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
593 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
594 url_fskip(pb, 36); /* display matrix */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
595 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
596 get_be32(pb); /* preview time */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
597 get_be32(pb); /* preview duration */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
598 get_be32(pb); /* poster time */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
599 get_be32(pb); /* selection time */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
600 get_be32(pb); /* selection duration */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
601 get_be32(pb); /* current time */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
602 get_be32(pb); /* next track ID */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
603 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
604 return 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
605 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
606 |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
607 static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
608 { |
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
609 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
610 |
639 | 611 if((uint64_t)atom.size > (1<<30)) |
612 return -1; | |
885 | 613 |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
614 // currently SVQ3 decoder expect full STSD header - so let's fake it |
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
615 // this should be fixed and just SMI header should be passed |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
616 av_free(st->codec->extradata); |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
617 st->codec->extradata_size = 0x5a + atom.size; |
1338 | 618 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
619 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
620 if (st->codec->extradata) { |
1731 | 621 memcpy(st->codec->extradata, "SVQ3", 4); // fake |
1353 | 622 get_buffer(pb, st->codec->extradata + 0x5a, atom.size); |
623 dprintf("Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a); | |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
624 } else |
887 | 625 url_fskip(pb, atom.size); |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
626 |
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
627 return 0; |
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
628 } |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
629 |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
630 static int mov_read_enda(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
631 { |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
632 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
633 int little_endian = get_be16(pb); |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
634 |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
635 if (little_endian) { |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
636 switch (st->codec->codec_id) { |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
637 case CODEC_ID_PCM_S24BE: |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
638 st->codec->codec_id = CODEC_ID_PCM_S24LE; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
639 break; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
640 case CODEC_ID_PCM_S32BE: |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
641 st->codec->codec_id = CODEC_ID_PCM_S32LE; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
642 break; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
643 default: |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
644 break; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
645 } |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
646 } |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
647 return 0; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
648 } |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
649 |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
650 static int mov_read_alac(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
651 { |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
652 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
653 |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
654 // currently ALAC decoder expect full atom header - so let's fake it |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
655 // this should be fixed and just ALAC header should be passed |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
656 |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
657 av_free(st->codec->extradata); |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
658 st->codec->extradata_size = 36; |
1338 | 659 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
660 |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
661 if (st->codec->extradata) { |
1731 | 662 memcpy(st->codec->extradata + 4, "alac", 4); // fake |
1353 | 663 get_buffer(pb, st->codec->extradata + 8, 36 - 8); |
664 dprintf("Reading alac %d %s\n", st->codec->extradata_size, st->codec->extradata); | |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
665 } else |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
666 url_fskip(pb, atom.size); |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
667 return 0; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
668 } |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
669 |
865 | 670 static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
671 { | |
672 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; | |
673 | |
674 if((uint64_t)atom.size > (1<<30)) | |
675 return -1; | |
885 | 676 |
947
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
677 if (st->codec->codec_id == CODEC_ID_QDM2) { |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
678 // pass all frma atom to codec, needed at least for QDM2 |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
679 av_free(st->codec->extradata); |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
680 st->codec->extradata_size = atom.size; |
1338 | 681 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
865 | 682 |
947
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
683 if (st->codec->extradata) { |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
684 get_buffer(pb, st->codec->extradata, atom.size); |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
685 } else |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
686 url_fskip(pb, atom.size); |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
687 } else if (atom.size > 8) { /* to read frma, esds atoms */ |
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
688 mov_read_default(c, pb, atom); |
1060 | 689 } else |
887 | 690 url_fskip(pb, atom.size); |
865 | 691 return 0; |
692 } | |
693 | |
997
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
694 static int mov_read_jp2h(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
695 { |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
696 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
697 |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
698 if((uint64_t)atom.size > (1<<30)) |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
699 return -1; |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
700 |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
701 av_free(st->codec->extradata); |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
702 |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
703 st->codec->extradata_size = atom.size + 8; |
1338 | 704 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
997
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
705 |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
706 /* pass all jp2h atom to codec */ |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
707 if (st->codec->extradata) { |
1731 | 708 memcpy(st->codec->extradata + 4, "jp2h", 4); |
1353 | 709 get_buffer(pb, st->codec->extradata + 8, atom.size); |
997
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
710 } else |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
711 url_fskip(pb, atom.size); |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
712 return 0; |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
713 } |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
714 |
615 | 715 static int mov_read_avcC(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
716 { | |
717 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; | |
718 | |
639 | 719 if((uint64_t)atom.size > (1<<30)) |
720 return -1; | |
721 | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
722 av_free(st->codec->extradata); |
615 | 723 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
724 st->codec->extradata_size = atom.size; |
1338 | 725 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
615 | 726 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
727 if (st->codec->extradata) { |
887 | 728 get_buffer(pb, st->codec->extradata, atom.size); |
615 | 729 } else |
887 | 730 url_fskip(pb, atom.size); |
615 | 731 |
732 return 0; | |
733 } | |
734 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
735 static int mov_read_stco(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 736 { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
737 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
738 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
639 | 739 unsigned int i, entries; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
740 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
741 get_byte(pb); /* version */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
742 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
743 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
744 entries = get_be32(pb); |
885 | 745 |
639 | 746 if(entries >= UINT_MAX/sizeof(int64_t)) |
747 return -1; | |
885 | 748 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
749 sc->chunk_count = entries; |
1338 | 750 sc->chunk_offsets = av_malloc(entries * sizeof(int64_t)); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
751 if (!sc->chunk_offsets) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
752 return -1; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
753 if (atom.type == MKTAG('s', 't', 'c', 'o')) { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
754 for(i=0; i<entries; i++) { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
755 sc->chunk_offsets[i] = get_be32(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
756 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
757 } else if (atom.type == MKTAG('c', 'o', '6', '4')) { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
758 for(i=0; i<entries; i++) { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
759 sc->chunk_offsets[i] = get_be64(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
760 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
761 } else |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
762 return -1; |
885 | 763 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
764 return 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
765 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
766 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
767 static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
768 { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
769 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
849
44b415886cbf
sample_rate value is not always correct (is there anything in quicktime which is?) so try to guess it from time_scale
michael
parents:
822
diff
changeset
|
770 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
771 int entries, frames_per_sample; |
65 | 772 uint32_t format; |
657
5b9575f5b6e8
mov header field and compressor name patch by Roine Gustafsson <roine AT users DOT sourceforge DOT net>
mmu_man
parents:
655
diff
changeset
|
773 uint8_t codec_name[32]; |
121 | 774 |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
775 /* for palette traversal */ |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
776 int color_depth; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
777 int color_start; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
778 int color_count; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
779 int color_end; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
780 int color_index; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
781 int color_dec; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
782 int color_greyscale; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
783 unsigned char *color_table; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
784 int j; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
785 unsigned char r, g, b; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
786 |
0 | 787 get_byte(pb); /* version */ |
788 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
789 | |
790 entries = get_be32(pb); | |
791 | |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
792 while(entries--) { //Parsing Sample description table |
121 | 793 enum CodecID id; |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
794 MOV_atom_t a = { 0, 0, 0 }; |
947
929f84cc63c3
stsd fix by (Baptiste COUDURIER )baptiste.coudurier smartjog com)
michael
parents:
943
diff
changeset
|
795 offset_t start_pos = url_ftell(pb); |
887 | 796 int size = get_be32(pb); /* size */ |
0 | 797 format = get_le32(pb); /* data format */ |
118 | 798 |
0 | 799 get_be32(pb); /* reserved */ |
800 get_be16(pb); /* reserved */ | |
801 get_be16(pb); /* index */ | |
802 | |
1156 | 803 if (st->codec->codec_tag) { |
804 /* multiple fourcc, just skip for now */ | |
805 url_fskip(pb, size - (url_ftell(pb) - start_pos)); | |
806 continue; | |
807 } | |
808 | |
887 | 809 st->codec->codec_tag = format; |
1032 | 810 id = codec_get_id(mov_audio_tags, format); |
1448
e8dc38807927
do not overwrite codec type if already known, fix conflict between 'raw ' fourcc used for audio and video, ae002_wordup.mov
bcoudurier
parents:
1447
diff
changeset
|
811 if (st->codec->codec_type != CODEC_TYPE_VIDEO && id > 0) { |
1032 | 812 st->codec->codec_type = CODEC_TYPE_AUDIO; |
1448
e8dc38807927
do not overwrite codec type if already known, fix conflict between 'raw ' fourcc used for audio and video, ae002_wordup.mov
bcoudurier
parents:
1447
diff
changeset
|
813 } else if (st->codec->codec_type != CODEC_TYPE_AUDIO && /* do not overwrite codec type */ |
e8dc38807927
do not overwrite codec type if already known, fix conflict between 'raw ' fourcc used for audio and video, ae002_wordup.mov
bcoudurier
parents:
1447
diff
changeset
|
814 format && format != MKTAG('m', 'p', '4', 's')) { /* skip old asf mpeg4 tag */ |
1032 | 815 id = codec_get_id(mov_video_tags, format); |
816 if (id <= 0) | |
817 id = codec_get_id(codec_bmp_tags, format); | |
818 if (id > 0) | |
819 st->codec->codec_type = CODEC_TYPE_VIDEO; | |
820 } | |
821 | |
1067
3d7fae1dfda4
skip null fourcc, fix ep2_mystery_m640_dummy.mov
bcoudurier
parents:
1063
diff
changeset
|
822 dprintf("size=%d 4CC= %c%c%c%c codec_type=%d\n", |
3d7fae1dfda4
skip null fourcc, fix ep2_mystery_m640_dummy.mov
bcoudurier
parents:
1063
diff
changeset
|
823 size, |
3d7fae1dfda4
skip null fourcc, fix ep2_mystery_m640_dummy.mov
bcoudurier
parents:
1063
diff
changeset
|
824 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, (format >> 24) & 0xff, |
3d7fae1dfda4
skip null fourcc, fix ep2_mystery_m640_dummy.mov
bcoudurier
parents:
1063
diff
changeset
|
825 st->codec->codec_type); |
3d7fae1dfda4
skip null fourcc, fix ep2_mystery_m640_dummy.mov
bcoudurier
parents:
1063
diff
changeset
|
826 |
887 | 827 if(st->codec->codec_type==CODEC_TYPE_VIDEO) { |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
828 st->codec->codec_id = id; |
0 | 829 get_be16(pb); /* version */ |
830 get_be16(pb); /* revision level */ | |
831 get_be32(pb); /* vendor */ | |
832 get_be32(pb); /* temporal quality */ | |
833 get_be32(pb); /* spacial quality */ | |
1063
f0de744f87f9
set width and height even for mpeg4, pix_fmt to NONE will force decoding anwyay
bcoudurier
parents:
1062
diff
changeset
|
834 |
f0de744f87f9
set width and height even for mpeg4, pix_fmt to NONE will force decoding anwyay
bcoudurier
parents:
1062
diff
changeset
|
835 st->codec->width = get_be16(pb); /* width */ |
f0de744f87f9
set width and height even for mpeg4, pix_fmt to NONE will force decoding anwyay
bcoudurier
parents:
1062
diff
changeset
|
836 st->codec->height = get_be16(pb); /* height */ |
f0de744f87f9
set width and height even for mpeg4, pix_fmt to NONE will force decoding anwyay
bcoudurier
parents:
1062
diff
changeset
|
837 |
0 | 838 get_be32(pb); /* horiz resolution */ |
839 get_be32(pb); /* vert resolution */ | |
840 get_be32(pb); /* data size, always 0 */ | |
118 | 841 frames_per_sample = get_be16(pb); /* frames per samples */ |
0 | 842 #ifdef DEBUG |
887 | 843 av_log(NULL, AV_LOG_DEBUG, "frames/samples = %d\n", frames_per_sample); |
0 | 844 #endif |
1011 | 845 get_buffer(pb, codec_name, 32); /* codec name, pascal string (FIXME: true for mp4?) */ |
846 if (codec_name[0] <= 31) { | |
847 memcpy(st->codec->codec_name, &codec_name[1],codec_name[0]); | |
848 st->codec->codec_name[codec_name[0]] = 0; | |
849 } | |
0 | 850 |
887 | 851 st->codec->bits_per_sample = get_be16(pb); /* depth */ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
852 st->codec->color_table_id = get_be16(pb); /* colortable id */ |
118 | 853 |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
854 /* figure out the palette situation */ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
855 color_depth = st->codec->bits_per_sample & 0x1F; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
856 color_greyscale = st->codec->bits_per_sample & 0x20; |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
857 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
858 /* if the depth is 2, 4, or 8 bpp, file is palettized */ |
885 | 859 if ((color_depth == 2) || (color_depth == 4) || |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
860 (color_depth == 8)) { |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
861 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
862 if (color_greyscale) { |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
863 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
864 /* compute the greyscale palette */ |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
865 color_count = 1 << color_depth; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
866 color_index = 255; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
867 color_dec = 256 / (color_count - 1); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
868 for (j = 0; j < color_count; j++) { |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
869 r = g = b = color_index; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
870 c->palette_control.palette[j] = |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
871 (r << 16) | (g << 8) | (b); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
872 color_index -= color_dec; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
873 if (color_index < 0) |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
874 color_index = 0; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
875 } |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
876 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
877 } else if (st->codec->color_table_id & 0x08) { |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
878 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
879 /* if flag bit 3 is set, use the default palette */ |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
880 color_count = 1 << color_depth; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
881 if (color_depth == 2) |
431 | 882 color_table = ff_qt_default_palette_4; |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
883 else if (color_depth == 4) |
431 | 884 color_table = ff_qt_default_palette_16; |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
885 else |
431 | 886 color_table = ff_qt_default_palette_256; |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
887 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
888 for (j = 0; j < color_count; j++) { |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
889 r = color_table[j * 4 + 0]; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
890 g = color_table[j * 4 + 1]; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
891 b = color_table[j * 4 + 2]; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
892 c->palette_control.palette[j] = |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
893 (r << 16) | (g << 8) | (b); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
894 } |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
895 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
896 } else { |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
897 |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
898 /* load the palette from the file */ |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
899 color_start = get_be32(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
900 color_count = get_be16(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
901 color_end = get_be16(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
902 for (j = color_start; j <= color_end; j++) { |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
903 /* each R, G, or B component is 16 bits; |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
904 * only use the top 8 bits; skip alpha bytes |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
905 * up front */ |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
906 get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
907 get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
908 r = get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
909 get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
910 g = get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
911 get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
912 b = get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
913 get_byte(pb); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
914 c->palette_control.palette[j] = |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
915 (r << 16) | (g << 8) | (b); |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
916 } |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
917 } |
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
918 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
919 st->codec->palctrl = &c->palette_control; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
920 st->codec->palctrl->palette_changed = 1; |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
921 } else |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
805
diff
changeset
|
922 st->codec->palctrl = NULL; |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
923 } else if(st->codec->codec_type==CODEC_TYPE_AUDIO) { |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
924 int bits_per_sample; |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
925 uint16_t version = get_be16(pb); |
302
6949df67922d
added palette support to the QT demuxer; registered SMC video decoder
melanson
parents:
301
diff
changeset
|
926 |
1032 | 927 st->codec->codec_id = id; |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
928 get_be16(pb); /* revision level */ |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
929 get_be32(pb); /* vendor */ |
118 | 930 |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
931 st->codec->channels = get_be16(pb); /* channel count */ |
1215 | 932 dprintf("audio channels %d\n", st->codec->channels); |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
933 st->codec->bits_per_sample = get_be16(pb); /* sample size */ |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
934 /* do we need to force to 16 for AMR ? */ |
690
fec605ce7d4a
mp4a fix based on some code by (Song.Itany inventec-inc com)
michael
parents:
683
diff
changeset
|
935 |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
936 /* handle specific s8 codec */ |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
937 get_be16(pb); /* compression id = 0*/ |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
938 get_be16(pb); /* packet size = 0 */ |
849
44b415886cbf
sample_rate value is not always correct (is there anything in quicktime which is?) so try to guess it from time_scale
michael
parents:
822
diff
changeset
|
939 |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
940 st->codec->sample_rate = ((get_be32(pb) >> 16)); |
690
fec605ce7d4a
mp4a fix based on some code by (Song.Itany inventec-inc com)
michael
parents:
683
diff
changeset
|
941 |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
942 switch (st->codec->codec_id) { |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
943 case CODEC_ID_PCM_S8: |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
944 case CODEC_ID_PCM_U8: |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
945 if (st->codec->bits_per_sample == 16) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
946 st->codec->codec_id = CODEC_ID_PCM_S16BE; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
947 break; |
1029 | 948 case CODEC_ID_PCM_S16LE: |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
949 case CODEC_ID_PCM_S16BE: |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
950 if (st->codec->bits_per_sample == 8) |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
951 st->codec->codec_id = CODEC_ID_PCM_S8; |
1334
5825a7bc0d96
change codec id if sample size field is set to 24 in stsd, fix Sony-mx5p.mov
bcoudurier
parents:
1299
diff
changeset
|
952 else if (st->codec->bits_per_sample == 24) |
5825a7bc0d96
change codec id if sample size field is set to 24 in stsd, fix Sony-mx5p.mov
bcoudurier
parents:
1299
diff
changeset
|
953 st->codec->codec_id = CODEC_ID_PCM_S24BE; |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
954 break; |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
955 default: |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
956 break; |
428
5ac07c7b4874
correctly identify AAC audio in mov/mp4/etc. files. patch by ("Thomas Raivio" <tjraivio at cc dot hut dot fi>)
michael
parents:
401
diff
changeset
|
957 } |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
958 |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
959 //Read QT version 1 fields. In version 0 theese dont exist |
1446
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
960 dprintf("version =%d, isom =%d\n",version,c->isom); |
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
961 if(!c->isom) { |
1447 | 962 if(version==1) { |
963 sc->sample_size_v1.den = get_be32(pb); /* samples per packet */ | |
964 get_be32(pb); /* bytes per packet */ | |
965 sc->sample_size_v1.num = get_be32(pb); /* bytes per frame */ | |
966 get_be32(pb); /* bytes per sample */ | |
967 } else if(version==2) { | |
968 get_be32(pb); /* sizeof struct only */ | |
969 st->codec->sample_rate = av_int2dbl(get_be64(pb)); /* float 64 */ | |
970 st->codec->channels = get_be32(pb); | |
971 get_be32(pb); /* always 0x7F000000 */ | |
972 get_be32(pb); /* bits per channel if sound is uncompressed */ | |
973 get_be32(pb); /* lcpm format specific flag */ | |
974 get_be32(pb); /* bytes per audio packet if constant */ | |
975 get_be32(pb); /* lpcm frames per audio packet if constant */ | |
976 } | |
1446
a353426e83e5
reintroduce isom field and read version 1 audio stsd only if file is not isom, fix testclip_wrong_version_1_audio_stsd.mp4
bcoudurier
parents:
1443
diff
changeset
|
977 } |
1336
06a5d191774d
move sample size adjusting code after audio stsd v2 parsing to let v2 set correct channel number, fix Sony-hdv2.mov
bcoudurier
parents:
1335
diff
changeset
|
978 |
06a5d191774d
move sample size adjusting code after audio stsd v2 parsing to let v2 set correct channel number, fix Sony-hdv2.mov
bcoudurier
parents:
1335
diff
changeset
|
979 bits_per_sample = av_get_bits_per_sample(st->codec->codec_id); |
06a5d191774d
move sample size adjusting code after audio stsd v2 parsing to let v2 set correct channel number, fix Sony-hdv2.mov
bcoudurier
parents:
1335
diff
changeset
|
980 if (bits_per_sample) { |
06a5d191774d
move sample size adjusting code after audio stsd v2 parsing to let v2 set correct channel number, fix Sony-hdv2.mov
bcoudurier
parents:
1335
diff
changeset
|
981 st->codec->bits_per_sample = bits_per_sample; |
06a5d191774d
move sample size adjusting code after audio stsd v2 parsing to let v2 set correct channel number, fix Sony-hdv2.mov
bcoudurier
parents:
1335
diff
changeset
|
982 sc->sample_size = (bits_per_sample >> 3) * st->codec->channels; |
06a5d191774d
move sample size adjusting code after audio stsd v2 parsing to let v2 set correct channel number, fix Sony-hdv2.mov
bcoudurier
parents:
1335
diff
changeset
|
983 } |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
984 } else { |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
985 /* other codec type, just skip (rtp, mp4s, tmcd ...) */ |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
986 url_fskip(pb, size - (url_ftell(pb) - start_pos)); |
0 | 987 } |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
988 /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */ |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
989 a.size = size - (url_ftell(pb) - start_pos); |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
990 if (a.size > 8) |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
991 mov_read_default(c, pb, a); |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
992 else if (a.size > 0) |
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
993 url_fskip(pb, a.size); |
0 | 994 } |
885 | 995 |
849
44b415886cbf
sample_rate value is not always correct (is there anything in quicktime which is?) so try to guess it from time_scale
michael
parents:
822
diff
changeset
|
996 if(st->codec->codec_type==CODEC_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1) { |
44b415886cbf
sample_rate value is not always correct (is there anything in quicktime which is?) so try to guess it from time_scale
michael
parents:
822
diff
changeset
|
997 st->codec->sample_rate= sc->time_scale; |
44b415886cbf
sample_rate value is not always correct (is there anything in quicktime which is?) so try to guess it from time_scale
michael
parents:
822
diff
changeset
|
998 } |
1039 | 999 |
1271
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1000 /* special codec parameters handling */ |
1039 | 1001 switch (st->codec->codec_id) { |
1271
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1002 #ifdef CONFIG_H261_DECODER |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1003 case CODEC_ID_H261: |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1004 #endif |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1005 #ifdef CONFIG_H263_DECODER |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1006 case CODEC_ID_H263: |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1007 #endif |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1008 #ifdef CONFIG_MPEG4_DECODER |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1009 case CODEC_ID_MPEG4: |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1010 #endif |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1011 st->codec->width= 0; /* let decoder init width/height */ |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1012 st->codec->height= 0; |
8c80d41a11cc
dont set width/height for h261/h263/mpeg4 since they are oftenly wrong, let decoder init them
bcoudurier
parents:
1270
diff
changeset
|
1013 break; |
1621
2f3091d284f8
Rename variables: faad --> libfaad, faac --> libfaac, faadbin --> libfaadbin
diego
parents:
1495
diff
changeset
|
1014 #ifdef CONFIG_LIBFAAD |
1039 | 1015 case CODEC_ID_AAC: |
1016 #endif | |
1040
3c523d59d55c
let vorbis decoder init too, fix mi2_vorbis51.mp4
bcoudurier
parents:
1039
diff
changeset
|
1017 #ifdef CONFIG_VORBIS_DECODER |
3c523d59d55c
let vorbis decoder init too, fix mi2_vorbis51.mp4
bcoudurier
parents:
1039
diff
changeset
|
1018 case CODEC_ID_VORBIS: |
3c523d59d55c
let vorbis decoder init too, fix mi2_vorbis51.mp4
bcoudurier
parents:
1039
diff
changeset
|
1019 #endif |
1039 | 1020 case CODEC_ID_MP3ON4: |
1021 st->codec->sample_rate= 0; /* let decoder init parameters properly */ | |
1022 break; | |
1269 | 1023 #ifdef CONFIG_DV_DEMUXER |
1268 | 1024 case CODEC_ID_DVAUDIO: |
1025 c->dv_fctx = av_alloc_format_context(); | |
1026 c->dv_demux = dv_init_demux(c->dv_fctx); | |
1027 if (!c->dv_demux) { | |
1028 av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n"); | |
1029 return -1; | |
1030 } | |
1031 sc->dv_audio_container = 1; | |
1032 st->codec->codec_id = CODEC_ID_PCM_S16LE; | |
1033 break; | |
1269 | 1034 #endif |
1272
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1035 /* no ifdef since parameters are always those */ |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1036 case CODEC_ID_AMR_WB: |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1037 st->codec->sample_rate= 16000; |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1038 st->codec->channels= 1; /* really needed */ |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1039 break; |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1040 case CODEC_ID_AMR_NB: |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1041 st->codec->sample_rate= 8000; |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1042 st->codec->channels= 1; /* really needed */ |
943d9957b96a
move amr parameters adjusting like other codecs
bcoudurier
parents:
1271
diff
changeset
|
1043 break; |
1299 | 1044 case CODEC_ID_MP2: |
1471
ad18f1010f47
support m1a hdlr mpeg elementary audio handler, fix Po-Slow_Death_64K.mov
bcoudurier
parents:
1448
diff
changeset
|
1045 st->codec->codec_type = CODEC_TYPE_AUDIO; /* force type after stsd for m1a hdlr */ |
1299 | 1046 st->need_parsing = 1; |
1047 break; | |
1039 | 1048 default: |
1049 break; | |
1033
a757a0a3824f
let faad init parameters properly, fix many SBR samples
bcoudurier
parents:
1032
diff
changeset
|
1050 } |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1051 |
0 | 1052 return 0; |
1053 } | |
1054 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1055 static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 1056 { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1057 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1058 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
639 | 1059 unsigned int i, entries; |
0 | 1060 |
1061 get_byte(pb); /* version */ | |
1062 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
1063 | |
1064 entries = get_be32(pb); | |
885 | 1065 |
639 | 1066 if(entries >= UINT_MAX / sizeof(MOV_sample_to_chunk_tbl)) |
1067 return -1; | |
885 | 1068 |
0 | 1069 #ifdef DEBUG |
491 | 1070 av_log(NULL, AV_LOG_DEBUG, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries); |
0 | 1071 #endif |
1072 sc->sample_to_chunk_sz = entries; | |
1338 | 1073 sc->sample_to_chunk = av_malloc(entries * sizeof(MOV_sample_to_chunk_tbl)); |
121 | 1074 if (!sc->sample_to_chunk) |
1075 return -1; | |
0 | 1076 for(i=0; i<entries; i++) { |
1077 sc->sample_to_chunk[i].first = get_be32(pb); | |
1078 sc->sample_to_chunk[i].count = get_be32(pb); | |
1079 sc->sample_to_chunk[i].id = get_be32(pb); | |
1080 } | |
1081 return 0; | |
1082 } | |
1083 | |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1084 static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1085 { |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1086 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1087 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
639 | 1088 unsigned int i, entries; |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1089 |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1090 get_byte(pb); /* version */ |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1091 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1092 |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1093 entries = get_be32(pb); |
885 | 1094 |
639 | 1095 if(entries >= UINT_MAX / sizeof(long)) |
1096 return -1; | |
885 | 1097 |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1098 sc->keyframe_count = entries; |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1099 #ifdef DEBUG |
1734 | 1100 av_log(NULL, AV_LOG_DEBUG, "keyframe_count = %d\n", sc->keyframe_count); |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1101 #endif |
1338 | 1102 sc->keyframes = av_malloc(entries * sizeof(long)); |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1103 if (!sc->keyframes) |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1104 return -1; |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1105 for(i=0; i<entries; i++) { |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1106 sc->keyframes[i] = get_be32(pb); |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1107 #ifdef DEBUG |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1108 /* av_log(NULL, AV_LOG_DEBUG, "keyframes[]=%ld\n", sc->keyframes[i]); */ |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1109 #endif |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1110 } |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1111 return 0; |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1112 } |
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1113 |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1114 static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 1115 { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1116 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1117 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1118 unsigned int i, entries, sample_size; |
121 | 1119 |
0 | 1120 get_byte(pb); /* version */ |
1121 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
118 | 1122 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1123 sample_size = get_be32(pb); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1124 if (!sc->sample_size) /* do not overwrite value computed in stsd */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1125 sc->sample_size = sample_size; |
0 | 1126 entries = get_be32(pb); |
639 | 1127 if(entries >= UINT_MAX / sizeof(long)) |
1128 return -1; | |
1129 | |
0 | 1130 sc->sample_count = entries; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1131 if (sample_size) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1132 return 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1133 |
0 | 1134 #ifdef DEBUG |
1734 | 1135 av_log(NULL, AV_LOG_DEBUG, "sample_size = %d sample_count = %d\n", sc->sample_size, sc->sample_count); |
0 | 1136 #endif |
1338 | 1137 sc->sample_sizes = av_malloc(entries * sizeof(long)); |
121 | 1138 if (!sc->sample_sizes) |
1139 return -1; | |
0 | 1140 for(i=0; i<entries; i++) { |
1141 sc->sample_sizes[i] = get_be32(pb); | |
1142 #ifdef DEBUG | |
653
c61da0556426
Revert the fixed-size-sample patch as it brokes and others
mmu_man
parents:
652
diff
changeset
|
1143 av_log(NULL, AV_LOG_DEBUG, "sample_sizes[]=%ld\n", sc->sample_sizes[i]); |
0 | 1144 #endif |
1145 } | |
1146 return 0; | |
1147 } | |
1148 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1149 static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 1150 { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1151 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
928 | 1152 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
639 | 1153 unsigned int i, entries; |
395
c1ed10f3b052
cleanup frame_rate code, this may also fix some large file bugs
michael
parents:
383
diff
changeset
|
1154 int64_t duration=0; |
c1ed10f3b052
cleanup frame_rate code, this may also fix some large file bugs
michael
parents:
383
diff
changeset
|
1155 int64_t total_sample_count=0; |
121 | 1156 |
0 | 1157 get_byte(pb); /* version */ |
1158 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
1159 entries = get_be32(pb); | |
670 | 1160 if(entries >= UINT_MAX / sizeof(Time2Sample)) |
639 | 1161 return -1; |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
1162 |
928 | 1163 sc->stts_count = entries; |
1164 sc->stts_data = av_malloc(entries * sizeof(Time2Sample)); | |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
1165 |
0 | 1166 #ifdef DEBUG |
491 | 1167 av_log(NULL, AV_LOG_DEBUG, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries); |
0 | 1168 #endif |
928 | 1169 |
1170 sc->time_rate=0; | |
1171 | |
0 | 1172 for(i=0; i<entries; i++) { |
670 | 1173 int sample_duration; |
1174 int sample_count; | |
0 | 1175 |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
1176 sample_count=get_be32(pb); |
0 | 1177 sample_duration = get_be32(pb); |
928 | 1178 sc->stts_data[i].count= sample_count; |
1179 sc->stts_data[i].duration= sample_duration; | |
1180 | |
1181 sc->time_rate= ff_gcd(sc->time_rate, sample_duration); | |
794
040cf31abb4b
another chapter in the neverending mov demuxer cleanup
michael
parents:
775
diff
changeset
|
1182 |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1183 dprintf("sample_count=%d, sample_duration=%d\n",sample_count,sample_duration); |
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1184 |
1027 | 1185 duration+=(int64_t)sample_duration*sample_count; |
134
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
1186 total_sample_count+=sample_count; |
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
1187 } |
5cda954c6e9a
AMR-NB audio support patch by (<joca at rixmail dot se>)
michaelni
parents:
133
diff
changeset
|
1188 |
794
040cf31abb4b
another chapter in the neverending mov demuxer cleanup
michael
parents:
775
diff
changeset
|
1189 st->nb_frames= total_sample_count; |
040cf31abb4b
another chapter in the neverending mov demuxer cleanup
michael
parents:
775
diff
changeset
|
1190 if(duration) |
040cf31abb4b
another chapter in the neverending mov demuxer cleanup
michael
parents:
775
diff
changeset
|
1191 st->duration= duration; |
0 | 1192 return 0; |
1193 } | |
1194 | |
671 | 1195 static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
1196 { | |
1005
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1197 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1198 MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; |
671 | 1199 unsigned int i, entries; |
1200 | |
1201 get_byte(pb); /* version */ | |
1202 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
1203 entries = get_be32(pb); | |
1204 if(entries >= UINT_MAX / sizeof(Time2Sample)) | |
1205 return -1; | |
1206 | |
1005
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1207 sc->ctts_count = entries; |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1208 sc->ctts_data = av_malloc(entries * sizeof(Time2Sample)); |
671 | 1209 |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1210 dprintf("track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries); |
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1211 |
671 | 1212 for(i=0; i<entries; i++) { |
1005
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1213 int count =get_be32(pb); |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1214 int duration =get_be32(pb); |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1215 |
1042
d641f2cdb692
ignore wrong negative cts values created by quicktime
bcoudurier
parents:
1040
diff
changeset
|
1216 if (duration < 0) { |
d641f2cdb692
ignore wrong negative cts values created by quicktime
bcoudurier
parents:
1040
diff
changeset
|
1217 av_log(c->fc, AV_LOG_ERROR, "negative ctts, ignoring\n"); |
d641f2cdb692
ignore wrong negative cts values created by quicktime
bcoudurier
parents:
1040
diff
changeset
|
1218 sc->ctts_count = 0; |
d641f2cdb692
ignore wrong negative cts values created by quicktime
bcoudurier
parents:
1040
diff
changeset
|
1219 url_fskip(pb, 8 * (entries - i - 1)); |
d641f2cdb692
ignore wrong negative cts values created by quicktime
bcoudurier
parents:
1040
diff
changeset
|
1220 break; |
d641f2cdb692
ignore wrong negative cts values created by quicktime
bcoudurier
parents:
1040
diff
changeset
|
1221 } |
1005
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1222 sc->ctts_data[i].count = count; |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1223 sc->ctts_data[i].duration= duration; |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1224 |
d5b8ab2409f7
some mov files have invalid pts so we need to consider these pts too in calculating the timabase
michael
parents:
999
diff
changeset
|
1225 sc->time_rate= ff_gcd(sc->time_rate, duration); |
671 | 1226 } |
1227 return 0; | |
1228 } | |
1229 | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1230 static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1231 { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1232 AVStream *st; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1233 MOVStreamContext *sc; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1234 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1235 st = av_new_stream(c->fc, c->fc->nb_streams); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1236 if (!st) return -2; |
1338 | 1237 sc = av_mallocz(sizeof(MOVStreamContext)); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1238 if (!sc) { |
887 | 1239 av_free(st); |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1240 return -1; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1241 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1242 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1243 st->priv_data = sc; |
1118 | 1244 st->codec->codec_type = CODEC_TYPE_DATA; |
191 | 1245 st->start_time = 0; /* XXX: check */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1246 c->streams[c->fc->nb_streams-1] = sc; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1247 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1248 return mov_read_default(c, pb, atom); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1249 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1250 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1251 static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1252 { |
1023 | 1253 AVStream *st = c->fc->streams[c->fc->nb_streams-1]; |
1254 int version = get_byte(pb); | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1255 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1256 get_byte(pb); get_byte(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1257 get_byte(pb); /* flags */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1258 /* |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1259 MOV_TRACK_ENABLED 0x0001 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1260 MOV_TRACK_IN_MOVIE 0x0002 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1261 MOV_TRACK_IN_PREVIEW 0x0004 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1262 MOV_TRACK_IN_POSTER 0x0008 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1263 */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1264 |
1022 | 1265 if (version == 1) { |
1266 get_be64(pb); | |
1267 get_be64(pb); | |
1268 } else { | |
1269 get_be32(pb); /* creation time */ | |
1270 get_be32(pb); /* modification time */ | |
1271 } | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1272 st->id = (int)get_be32(pb); /* track id (NOT 0 !)*/ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1273 get_be32(pb); /* reserved */ |
191 | 1274 st->start_time = 0; /* check */ |
1022 | 1275 (version == 1) ? get_be64(pb) : get_be32(pb); /* highlevel (considering edits) duration in movie timebase */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1276 get_be32(pb); /* reserved */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1277 get_be32(pb); /* reserved */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1278 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1279 get_be16(pb); /* layer */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1280 get_be16(pb); /* alternate group */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1281 get_be16(pb); /* volume */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1282 get_be16(pb); /* reserved */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1283 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1284 url_fskip(pb, 36); /* display matrix */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1285 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1286 /* those are fixed-point */ |
1113 | 1287 get_be32(pb); /* track width */ |
1288 get_be32(pb); /* track height */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1289 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1290 return 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1291 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1292 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1293 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1294 /* like the files created with Adobe Premiere 5.0, for samples see */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1295 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1296 static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1297 { |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1298 int err; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1299 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1300 if (atom.size < 8) |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1301 return 0; /* continue */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1302 if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1303 url_fskip(pb, atom.size - 4); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1304 return 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1305 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1306 atom.type = get_le32(pb); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1307 atom.offset += 8; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1308 atom.size -= 8; |
131 | 1309 if (atom.type != MKTAG('m', 'd', 'a', 't')) { |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1310 url_fskip(pb, atom.size); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1311 return 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1312 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1313 err = mov_read_mdat(c, pb, atom); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1314 return err; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1315 } |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1316 |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1317 static int mov_read_cmov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) |
0 | 1318 { |
1404
53803884feb7
warn about zlib support needed if file has compressed moov atom
bcoudurier
parents:
1403
diff
changeset
|
1319 #ifdef CONFIG_ZLIB |
0 | 1320 ByteIOContext ctx; |
121 | 1321 uint8_t *cmov_data; |
1322 uint8_t *moov_data; /* uncompressed data */ | |
0 | 1323 long cmov_len, moov_len; |
1324 int ret; | |
121 | 1325 |
0 | 1326 get_be32(pb); /* dcom atom */ |
1327 if (get_le32(pb) != MKTAG( 'd', 'c', 'o', 'm' )) | |
1328 return -1; | |
1329 if (get_le32(pb) != MKTAG( 'z', 'l', 'i', 'b' )) { | |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1330 av_log(NULL, AV_LOG_ERROR, "unknown compression for cmov atom !"); |
0 | 1331 return -1; |
1332 } | |
1333 get_be32(pb); /* cmvd atom */ | |
1334 if (get_le32(pb) != MKTAG( 'c', 'm', 'v', 'd' )) | |
1335 return -1; | |
1336 moov_len = get_be32(pb); /* uncompressed size */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1337 cmov_len = atom.size - 6 * 4; |
118 | 1338 |
1338 | 1339 cmov_data = av_malloc(cmov_len); |
0 | 1340 if (!cmov_data) |
1341 return -1; | |
1338 | 1342 moov_data = av_malloc(moov_len); |
0 | 1343 if (!moov_data) { |
1344 av_free(cmov_data); | |
1345 return -1; | |
1346 } | |
1347 get_buffer(pb, cmov_data, cmov_len); | |
121 | 1348 if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK) |
0 | 1349 return -1; |
1403
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1402
diff
changeset
|
1350 if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0) |
0 | 1351 return -1; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1352 atom.type = MKTAG( 'm', 'o', 'o', 'v' ); |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1353 atom.offset = 0; |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1354 atom.size = moov_len; |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
1355 #ifdef DEBUG |
953 | 1356 // { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); } |
132
9ca36221ae23
* passing ImageDescriptions for SVQ3 (Vertical300K.sorenson works)
kabi
parents:
131
diff
changeset
|
1357 #endif |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1358 ret = mov_read_default(c, &ctx, atom); |
0 | 1359 av_free(moov_data); |
1360 av_free(cmov_data); | |
1361 return ret; | |
1404
53803884feb7
warn about zlib support needed if file has compressed moov atom
bcoudurier
parents:
1403
diff
changeset
|
1362 #else |
53803884feb7
warn about zlib support needed if file has compressed moov atom
bcoudurier
parents:
1403
diff
changeset
|
1363 av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n"); |
53803884feb7
warn about zlib support needed if file has compressed moov atom
bcoudurier
parents:
1403
diff
changeset
|
1364 return -1; |
53803884feb7
warn about zlib support needed if file has compressed moov atom
bcoudurier
parents:
1403
diff
changeset
|
1365 #endif |
0 | 1366 } |
1367 | |
491 | 1368 /* edit list atom */ |
1369 static int mov_read_elst(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom) | |
1370 { | |
1061 | 1371 int i, edit_count; |
491 | 1372 |
1061 | 1373 get_byte(pb); /* version */ |
1374 get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ | |
1375 edit_count= c->streams[c->fc->nb_streams-1]->edit_count = get_be32(pb); /* entries */ | |
885 | 1376 |
1061 | 1377 for(i=0; i<edit_count; i++){ |
1378 get_be32(pb); /* Track duration */ | |
1379 get_be32(pb); /* Media time */ | |
1380 get_be32(pb); /* Media rate */ | |
1381 } | |
1382 dprintf("track[%i].edit_count = %i\n", c->fc->nb_streams-1, c->streams[c->fc->nb_streams-1]->edit_count); | |
1383 return 0; | |
491 | 1384 } |
1385 | |
0 | 1386 static const MOVParseTableEntry mov_default_parse_table[] = { |
1387 /* mp4 atoms */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1388 { MKTAG( 'c', 'o', '6', '4' ), mov_read_stco }, |
671 | 1389 { MKTAG( 'c', 't', 't', 's' ), mov_read_ctts }, /* composition time to sample */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1390 { MKTAG( 'e', 'd', 't', 's' ), mov_read_default }, |
500
4070a7d58d2c
mov_read_elst fix, based upon a patch by (Sebastien Bechet <s.bechet at av7 dot net>)
michael
parents:
499
diff
changeset
|
1391 { MKTAG( 'e', 'l', 's', 't' ), mov_read_elst }, |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
1392 { MKTAG( 'e', 'n', 'd', 'a' ), mov_read_enda }, |
963
5783108b1478
add mov_read_ftyp to check iso media file type and set c->mp4 patch by (Baptiste COUDURIER <baptiste.coudurier 0 smartjog o com>)
michael
parents:
959
diff
changeset
|
1393 { MKTAG( 'f', 't', 'y', 'p' ), mov_read_ftyp }, |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1394 { MKTAG( 'h', 'd', 'l', 'r' ), mov_read_hdlr }, |
997
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
1395 { MKTAG( 'j', 'p', '2', 'h' ), mov_read_jp2h }, |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1396 { MKTAG( 'm', 'd', 'a', 't' ), mov_read_mdat }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1397 { MKTAG( 'm', 'd', 'h', 'd' ), mov_read_mdhd }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1398 { MKTAG( 'm', 'd', 'i', 'a' ), mov_read_default }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1399 { MKTAG( 'm', 'i', 'n', 'f' ), mov_read_default }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1400 { MKTAG( 'm', 'o', 'o', 'v' ), mov_read_moov }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1401 { MKTAG( 'm', 'v', 'h', 'd' ), mov_read_mvhd }, |
615 | 1402 { MKTAG( 'S', 'M', 'I', ' ' ), mov_read_smi }, /* Sorenson extension ??? */ |
968
dbf4bc73c7c9
Cleans reading stsd audio, and makes it more generic patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com>)
michael
parents:
967
diff
changeset
|
1403 { MKTAG( 'a', 'l', 'a', 'c' ), mov_read_alac }, /* alac specific atom */ |
885 | 1404 { MKTAG( 'a', 'v', 'c', 'C' ), mov_read_avcC }, |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1405 { MKTAG( 's', 't', 'b', 'l' ), mov_read_default }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1406 { MKTAG( 's', 't', 'c', 'o' ), mov_read_stco }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1407 { MKTAG( 's', 't', 's', 'c' ), mov_read_stsc }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1408 { MKTAG( 's', 't', 's', 'd' ), mov_read_stsd }, /* sample description */ |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1409 { MKTAG( 's', 't', 's', 's' ), mov_read_stss }, /* sync sample */ |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1410 { MKTAG( 's', 't', 's', 'z' ), mov_read_stsz }, /* sample size */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1411 { MKTAG( 's', 't', 't', 's' ), mov_read_stts }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1412 { MKTAG( 't', 'k', 'h', 'd' ), mov_read_tkhd }, /* track header */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1413 { MKTAG( 't', 'r', 'a', 'k' ), mov_read_trak }, |
865 | 1414 { MKTAG( 'w', 'a', 'v', 'e' ), mov_read_wave }, |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1415 { MKTAG( 'c', 't', 'a', 'b' ), mov_read_ctab }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1416 { MKTAG( 'e', 's', 'd', 's' ), mov_read_esds }, |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1417 { MKTAG( 'w', 'i', 'd', 'e' ), mov_read_wide }, /* place holder */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1418 { MKTAG( 'c', 'm', 'o', 'v' ), mov_read_cmov }, |
1418
9720274e2621
remove mov_read_leaf and remove useless reading function table, mov_read_default will skip atom with no parsing function anyway
bcoudurier
parents:
1415
diff
changeset
|
1419 { 0L, NULL } |
0 | 1420 }; |
1421 | |
1422 static void mov_free_stream_context(MOVStreamContext *sc) | |
1423 { | |
1424 if(sc) { | |
885 | 1425 av_freep(&sc->ctts_data); |
671 | 1426 av_freep(&sc); |
0 | 1427 } |
1428 } | |
1429 | |
121 | 1430 /* XXX: is it sufficient ? */ |
0 | 1431 static int mov_probe(AVProbeData *p) |
1432 { | |
1433 unsigned int offset; | |
1434 uint32_t tag; | |
658 | 1435 int score = 0; |
0 | 1436 |
1437 /* check file header */ | |
1438 if (p->buf_size <= 12) | |
1439 return 0; | |
1440 offset = 0; | |
1441 for(;;) { | |
1442 /* ignore invalid offset */ | |
1443 if ((offset + 8) > (unsigned int)p->buf_size) | |
658 | 1444 return score; |
1673 | 1445 tag = AV_RL32(p->buf + offset + 4); |
0 | 1446 switch(tag) { |
658 | 1447 /* check for obvious tags */ |
997
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
1448 case MKTAG( 'j', 'P', ' ', ' ' ): /* jpeg 2000 signature */ |
0 | 1449 case MKTAG( 'm', 'o', 'o', 'v' ): |
24 | 1450 case MKTAG( 'm', 'd', 'a', 't' ): |
1451 case MKTAG( 'p', 'n', 'o', 't' ): /* detect movs with preview pics like ew.mov and april.mov */ | |
146 | 1452 case MKTAG( 'u', 'd', 't', 'a' ): /* Packet Video PVAuthor adds this and a lot of more junk */ |
0 | 1453 return AVPROBE_SCORE_MAX; |
658 | 1454 /* those are more common words, so rate then a bit less */ |
1455 case MKTAG( 'w', 'i', 'd', 'e' ): | |
1456 case MKTAG( 'f', 'r', 'e', 'e' ): | |
1457 case MKTAG( 'j', 'u', 'n', 'k' ): | |
1458 case MKTAG( 'p', 'i', 'c', 't' ): | |
1459 return AVPROBE_SCORE_MAX - 5; | |
0 | 1460 case MKTAG( 'f', 't', 'y', 'p' ): |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1461 case MKTAG( 's', 'k', 'i', 'p' ): |
712
31e58b79ed02
Patch for "uuid" atom followed after atom "ftyp" by "QuickTime <ffmpeg AT gmail DOT com>"
mmu_man
parents:
708
diff
changeset
|
1462 case MKTAG( 'u', 'u', 'i', 'd' ): |
1673 | 1463 offset = AV_RB32(p->buf+offset) + offset; |
658 | 1464 /* if we only find those cause probedata is too small at least rate them */ |
1465 score = AVPROBE_SCORE_MAX - 50; | |
0 | 1466 break; |
1467 default: | |
1468 /* unrecognized tag */ | |
658 | 1469 return score; |
0 | 1470 } |
1471 } | |
658 | 1472 return score; |
0 | 1473 } |
1474 | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1475 static void mov_build_index(MOVContext *mov, AVStream *st) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1476 { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1477 MOVStreamContext *sc = st->priv_data; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1478 offset_t current_offset; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1479 int64_t current_dts = 0; |
1733 | 1480 unsigned int stts_index = 0; |
1481 unsigned int stsc_index = 0; | |
1482 unsigned int stss_index = 0; | |
1483 unsigned int i, j, k; | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1484 |
1268 | 1485 if (sc->sample_sizes || st->codec->codec_type == CODEC_TYPE_VIDEO || sc->dv_audio_container) { |
1733 | 1486 unsigned int current_sample = 0; |
1487 unsigned int stts_sample = 0; | |
1488 unsigned int keyframe, sample_size; | |
1489 unsigned int distance = 0; | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1490 |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1491 st->nb_frames = sc->sample_count; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1492 for (i = 0; i < sc->chunk_count; i++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1493 current_offset = sc->chunk_offsets[i]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1494 if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1495 stsc_index++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1496 for (j = 0; j < sc->sample_to_chunk[stsc_index].count; j++) { |
1732
fc47ca451446
stop if current sample is higher than sample count
bcoudurier
parents:
1731
diff
changeset
|
1497 if (current_sample >= sc->sample_count) { |
fc47ca451446
stop if current sample is higher than sample count
bcoudurier
parents:
1731
diff
changeset
|
1498 av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n"); |
fc47ca451446
stop if current sample is higher than sample count
bcoudurier
parents:
1731
diff
changeset
|
1499 goto out; |
fc47ca451446
stop if current sample is higher than sample count
bcoudurier
parents:
1731
diff
changeset
|
1500 } |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1501 keyframe = !sc->keyframe_count || current_sample + 1 == sc->keyframes[stss_index]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1502 if (keyframe) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1503 distance = 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1504 if (stss_index + 1 < sc->keyframe_count) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1505 stss_index++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1506 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1507 sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample]; |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1440
diff
changeset
|
1508 dprintf("AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", size %d, distance %d, keyframe %d\n", |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1509 st->index, current_sample, current_offset, current_dts, sample_size, distance, keyframe); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1510 av_add_index_entry(st, current_offset, current_dts, sample_size, distance, keyframe ? AVINDEX_KEYFRAME : 0); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1511 current_offset += sample_size; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1512 assert(sc->stts_data[stts_index].duration % sc->time_rate == 0); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1513 current_dts += sc->stts_data[stts_index].duration / sc->time_rate; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1514 distance++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1515 stts_sample++; |
1732
fc47ca451446
stop if current sample is higher than sample count
bcoudurier
parents:
1731
diff
changeset
|
1516 current_sample++; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1517 if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1518 stts_sample = 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1519 stts_index++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1520 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1521 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1522 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1523 } else { /* read whole chunk */ |
1733 | 1524 unsigned int chunk_samples, chunk_size, chunk_duration; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1525 |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1526 for (i = 0; i < sc->chunk_count; i++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1527 current_offset = sc->chunk_offsets[i]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1528 if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1529 stsc_index++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1530 chunk_samples = sc->sample_to_chunk[stsc_index].count; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1531 /* get chunk size */ |
1276
bc0b7f4637f0
fix mac3audio.mov, pcm_s8 and pcm_u8 can only have sample size of 1 and only if mono, dont rely on bits per sample which can be wrong
bcoudurier
parents:
1272
diff
changeset
|
1532 if (sc->sample_size > 1 || st->codec->codec_id == CODEC_ID_PCM_U8 || st->codec->codec_id == CODEC_ID_PCM_S8) |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1533 chunk_size = chunk_samples * sc->sample_size; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1534 else if (sc->sample_size_v1.den > 0 && (chunk_samples * sc->sample_size_v1.num % sc->sample_size_v1.den == 0)) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1535 chunk_size = chunk_samples * sc->sample_size_v1.num / sc->sample_size_v1.den; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1536 else { /* workaround to find nearest next chunk offset */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1537 chunk_size = INT_MAX; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1538 for (j = 0; j < mov->total_streams; j++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1539 MOVStreamContext *msc = mov->streams[j]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1540 |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1541 for (k = msc->next_chunk; k < msc->chunk_count; k++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1542 if (msc->chunk_offsets[k] > current_offset && msc->chunk_offsets[k] - current_offset < chunk_size) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1543 chunk_size = msc->chunk_offsets[k] - current_offset; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1544 msc->next_chunk = k; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1545 break; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1546 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1547 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1548 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1549 /* check for last chunk */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1550 if (chunk_size == INT_MAX) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1551 for (j = 0; j < mov->mdat_count; j++) { |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1440
diff
changeset
|
1552 dprintf("mdat %d, offset %"PRIx64", size %"PRId64", current offset %"PRIx64"\n", |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1553 j, mov->mdat_list[j].offset, mov->mdat_list[j].size, current_offset); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1554 if (mov->mdat_list[j].offset <= current_offset && mov->mdat_list[j].offset + mov->mdat_list[j].size > current_offset) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1555 chunk_size = mov->mdat_list[j].offset + mov->mdat_list[j].size - current_offset; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1556 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1557 assert(chunk_size != INT_MAX); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1558 for (j = 0; j < mov->total_streams; j++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1559 mov->streams[j]->next_chunk = 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1560 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1561 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1562 av_add_index_entry(st, current_offset, current_dts, chunk_size, 0, AVINDEX_KEYFRAME); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1563 /* get chunk duration */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1564 chunk_duration = 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1565 while (chunk_samples > 0) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1566 if (chunk_samples < sc->stts_data[stts_index].count) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1567 chunk_duration += sc->stts_data[stts_index].duration * chunk_samples; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1568 sc->stts_data[stts_index].count -= chunk_samples; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1569 break; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1570 } else { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1571 chunk_duration += sc->stts_data[stts_index].duration * chunk_samples; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1572 chunk_samples -= sc->stts_data[stts_index].count; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1573 if (stts_index + 1 < sc->stts_count) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1574 stts_index++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1575 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1576 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1577 } |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1440
diff
changeset
|
1578 dprintf("AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", size %d, duration %d\n", |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1579 st->index, i, current_offset, current_dts, chunk_size, chunk_duration); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1580 assert(chunk_duration % sc->time_rate == 0); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1581 current_dts += chunk_duration / sc->time_rate; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1582 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1583 } |
1732
fc47ca451446
stop if current sample is higher than sample count
bcoudurier
parents:
1731
diff
changeset
|
1584 out: |
1162 | 1585 /* adjust sample count to avindex entries */ |
1586 sc->sample_count = st->nb_index_entries; | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1587 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1588 |
0 | 1589 static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap) |
1590 { | |
121 | 1591 MOVContext *mov = (MOVContext *) s->priv_data; |
0 | 1592 ByteIOContext *pb = &s->pb; |
1118 | 1593 int i, err; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1594 MOV_atom_t atom = { 0, 0, 0 }; |
0 | 1595 |
1596 mov->fc = s; | |
121 | 1597 mov->parse_table = mov_default_parse_table; |
956
18bb4485996c
useless code removal by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
955
diff
changeset
|
1598 |
0 | 1599 if(!url_is_streamed(pb)) /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */ |
887 | 1600 atom.size = url_fsize(pb); |
0 | 1601 else |
887 | 1602 atom.size = 0x7FFFFFFFFFFFFFFFLL; |
0 | 1603 |
1604 /* check MOV header */ | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1605 err = mov_read_default(mov, pb, atom); |
133 | 1606 if (err<0 || (!mov->found_moov && !mov->found_mdat)) { |
887 | 1607 av_log(s, AV_LOG_ERROR, "mov: header not found !!! (err:%d, moov:%d, mdat:%d) pos:%"PRId64"\n", |
1608 err, mov->found_moov, mov->found_mdat, url_ftell(pb)); | |
1609 return -1; | |
0 | 1610 } |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1611 dprintf("on_parse_exit_offset=%d\n", (int) url_ftell(pb)); |
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1612 |
0 | 1613 /* some cleanup : make sure we are on the mdat atom */ |
1614 if(!url_is_streamed(pb) && (url_ftell(pb) != mov->mdat_offset)) | |
1615 url_fseek(pb, mov->mdat_offset, SEEK_SET); | |
1616 | |
1118 | 1617 mov->total_streams = s->nb_streams; |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1618 |
1118 | 1619 for(i=0; i<mov->total_streams; i++) { |
1620 MOVStreamContext *sc = mov->streams[i]; | |
1727 | 1621 /* sanity checks */ |
1622 if(!sc->stts_count || !sc->chunk_count || !sc->sample_to_chunk_sz || | |
1623 (!sc->sample_size && !sc->sample_count)){ | |
1624 av_log(s, AV_LOG_ERROR, "missing mandatory atoms, broken header\n"); | |
1625 return -1; | |
1626 } | |
1118 | 1627 if(!sc->time_rate) |
1628 sc->time_rate=1; | |
1629 if(!sc->time_scale) | |
1630 sc->time_scale= mov->time_scale; | |
1631 av_set_pts_info(s->streams[i], 64, sc->time_rate, sc->time_scale); | |
928 | 1632 |
1118 | 1633 if(s->streams[i]->duration != AV_NOPTS_VALUE){ |
1634 assert(s->streams[i]->duration % sc->time_rate == 0); | |
1635 s->streams[i]->duration /= sc->time_rate; | |
955 | 1636 } |
1118 | 1637 sc->ffindex = i; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1638 mov_build_index(mov, s->streams[i]); |
1110
a188feae9a07
simplify, completely ignore streams not recognized, that fixes seeking for some files
bcoudurier
parents:
1093
diff
changeset
|
1639 } |
928 | 1640 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1641 for(i=0; i<mov->total_streams; i++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1642 /* dont need those anymore */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1643 av_freep(&mov->streams[i]->chunk_offsets); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1644 av_freep(&mov->streams[i]->sample_to_chunk); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1645 av_freep(&mov->streams[i]->sample_sizes); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1646 av_freep(&mov->streams[i]->keyframes); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1647 av_freep(&mov->streams[i]->stts_data); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1648 } |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1649 av_freep(&mov->mdat_list); |
0 | 1650 return 0; |
1651 } | |
1652 | |
1653 static int mov_read_packet(AVFormatContext *s, AVPacket *pkt) | |
1654 { | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1655 MOVContext *mov = s->priv_data; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1656 MOVStreamContext *sc = 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1657 AVIndexEntry *sample = 0; |
769 | 1658 int64_t best_dts = INT64_MAX; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1659 int i; |
0 | 1660 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1661 for (i = 0; i < mov->total_streams; i++) { |
887 | 1662 MOVStreamContext *msc = mov->streams[i]; |
769 | 1663 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1664 if (s->streams[i]->discard != AVDISCARD_ALL && msc->current_sample < msc->sample_count) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1665 AVIndexEntry *current_sample = &s->streams[i]->index_entries[msc->current_sample]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1666 int64_t dts = av_rescale(current_sample->timestamp * (int64_t)msc->time_rate, AV_TIME_BASE, msc->time_scale); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1667 |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1440
diff
changeset
|
1668 dprintf("stream %d, sample %ld, dts %"PRId64"\n", i, msc->current_sample, dts); |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1669 if (dts < best_dts) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1670 sample = current_sample; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1671 best_dts = dts; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1672 sc = msc; |
769 | 1673 } |
0 | 1674 } |
1675 } | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1676 if (!sample) |
887 | 1677 return -1; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1678 /* must be done just before reading, to avoid infinite loop on sample */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1679 sc->current_sample++; |
1162 | 1680 if (sample->pos >= url_fsize(&s->pb)) { |
1388
3172bf94c066
Use proper PRI?64 macros for %ll? format to fix printf format warnings:
rathann
parents:
1384
diff
changeset
|
1681 av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n", sc->ffindex, sample->pos); |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1682 return -1; |
0 | 1683 } |
1270 | 1684 #ifdef CONFIG_DV_DEMUXER |
1268 | 1685 if (sc->dv_audio_container) { |
1686 dv_get_packet(mov->dv_demux, pkt); | |
1687 dprintf("dv audio pkt size %d\n", pkt->size); | |
1688 } else { | |
1270 | 1689 #endif |
1268 | 1690 url_fseek(&s->pb, sample->pos, SEEK_SET); |
1691 av_get_packet(&s->pb, pkt, sample->size); | |
1270 | 1692 #ifdef CONFIG_DV_DEMUXER |
1268 | 1693 if (mov->dv_demux) { |
1694 void *pkt_destruct_func = pkt->destruct; | |
1695 dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size); | |
1696 pkt->destruct = pkt_destruct_func; | |
1697 } | |
1698 } | |
1270 | 1699 #endif |
0 | 1700 pkt->stream_index = sc->ffindex; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1701 pkt->dts = sample->timestamp; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1702 if (sc->ctts_data) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1703 assert(sc->ctts_data[sc->sample_to_ctime_index].duration % sc->time_rate == 0); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1704 pkt->pts = pkt->dts + sc->ctts_data[sc->sample_to_ctime_index].duration / sc->time_rate; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1705 /* update ctts context */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1706 sc->sample_to_ctime_sample++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1707 if (sc->sample_to_ctime_index < sc->ctts_count && sc->ctts_data[sc->sample_to_ctime_index].count == sc->sample_to_ctime_sample) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1708 sc->sample_to_ctime_index++; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1709 sc->sample_to_ctime_sample = 0; |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1710 } |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1711 } else { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1712 pkt->pts = pkt->dts; |
383
1674ed5ca2f0
Parse stss info in MOV files to get key frames patch by ("Brian Becker" <Brian dot Becker at palmone dot com>)
michael
parents:
370
diff
changeset
|
1713 } |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1714 pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? PKT_FLAG_KEY : 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1715 pkt->pos = sample->pos; |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1440
diff
changeset
|
1716 dprintf("stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n", pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration); |
0 | 1717 return 0; |
1718 } | |
1719 | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1720 static int mov_seek_stream(AVStream *st, int64_t timestamp, int flags) |
491 | 1721 { |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1722 MOVStreamContext *sc = st->priv_data; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1723 int sample, time_sample; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1724 int i; |
491 | 1725 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1726 sample = av_index_search_timestamp(st, timestamp, flags); |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1440
diff
changeset
|
1727 dprintf("stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample); |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1728 if (sample < 0) /* not sure what to do */ |
491 | 1729 return -1; |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1730 sc->current_sample = sample; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1731 dprintf("stream %d, found sample %ld\n", st->index, sc->current_sample); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1732 /* adjust ctts index */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1733 if (sc->ctts_data) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1734 time_sample = 0; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1735 for (i = 0; i < sc->ctts_count; i++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1736 time_sample += sc->ctts_data[i].count; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1737 if (time_sample >= sc->current_sample) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1738 sc->sample_to_ctime_index = i; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1739 sc->sample_to_ctime_sample = time_sample - sc->current_sample; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1740 break; |
491 | 1741 } |
1742 } | |
1743 } | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1744 return sample; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1745 } |
491 | 1746 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1747 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1748 { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1749 AVStream *st; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1750 int64_t seek_timestamp, timestamp; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1751 int sample; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1752 int i; |
491 | 1753 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1754 if (stream_index >= s->nb_streams) |
491 | 1755 return -1; |
1756 | |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1757 st = s->streams[stream_index]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1758 sample = mov_seek_stream(st, sample_time, flags); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1759 if (sample < 0) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1760 return -1; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1761 |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1762 /* adjust seek timestamp to found sample timestamp */ |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1763 seek_timestamp = st->index_entries[sample].timestamp; |
952
5fdcae83a82f
mov debug clean patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
949
diff
changeset
|
1764 |
1161
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1765 for (i = 0; i < s->nb_streams; i++) { |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1766 st = s->streams[i]; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1767 if (stream_index == i || st->discard == AVDISCARD_ALL) |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1768 continue; |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1769 |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1770 timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base); |
b340deaf925b
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
bcoudurier
parents:
1157
diff
changeset
|
1771 mov_seek_stream(st, timestamp, flags); |
885 | 1772 } |
491 | 1773 return 0; |
1774 } | |
1775 | |
0 | 1776 static int mov_read_close(AVFormatContext *s) |
1777 { | |
1778 int i; | |
121 | 1779 MOVContext *mov = (MOVContext *) s->priv_data; |
0 | 1780 for(i=0; i<mov->total_streams; i++) |
1781 mov_free_stream_context(mov->streams[i]); | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1782 /* free color tabs */ |
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1783 for(i=0; i<mov->ctab_size; i++) |
887 | 1784 av_freep(&mov->ctab[i]); |
1268 | 1785 if(mov->dv_demux){ |
1786 for(i=0; i<mov->dv_fctx->nb_streams; i++){ | |
1787 av_freep(&mov->dv_fctx->streams[i]->codec); | |
1788 av_freep(&mov->dv_fctx->streams[i]); | |
1789 } | |
1790 av_freep(&mov->dv_fctx); | |
1791 av_freep(&mov->dv_demux); | |
1792 } | |
130
f607ed6aa365
* support for AAC audio (esds decoding - using extradata)
kabi
parents:
129
diff
changeset
|
1793 av_freep(&mov->ctab); |
0 | 1794 return 0; |
1795 } | |
1796 | |
1169 | 1797 AVInputFormat mov_demuxer = { |
997
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
1798 "mov,mp4,m4a,3gp,3g2,mj2", |
fb3380061c31
add support for Motion JPEG 2000 file format patch by (Baptiste COUDURIER <baptiste.coudurier smartjog com)
michael
parents:
994
diff
changeset
|
1799 "QuickTime/MPEG4/Motion JPEG 2000 format", |
0 | 1800 sizeof(MOVContext), |
1801 mov_probe, | |
1802 mov_read_header, | |
1803 mov_read_packet, | |
1804 mov_read_close, | |
491 | 1805 mov_read_seek, |
0 | 1806 }; |