Mercurial > mplayer.hg
annotate libmpdemux/demux_mov.c @ 13738:39004f891def
seeking based on the largest timestamp in an mpeg stream
It is often more accurate than the current seeking and it has the
additional benefit of giving the (almost) precise total time of the movie.
patch by Michael Behrisch < behrisch at informatik.hu-berlin.de >
author | aurel |
---|---|
date | Sat, 23 Oct 2004 00:05:38 +0000 |
parents | 5d4910f6aa79 |
children | 7dfda76015c8 |
rev | line source |
---|---|
2148 | 1 // QuickTime MOV file parser by A'rpi |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
2 // additional work by Atmos |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
3 // based on TOOLS/movinfo.c by A'rpi & Al3x |
2148 | 4 // compressed header support from moov.c of the openquicktime lib. |
2386 | 5 // References: http://openquicktime.sf.net/, http://www.heroinewarrior.com/ |
2542 | 6 // http://www.geocities.com/SiliconValley/Lakes/2160/fformats/files/mov.pdf |
5242
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
7 // (above url no longer works, file mirrored somewhere? ::atmos) |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
8 // The QuickTime File Format PDF from Apple: |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
9 // http://developer.apple.com/techpubs/quicktime/qtdevdocs/PDF/QTFileFormat.pdf |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
10 // (Complete list of documentation at http://developer.apple.com/quicktime/) |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
11 // MP4-Lib sources from http://mpeg4ip.sf.net/ might be usefull fot .mp4 |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
12 // aswell as .mov specific stuff. |
5254
142ea546abb5
Add a usefull url, btw. audio esds needs some fixing with some files, I'll investigate.
atmos4
parents:
5252
diff
changeset
|
13 // All sort of Stuff about MPEG4: |
142ea546abb5
Add a usefull url, btw. audio esds needs some fixing with some files, I'll investigate.
atmos4
parents:
5252
diff
changeset
|
14 // http://www.cmlab.csie.ntu.edu.tw/~pkhsiao/thesis.html |
5257 | 15 // I really recommend N4270-1.doc and N4270-2.doc which are exact specs |
16 // of the MP4-File Format and the MPEG4 Specific extensions. ::atmos | |
1490 | 17 |
18 #include <stdio.h> | |
19 #include <stdlib.h> | |
20 #include <unistd.h> | |
21 | |
1567 | 22 #include "config.h" |
23 #include "mp_msg.h" | |
1973
5216f108cb4f
all error/warn/info messages moved to help_mp-en.h for translation
arpi
parents:
1567
diff
changeset
|
24 #include "help_mp.h" |
1490 | 25 |
26 #include "stream.h" | |
27 #include "demuxer.h" | |
28 #include "stheader.h" | |
29 | |
2386 | 30 #include "bswap.h" |
31 | |
4332 | 32 #include "qtpalette.h" |
6612 | 33 #include "parse_mp4.h" // .MP4 specific stuff |
4332 | 34 |
9502
241bba8f60e8
MACOSX support patch, based on Dan Christiansens work
alex
parents:
9125
diff
changeset
|
35 #ifdef MACOSX |
241bba8f60e8
MACOSX support patch, based on Dan Christiansens work
alex
parents:
9125
diff
changeset
|
36 #include <QuickTime/QuickTime.h> |
11399
82bf5475b991
Fix for compilation on Mac OS X by Steven M. Schultz <sms@2BSD.COM>.
mosu
parents:
11370
diff
changeset
|
37 #else |
82bf5475b991
Fix for compilation on Mac OS X by Steven M. Schultz <sms@2BSD.COM>.
mosu
parents:
11370
diff
changeset
|
38 #include "../loader/qtx/qtxsdk/components.h" |
9502
241bba8f60e8
MACOSX support patch, based on Dan Christiansens work
alex
parents:
9125
diff
changeset
|
39 #endif |
241bba8f60e8
MACOSX support patch, based on Dan Christiansens work
alex
parents:
9125
diff
changeset
|
40 |
2148 | 41 #ifdef HAVE_ZLIB |
42 #include <zlib.h> | |
43 #endif | |
44 | |
9951
82f6240091a8
Avoid including a header file twice to prevent Cygwin gcc 2.95.3-10 from
diego
parents:
9590
diff
changeset
|
45 #ifndef _FCNTL_H |
2786 | 46 #include <fcntl.h> |
6334
5becd843ff47
cygwin & darwin fixes by Joey Parrish <joey@yunamusic.com>
arpi
parents:
6139
diff
changeset
|
47 #endif |
2786 | 48 |
7654
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
49 #define BE_16(x) (((unsigned char *)(x))[0] << 8 | \ |
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
50 ((unsigned char *)(x))[1]) |
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
51 #define BE_32(x) (((unsigned char *)(x))[0] << 24 | \ |
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
52 ((unsigned char *)(x))[1] << 16 | \ |
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
53 ((unsigned char *)(x))[2] << 8 | \ |
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
54 ((unsigned char *)(x))[3]) |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
55 |
7654
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
56 #define char2short(x,y) BE_16(&(x)[(y)]) |
a2e735271814
BE_16/BE_32 macro was accessing integers from unaligned addresses on SPARC
jkeil
parents:
7514
diff
changeset
|
57 #define char2int(x,y) BE_32(&(x)[(y)]) |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
58 |
1490 | 59 typedef struct { |
2100 | 60 unsigned int pts; // duration |
61 unsigned int size; | |
62 off_t pos; | |
63 } mov_sample_t; | |
64 | |
65 typedef struct { | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
66 unsigned int sample; // number of the first sample in the chunk |
2115 | 67 unsigned int size; // number of samples in the chunk |
68 int desc; // for multiple codecs mode - not used | |
2100 | 69 off_t pos; |
70 } mov_chunk_t; | |
71 | |
72 typedef struct { | |
73 unsigned int first; | |
74 unsigned int spc; | |
75 unsigned int sdid; | |
76 } mov_chunkmap_t; | |
77 | |
78 typedef struct { | |
2115 | 79 unsigned int num; |
80 unsigned int dur; | |
81 } mov_durmap_t; | |
82 | |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
83 typedef struct { |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
84 unsigned int dur; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
85 unsigned int pos; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
86 int speed; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
87 // |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
88 int frames; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
89 int start_sample; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
90 int start_frame; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
91 int pts_offset; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
92 } mov_editlist_t; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
93 |
4624 | 94 #define MOV_TRAK_UNKNOWN 0 |
95 #define MOV_TRAK_VIDEO 1 | |
96 #define MOV_TRAK_AUDIO 2 | |
97 #define MOV_TRAK_FLASH 3 | |
98 #define MOV_TRAK_GENERIC 4 | |
99 #define MOV_TRAK_CODE 5 | |
100 | |
2115 | 101 typedef struct { |
1490 | 102 int id; |
103 int type; | |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
104 off_t pos; |
2101 | 105 // |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
106 unsigned int media_handler; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
107 unsigned int data_handler; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
108 // |
1490 | 109 int timescale; |
2100 | 110 unsigned int length; |
2115 | 111 int samplesize; // 0 = variable |
112 int duration; // 0 = variable | |
1490 | 113 int width,height; // for video |
114 unsigned int fourcc; | |
2115 | 115 // |
2101 | 116 int tkdata_len; // track data |
117 unsigned char* tkdata; | |
118 int stdata_len; // stream data | |
119 unsigned char* stdata; | |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
120 // |
5252 | 121 unsigned char* stream_header; |
122 int stream_header_len; // if >0, this header should be sent before the 1st frame | |
123 // | |
2100 | 124 int samples_size; |
125 mov_sample_t* samples; | |
126 int chunks_size; | |
127 mov_chunk_t* chunks; | |
128 int chunkmap_size; | |
129 mov_chunkmap_t* chunkmap; | |
2115 | 130 int durmap_size; |
131 mov_durmap_t* durmap; | |
2544 | 132 int keyframes_size; |
133 unsigned int* keyframes; | |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
134 int editlist_size; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
135 mov_editlist_t* editlist; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
136 int editlist_pos; |
5372
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
137 // |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
138 void* desc; // image/sound/etc description (pointer to ImageDescription etc) |
1490 | 139 } mov_track_t; |
140 | |
7441
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
141 void mov_build_index(mov_track_t* trak,int timescale){ |
2100 | 142 int i,j,s; |
143 int last=trak->chunks_size; | |
2115 | 144 unsigned int pts=0; |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
145 |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
146 #if 0 |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
147 if (trak->chunks_size <= 0) |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
148 { |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
149 mp_msg(MSGT_DEMUX, MSGL_WARN, "No chunk offset table, trying to build one!\n"); |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
150 |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
151 trak->chunks_size = trak->samples_size; /* XXX: FIXME ! */ |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
152 trak->chunks = realloc(trak->chunks, sizeof(mov_chunk_t)*trak->chunks_size); |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
153 |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
154 for (i=0; i < trak->chunks_size; i++) |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
155 trak->chunks[i].pos = -1; |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
156 } |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
157 #endif |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
158 |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
159 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV track #%d: %d chunks, %d samples\n",trak->id,trak->chunks_size,trak->samples_size); |
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
160 mp_msg(MSGT_DEMUX, MSGL_V, "pts=%d scale=%d time=%5.3f\n",trak->length,trak->timescale,(float)trak->length/(float)trak->timescale); |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
161 |
2100 | 162 // process chunkmap: |
163 i=trak->chunkmap_size; | |
164 while(i>0){ | |
165 --i; | |
166 for(j=trak->chunkmap[i].first;j<last;j++){ | |
167 trak->chunks[j].desc=trak->chunkmap[i].sdid; | |
168 trak->chunks[j].size=trak->chunkmap[i].spc; | |
169 } | |
170 last=trak->chunkmap[i].first; | |
171 } | |
2115 | 172 |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
173 #if 0 |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
174 for (i=0; i < trak->chunks_size; i++) |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
175 { |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
176 /* fixup position */ |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
177 if (trak->chunks[i].pos == -1) |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
178 if (i > 0) |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
179 trak->chunks[i].pos = trak->chunks[i-1].pos + trak->chunks[i-1].size; |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
180 else |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
181 trak->chunks[i].pos = 0; /* FIXME: set initial pos */ |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
182 #endif |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
183 |
2115 | 184 // calc pts of chunks: |
185 s=0; | |
186 for(j=0;j<trak->chunks_size;j++){ | |
187 trak->chunks[j].sample=s; | |
188 s+=trak->chunks[j].size; | |
189 } | |
190 | |
4624 | 191 // workaround for fixed-size video frames (dv and uncompressed) |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
192 if(!trak->samples_size && trak->type!=MOV_TRAK_AUDIO){ |
4624 | 193 trak->samples_size=s; |
194 trak->samples=malloc(sizeof(mov_sample_t)*s); | |
195 for(i=0;i<s;i++) | |
196 trak->samples[i].size=trak->samplesize; | |
197 trak->samplesize=0; | |
198 } | |
199 | |
2115 | 200 if(!trak->samples_size){ |
201 // constant sampesize | |
202 if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){ | |
2227 | 203 trak->duration=trak->durmap[0].dur; |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
204 } else mp_msg(MSGT_DEMUX, MSGL_ERR, "*** constant samplesize & variable duration not yet supported! ***\nContact the author if you have such sample file!\n"); |
2115 | 205 return; |
206 } | |
207 | |
208 // calc pts: | |
209 s=0; | |
210 for(j=0;j<trak->durmap_size;j++){ | |
211 for(i=0;i<trak->durmap[j].num;i++){ | |
212 trak->samples[s].pts=pts; | |
213 ++s; | |
214 pts+=trak->durmap[j].dur; | |
215 } | |
216 } | |
2100 | 217 |
218 // calc sample offsets | |
219 s=0; | |
220 for(j=0;j<trak->chunks_size;j++){ | |
221 off_t pos=trak->chunks[j].pos; | |
222 for(i=0;i<trak->chunks[j].size;i++){ | |
223 trak->samples[s].pos=pos; | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
224 mp_msg(MSGT_DEMUX, MSGL_DBG3, "Sample %5d: pts=%8d off=0x%08X size=%d\n",s, |
2100 | 225 trak->samples[s].pts, |
226 (int)trak->samples[s].pos, | |
227 trak->samples[s].size); | |
228 pos+=trak->samples[s].size; | |
229 ++s; | |
230 } | |
231 } | |
232 | |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
233 // precalc editlist entries |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
234 if(trak->editlist_size>0){ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
235 int frame=0; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
236 int e_pts=0; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
237 for(i=0;i<trak->editlist_size;i++){ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
238 mov_editlist_t* el=&trak->editlist[i]; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
239 int sample=0; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
240 int pts=el->pos; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
241 el->start_frame=frame; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
242 if(pts<0){ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
243 // skip! |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
244 el->frames=0; continue; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
245 } |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
246 // find start sample |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
247 for(;sample<trak->samples_size;sample++){ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
248 if(pts<=trak->samples[sample].pts) break; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
249 } |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
250 el->start_sample=sample; |
7441
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
251 el->pts_offset=((long long)e_pts*(long long)trak->timescale)/(long long)timescale-trak->samples[sample].pts; |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
252 pts+=((long long)el->dur*(long long)trak->timescale)/(long long)timescale; |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
253 e_pts+=el->dur; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
254 // find end sample |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
255 for(;sample<trak->samples_size;sample++){ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
256 if(pts<=trak->samples[sample].pts) break; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
257 } |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
258 el->frames=sample-el->start_sample; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
259 frame+=el->frames; |
7514 | 260 mp_msg(MSGT_DEMUX,MSGL_V,"EL#%d: pts=%d 1st_sample=%d frames=%d (%5.3fs) pts_offs=%d\n",i, |
261 el->pos,el->start_sample, el->frames, | |
262 (float)(el->dur)/(float)timescale, el->pts_offset); | |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
263 } |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
264 } |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
265 |
2100 | 266 } |
267 | |
1490 | 268 #define MOV_MAX_TRACKS 256 |
269 | |
270 typedef struct { | |
271 off_t moov_start; | |
272 off_t moov_end; | |
273 off_t mdat_start; | |
274 off_t mdat_end; | |
275 int track_db; | |
276 mov_track_t* tracks[MOV_MAX_TRACKS]; | |
7441
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
277 int timescale; // movie timescale |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
278 int duration; // movie duration (in movie timescale units) |
1490 | 279 } mov_priv_t; |
280 | |
281 #define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d)) | |
282 | |
283 int mov_check_file(demuxer_t* demuxer){ | |
284 int flags=0; | |
2879 | 285 int no=0; |
1490 | 286 mov_priv_t* priv=malloc(sizeof(mov_priv_t)); |
287 | |
1567 | 288 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for MOV\n"); |
1490 | 289 |
290 memset(priv,0,sizeof(mov_priv_t)); | |
291 | |
292 while(1){ | |
8315 | 293 int i; |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
294 int skipped=8; |
1490 | 295 off_t len=stream_read_dword(demuxer->stream); |
296 unsigned int id=stream_read_dword(demuxer->stream); | |
297 if(stream_eof(demuxer->stream)) break; // EOF | |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
298 if (len == 1) /* real size is 64bits - cjb */ |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
299 { |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
300 #ifndef _LARGEFILE_SOURCE |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
301 if (stream_read_dword(demuxer->stream) != 0) |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
302 mp_msg(MSGT_DEMUX, MSGL_WARN, "64bit file, but you've compiled MPlayer without LARGEFILE support!\n"); |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
303 len = stream_read_dword(demuxer->stream); |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
304 #else |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
305 len = stream_read_qword(demuxer->stream); |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
306 #endif |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
307 skipped += 8; |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
308 } |
5241
126d5fd76a70
temporary disabled len=0 code due to reported loop errors
alex
parents:
5236
diff
changeset
|
309 #if 0 |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
310 else if (len == 0) /* deleted chunk */ |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
311 { |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
312 /* XXX: CJB! is this right? - alex */ |
5243 | 313 goto skip_chunk; |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
314 } |
5241
126d5fd76a70
temporary disabled len=0 code due to reported loop errors
alex
parents:
5236
diff
changeset
|
315 #endif |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
316 else if(len<8) break; // invalid chunk |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
317 |
1490 | 318 switch(id){ |
5257 | 319 case MOV_FOURCC('f','t','y','p'): { |
320 unsigned int tmp; | |
321 // File Type Box (ftyp): | |
322 // char[4] major_brand (eg. 'isom') | |
323 // int minor_version (eg. 0x00000000) | |
324 // char[4] compatible_brands[] (eg. 'mp41') | |
325 // compatible_brands list spans to the end of box | |
326 #if 1 | |
327 tmp = stream_read_dword(demuxer->stream); | |
328 switch(tmp) { | |
329 case MOV_FOURCC('i','s','o','m'): | |
11810
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
330 mp_msg(MSGT_DEMUX,MSGL_V,"ISO: File Type Major Brand: ISO Base Media\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
331 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
332 case MOV_FOURCC('m','p','4','1'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
333 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: ISO/IEC 14496-1 (MPEG-4 system) v1\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
334 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
335 case MOV_FOURCC('m','p','4','2'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
336 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: ISO/IEC 14496-1 (MPEG-4 system) v2\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
337 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
338 case MOV_FOURCC('M','4','A',' '): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
339 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: Apple iTunes AAC-LC Audio\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
340 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
341 case MOV_FOURCC('M','4','P',' '): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
342 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: Apple iTunes AAC-LC Protected Audio\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
343 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
344 case MOV_FOURCC('q','t',' ',' '): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
345 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: Original QuickTime\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
346 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
347 case MOV_FOURCC('3','g','p','1'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
348 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: 3GPP Profile 1\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
349 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
350 case MOV_FOURCC('3','g','p','2'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
351 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: 3GPP Profile 2\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
352 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
353 case MOV_FOURCC('3','g','p','3'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
354 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: 3GPP Profile 3\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
355 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
356 case MOV_FOURCC('3','g','p','4'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
357 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: 3GPP Profile 4\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
358 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
359 case MOV_FOURCC('3','g','p','5'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
360 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: 3GPP Profile 5\n"); |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
361 break; |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
362 case MOV_FOURCC('m','m','p','4'): |
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
363 mp_msg(MSGT_DEMUX,MSGL_INFO,"ISO: File Type Major Brand: Mobile ISO/IEC 14496-1 (MPEG-4 system)\n"); |
5257 | 364 break; |
365 default: | |
366 tmp = be2me_32(tmp); | |
11810
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
367 mp_msg(MSGT_DEMUX,MSGL_WARN,"ISO: Unknown File Type Major Brand: %.4s\n",&tmp); |
5257 | 368 } |
11810
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
369 mp_msg(MSGT_DEMUX,MSGL_V,"ISO: File Type Minor Version: %d\n", |
5257 | 370 stream_read_dword(demuxer->stream)); |
371 skipped += 8; | |
372 // List all compatible brands | |
373 for(i = 0; i < ((len-16)/4); i++) { | |
374 tmp = be2me_32(stream_read_dword(demuxer->stream)); | |
11810
8cce53dd235f
Have the MOV demuxer recognize and display (via MPINFO) registered ISO
diego
parents:
11399
diff
changeset
|
375 mp_msg(MSGT_DEMUX,MSGL_V,"ISO: File Type Compatible Brand #%d: %.4s\n",i,&tmp); |
5257 | 376 skipped += 4; |
377 } | |
378 #endif | |
379 } break; | |
1490 | 380 case MOV_FOURCC('m','o','o','v'): |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
381 // case MOV_FOURCC('c','m','o','v'): |
1567 | 382 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie header found!\n"); |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
383 priv->moov_start=(off_t)stream_tell(demuxer->stream); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
384 priv->moov_end=(off_t)priv->moov_start+len-skipped; |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
385 mp_msg(MSGT_DEMUX,MSGL_DBG2,"MOV: Movie header: start: %x end: %x\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
386 priv->moov_start, priv->moov_end); |
8315 | 387 skipped+=8; |
388 i = stream_read_dword(demuxer->stream)-8; | |
389 if(stream_read_dword(demuxer->stream)==MOV_FOURCC('r','m','r','a')){ | |
390 int ref=0; | |
391 skipped+=i; | |
392 mp_msg(MSGT_DEMUX,MSGL_INFO,"MOV: Reference Media file!!!\n"); | |
8937 | 393 //set demuxer type to playlist ... |
394 demuxer->type=DEMUXER_TYPE_PLAYLIST; | |
8315 | 395 while(i>0){ |
396 int len=stream_read_dword(demuxer->stream)-8; | |
397 int fcc=stream_read_dword(demuxer->stream); | |
398 if(len<0) break; // EOF!? | |
399 i-=8; | |
400 // printf("i=%d len=%d\n",i,len); | |
401 switch(fcc){ | |
402 case MOV_FOURCC('r','m','d','a'): | |
403 continue; | |
404 case MOV_FOURCC('r','d','r','f'): { | |
405 int tmp=stream_read_dword(demuxer->stream); | |
406 int type=stream_read_dword_le(demuxer->stream); | |
407 int slen=stream_read_dword(demuxer->stream); | |
8937 | 408 //char* s=malloc(slen+1); |
409 //stream_read(demuxer->stream,s,slen); | |
410 | |
411 //FIXME: also store type & data_rate ? | |
412 ds_read_packet(demuxer->video, | |
413 demuxer->stream, | |
414 slen, | |
415 0, | |
416 stream_tell(demuxer->stream), | |
417 0 // no flags | |
418 ); | |
419 flags|=4; | |
420 mp_msg(MSGT_DEMUX,MSGL_V,"Added reference to playlist\n"); | |
421 //s[slen]=0; | |
422 //mp_msg(MSGT_DEMUX,MSGL_INFO,"REF: [%.4s] %s\n",&type,s); | |
8315 | 423 len-=12+slen;i-=12+slen; break; |
424 } | |
425 case MOV_FOURCC('r','m','d','r'): { | |
426 int flags=stream_read_dword(demuxer->stream); | |
427 int rate=stream_read_dword(demuxer->stream); | |
428 mp_msg(MSGT_DEMUX,MSGL_V," min. data rate: %d bits/sec\n",rate); | |
429 len-=8; i-=8; break; | |
430 } | |
431 case MOV_FOURCC('r','m','q','u'): { | |
432 int q=stream_read_dword(demuxer->stream); | |
433 mp_msg(MSGT_DEMUX,MSGL_V," quality index: %d\n",q); | |
434 len-=4; i-=4; break; | |
435 } | |
436 } | |
437 i-=len;stream_skip(demuxer->stream,len); | |
438 } | |
439 } | |
1490 | 440 flags|=1; |
441 break; | |
5680 | 442 case MOV_FOURCC('w','i','d','e'): |
443 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: 'WIDE' chunk found!\n"); | |
444 if(flags&2) break; | |
1490 | 445 case MOV_FOURCC('m','d','a','t'): |
1567 | 446 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie DATA found!\n"); |
1490 | 447 priv->mdat_start=stream_tell(demuxer->stream); |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
448 priv->mdat_end=priv->mdat_start+len-skipped; |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
449 mp_msg(MSGT_DEMUX,MSGL_DBG2,"MOV: Movie data: start: %x end: %x\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
450 priv->mdat_start, priv->mdat_end); |
1490 | 451 flags|=2; |
8928 | 452 if(flags==3){ |
453 // if we're over the headers, then we can stop parsing here! | |
454 demuxer->priv=priv; | |
455 return 1; | |
456 } | |
1490 | 457 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
458 case MOV_FOURCC('f','r','e','e'): |
2942 | 459 case MOV_FOURCC('s','k','i','p'): |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
460 case MOV_FOURCC('j','u','n','k'): |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
461 mp_msg(MSGT_DEMUX,MSGL_DBG2,"MOV: free space (len: %d)\n", len); |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
462 /* unused, if you edit a mov, you can use space provided by free atoms (redefining it) */ |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
463 break; |
6865 | 464 case MOV_FOURCC('p','n','o','t'): |
465 case MOV_FOURCC('P','I','C','T'): | |
466 /* dunno what, but we shoudl ignore it */ | |
467 break; | |
1490 | 468 default: |
7759 | 469 if(no==0){ free(priv); return 0;} // first chunk is bad! |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
470 id = be2me_32(id); |
1567 | 471 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
1490 | 472 } |
5243 | 473 skip_chunk: |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
474 if(!stream_skip(demuxer->stream,len-skipped)) break; |
2879 | 475 ++no; |
1490 | 476 } |
7759 | 477 |
478 if(flags==3){ | |
479 demuxer->priv=priv; | |
480 return 1; | |
481 } | |
482 free(priv); | |
483 | |
9125
61ec44e2f406
Attached PATCH fixes the case, when data-flag and reference flags are set and
arpi
parents:
9113
diff
changeset
|
484 if ((flags==5) || (flags==7)) // reference & header sent |
8937 | 485 return 1; |
486 | |
2148 | 487 if(flags==1) |
488 mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing data (mdat) chunk! Maybe broken file...\n"); | |
489 else if(flags==2) | |
490 mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing header (moov/cmov) chunk! Maybe broken file...\n"); | |
1490 | 491 |
7759 | 492 return 0; |
1490 | 493 } |
494 | |
495 static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){ | |
496 mov_priv_t* priv=demuxer->priv; | |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
497 // printf("lschunks (level=%d,endpos=%x)\n", level, endpos); |
1490 | 498 while(1){ |
499 off_t pos; | |
500 off_t len; | |
501 unsigned int id; | |
502 // | |
503 pos=stream_tell(demuxer->stream); | |
2148 | 504 // printf("stream_tell==%d\n",pos); |
1490 | 505 if(pos>=endpos) return; // END |
506 len=stream_read_dword(demuxer->stream); | |
2148 | 507 // printf("len==%d\n",len); |
1490 | 508 if(len<8) return; // error |
509 len-=8; | |
510 id=stream_read_dword(demuxer->stream); | |
511 // | |
1567 | 512 mp_msg(MSGT_DEMUX,MSGL_DBG2,"lschunks %.4s %d\n",&id,(int)len); |
1490 | 513 // |
514 if(trak){ | |
515 switch(id){ | |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
516 case MOV_FOURCC('m','d','a','t'): { |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
517 mp_msg(MSGT_DEMUX,MSGL_WARN,"Hmm, strange MOV, parsing mdat in lschunks?\n"); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
518 return; |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
519 } |
3071 | 520 case MOV_FOURCC('f','r','e','e'): |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
521 case MOV_FOURCC('u','d','t','a'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
522 /* here not supported :p */ |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
523 break; |
1490 | 524 case MOV_FOURCC('t','k','h','d'): { |
1567 | 525 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sTrack header!\n",level,""); |
2101 | 526 // read codec data |
527 trak->tkdata_len=len; | |
528 trak->tkdata=malloc(trak->tkdata_len); | |
529 stream_read(demuxer->stream,trak->tkdata,trak->tkdata_len); | |
7441
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
530 /* |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
531 0 1 Version |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
532 1 3 Flags |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
533 4 4 Creation time |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
534 8 4 Modification time |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
535 12 4 Track ID |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
536 16 4 Reserved |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
537 20 4 Duration |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
538 24 8 Reserved |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
539 32 2 Layer |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
540 34 2 Alternate group |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
541 36 2 Volume |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
542 38 2 Reserved |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
543 40 36 Matrix structure |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
544 76 4 Track width |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
545 80 4 Track height |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
546 */ |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
547 mp_msg(MSGT_DEMUX,MSGL_V,"tkhd len=%d ver=%d flags=0x%X id=%d dur=%d lay=%d vol=%d\n", |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
548 trak->tkdata_len, trak->tkdata[0], trak->tkdata[1], |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
549 char2int(trak->tkdata,12), // id |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
550 char2int(trak->tkdata,20), // duration |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
551 char2short(trak->tkdata,32), // layer |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
552 char2short(trak->tkdata,36)); // volume |
1490 | 553 break; |
554 } | |
555 case MOV_FOURCC('m','d','h','d'): { | |
2100 | 556 unsigned int tmp; |
1567 | 557 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia header!\n",level,""); |
2100 | 558 #if 0 |
559 tmp=stream_read_dword(demuxer->stream); | |
560 printf("dword1: 0x%08X (%d)\n",tmp,tmp); | |
561 tmp=stream_read_dword(demuxer->stream); | |
562 printf("dword2: 0x%08X (%d)\n",tmp,tmp); | |
563 tmp=stream_read_dword(demuxer->stream); | |
564 printf("dword3: 0x%08X (%d)\n",tmp,tmp); | |
565 tmp=stream_read_dword(demuxer->stream); | |
566 printf("dword4: 0x%08X (%d)\n",tmp,tmp); | |
567 tmp=stream_read_dword(demuxer->stream); | |
568 printf("dword5: 0x%08X (%d)\n",tmp,tmp); | |
569 tmp=stream_read_dword(demuxer->stream); | |
570 printf("dword6: 0x%08X (%d)\n",tmp,tmp); | |
571 #endif | |
572 stream_skip(demuxer->stream,12); | |
1490 | 573 // read timescale |
2100 | 574 trak->timescale=stream_read_dword(demuxer->stream); |
575 // read length | |
576 trak->length=stream_read_dword(demuxer->stream); | |
1490 | 577 break; |
578 } | |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
579 case MOV_FOURCC('h','d','l','r'): { |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
580 unsigned int tmp=stream_read_dword(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
581 unsigned int type=stream_read_dword_le(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
582 unsigned int subtype=stream_read_dword_le(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
583 unsigned int manufact=stream_read_dword_le(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
584 unsigned int comp_flags=stream_read_dword(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
585 unsigned int comp_mask=stream_read_dword(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
586 int len=stream_read_char(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
587 char* str=malloc(len+1); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
588 stream_read(demuxer->stream,str,len); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
589 str[len]=0; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
590 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sHandler header: %.4s/%.4s (%.4s) %s\n",level,"",&type,&subtype,&manufact,str); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
591 free(str); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
592 switch(bswap_32(type)){ |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
593 case MOV_FOURCC('m','h','l','r'): |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
594 trak->media_handler=bswap_32(subtype); break; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
595 case MOV_FOURCC('d','h','l','r'): |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
596 trak->data_handler=bswap_32(subtype); break; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
597 default: |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
598 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown handler class: 0x%X (%.4s)\n",bswap_32(type),&type); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
599 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
600 break; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
601 } |
1490 | 602 case MOV_FOURCC('v','m','h','d'): { |
1567 | 603 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sVideo header!\n",level,""); |
1490 | 604 trak->type=MOV_TRAK_VIDEO; |
605 // read video data | |
606 break; | |
607 } | |
608 case MOV_FOURCC('s','m','h','d'): { | |
1567 | 609 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSound header!\n",level,""); |
1490 | 610 trak->type=MOV_TRAK_AUDIO; |
611 // read audio data | |
612 break; | |
613 } | |
2786 | 614 case MOV_FOURCC('g','m','h','d'): { |
615 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sGeneric header!\n",level,""); | |
616 trak->type=MOV_TRAK_GENERIC; | |
617 break; | |
618 } | |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
619 case MOV_FOURCC('n','m','h','d'): { |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
620 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sGeneric header!\n",level,""); |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
621 trak->type=MOV_TRAK_GENERIC; |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
622 break; |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
623 } |
1490 | 624 case MOV_FOURCC('s','t','s','d'): { |
625 int i=stream_read_dword(demuxer->stream); // temp! | |
626 int count=stream_read_dword(demuxer->stream); | |
1567 | 627 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sDescription list! (cnt:%d)\n",level,"",count); |
1490 | 628 for(i=0;i<count;i++){ |
629 off_t pos=stream_tell(demuxer->stream); | |
630 off_t len=stream_read_dword(demuxer->stream); | |
631 unsigned int fourcc=stream_read_dword_le(demuxer->stream); | |
632 if(len<8) break; // error | |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
633 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s desc #%d: %.4s (%d bytes)\n",level,"",i,&fourcc,len-16); |
9575
5c18b20924e1
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>
rtognimp
parents:
9502
diff
changeset
|
634 if(fourcc!=trak->fourcc && i) |
5c18b20924e1
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>
rtognimp
parents:
9502
diff
changeset
|
635 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVvariableFourCC); |
5c18b20924e1
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>
rtognimp
parents:
9502
diff
changeset
|
636 // if(!i) |
5c18b20924e1
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>
rtognimp
parents:
9502
diff
changeset
|
637 { |
1490 | 638 trak->fourcc=fourcc; |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
639 // read type specific (audio/video/time/text etc) header |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
640 // NOTE: trak type is not yet known at this point :((( |
2101 | 641 trak->stdata_len=len-8; |
642 trak->stdata=malloc(trak->stdata_len); | |
643 stream_read(demuxer->stream,trak->stdata,trak->stdata_len); | |
1490 | 644 } |
645 if(!stream_seek(demuxer->stream,pos+len)) break; | |
646 } | |
647 break; | |
648 } | |
2100 | 649 case MOV_FOURCC('s','t','t','s'): { |
8258 | 650 int temp=stream_read_dword(demuxer->stream); |
2100 | 651 int len=stream_read_dword(demuxer->stream); |
652 int i; | |
653 unsigned int pts=0; | |
654 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample duration table! (%d blocks)\n",level,"",len); | |
2115 | 655 trak->durmap=malloc(sizeof(mov_durmap_t)*len); |
656 memset(trak->durmap,0,sizeof(mov_durmap_t)*len); | |
657 trak->durmap_size=len; | |
2100 | 658 for(i=0;i<len;i++){ |
2115 | 659 trak->durmap[i].num=stream_read_dword(demuxer->stream); |
660 trak->durmap[i].dur=stream_read_dword(demuxer->stream); | |
661 pts+=trak->durmap[i].num*trak->durmap[i].dur; | |
2100 | 662 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
663 if(trak->length!=pts) mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! pts=%d length=%d\n",pts,trak->length); |
2100 | 664 break; |
665 } | |
666 case MOV_FOURCC('s','t','s','c'): { | |
667 int temp=stream_read_dword(demuxer->stream); | |
668 int len=stream_read_dword(demuxer->stream); | |
2533 | 669 int ver = (temp << 24); |
670 int flags = (temp << 16)|(temp<<8)|temp; | |
2100 | 671 int i; |
2533 | 672 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample->Chunk mapping table! (%d blocks) (ver:%d,flags:%ld)\n", |
673 level,"",len,ver,flags); | |
2100 | 674 // read data: |
675 trak->chunkmap_size=len; | |
676 trak->chunkmap=malloc(sizeof(mov_chunkmap_t)*len); | |
677 for(i=0;i<len;i++){ | |
2103 | 678 trak->chunkmap[i].first=stream_read_dword(demuxer->stream)-1; |
2100 | 679 trak->chunkmap[i].spc=stream_read_dword(demuxer->stream); |
680 trak->chunkmap[i].sdid=stream_read_dword(demuxer->stream); | |
681 } | |
682 break; | |
683 } | |
684 case MOV_FOURCC('s','t','s','z'): { | |
685 int temp=stream_read_dword(demuxer->stream); | |
686 int ss=stream_read_dword(demuxer->stream); | |
2533 | 687 int ver = (temp << 24); |
688 int flags = (temp << 16)|(temp<<8)|temp; | |
689 int entries=stream_read_dword(demuxer->stream); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
690 int i; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
691 |
2533 | 692 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample size table! (entries=%d ss=%d) (ver:%d,flags:%ld)\n", |
693 level,"",entries,ss,ver,flags); | |
2786 | 694 trak->samplesize=ss; |
695 if (!ss) { | |
696 // variable samplesize | |
697 trak->samples=realloc(trak->samples,sizeof(mov_sample_t)*entries); | |
698 trak->samples_size=entries; | |
699 for(i=0;i<entries;i++) | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
700 trak->samples[i].size=stream_read_dword(demuxer->stream); |
2786 | 701 } |
2100 | 702 break; |
703 } | |
704 case MOV_FOURCC('s','t','c','o'): { | |
8258 | 705 int temp=stream_read_dword(demuxer->stream); |
2100 | 706 int len=stream_read_dword(demuxer->stream); |
707 int i; | |
708 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sChunk offset table! (%d chunks)\n",level,"",len); | |
709 // extend array if needed: | |
710 if(len>trak->chunks_size){ | |
711 trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len); | |
712 trak->chunks_size=len; | |
713 } | |
714 // read elements: | |
715 for(i=0;i<len;i++) trak->chunks[i].pos=stream_read_dword(demuxer->stream); | |
716 break; | |
717 } | |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
718 case MOV_FOURCC('c','o','6','4'): { |
8258 | 719 int temp=stream_read_dword(demuxer->stream); |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
720 int len=stream_read_dword(demuxer->stream); |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
721 int i; |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
722 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s64bit chunk offset table! (%d chunks)\n",level,"",len); |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
723 // extend array if needed: |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
724 if(len>trak->chunks_size){ |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
725 trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len); |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
726 trak->chunks_size=len; |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
727 } |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
728 // read elements: |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
729 for(i=0;i<len;i++) |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
730 { |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
731 #ifndef _LARGEFILE_SOURCE |
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
732 if (stream_read_dword(demuxer->stream) != 0) |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
733 mp_msg(MSGT_DEMUX, MSGL_WARN, "Chunk %d has got 64bit address, but you've MPlayer compiled without LARGEFILE support!\n", i); |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
734 trak->chunks[i].pos = stream_read_dword(demuxer->stream); |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
735 #else |
3999
3c6b061ec033
mov_check_file 64bit support by Chris Bednar. also fixed co64 chunk and added warnings for 64bit files reading without largefiles support
alex
parents:
3652
diff
changeset
|
736 trak->chunks[i].pos = stream_read_qword(demuxer->stream); |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
737 #endif |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
738 } |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
739 break; |
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
740 } |
2533 | 741 case MOV_FOURCC('s','t','s','s'): { |
742 int temp=stream_read_dword(demuxer->stream); | |
743 int entries=stream_read_dword(demuxer->stream); | |
744 int ver = (temp << 24); | |
745 int flags = (temp << 16)|(temp<<8)|temp; | |
746 int i; | |
2542 | 747 mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sSyncing samples (keyframes) table! (%d entries) (ver:%d,flags:%ld)\n", |
2533 | 748 level, "",entries, ver, flags); |
2544 | 749 trak->keyframes_size=entries; |
750 trak->keyframes=malloc(sizeof(unsigned int)*entries); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
751 for (i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
752 trak->keyframes[i]=stream_read_dword(demuxer->stream)-1; |
2544 | 753 // for (i=0;i<entries;i++) printf("%3d: %d\n",i,trak->keyframes[i]); |
2533 | 754 break; |
755 } | |
1490 | 756 case MOV_FOURCC('m','d','i','a'): { |
1567 | 757 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia stream!\n",level,""); |
1490 | 758 lschunks(demuxer,level+1,pos+len,trak); |
759 break; | |
760 } | |
761 case MOV_FOURCC('m','i','n','f'): { | |
1567 | 762 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia info!\n",level,""); |
1490 | 763 lschunks(demuxer,level+1,pos+len,trak); |
764 break; | |
765 } | |
766 case MOV_FOURCC('s','t','b','l'): { | |
1567 | 767 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample info!\n",level,""); |
1490 | 768 lschunks(demuxer,level+1,pos+len,trak); |
769 break; | |
770 } | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
771 case MOV_FOURCC('e','d','t','s'): { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
772 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: %*sEdit atom!\n", level, ""); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
773 lschunks(demuxer,level+1,pos+len,trak); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
774 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
775 } |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
776 case MOV_FOURCC('e','l','s','t'): { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
777 int temp=stream_read_dword(demuxer->stream); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
778 int entries=stream_read_dword(demuxer->stream); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
779 int ver = (temp << 24); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
780 int flags = (temp << 16)|(temp<<8)|temp; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
781 int i; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
782 |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
783 mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sEdit list table (%d entries) (ver:%d,flags:%ld)\n", |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
784 level, "",entries, ver, flags); |
6611 | 785 #if 1 |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
786 trak->editlist_size=entries; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
787 trak->editlist=malloc(trak->editlist_size*sizeof(mov_editlist_t)); |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
788 for (i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
789 { |
6611 | 790 int dur=stream_read_dword(demuxer->stream); |
791 int mt=stream_read_dword(demuxer->stream); | |
792 int mr=stream_read_dword(demuxer->stream); // 16.16fp | |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
793 trak->editlist[i].dur=dur; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
794 trak->editlist[i].pos=mt; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
795 trak->editlist[i].speed=mr; |
6611 | 796 mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*s entry#%d: duration: %d start time: %d speed: %3.1fx\n",level,"", |
797 i, | |
798 dur,mt,(float)mr/65536.0f); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
799 } |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
800 #endif |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
801 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
802 } |
2786 | 803 case MOV_FOURCC('c','o','d','e'): |
804 { | |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
805 /* XXX: Implement atom 'code' for FLASH support */ |
2786 | 806 } |
2532 | 807 default: |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
808 id = be2me_32(id); |
2532 | 809 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
810 break; | |
1490 | 811 }//switch(id) |
2532 | 812 } else { /* not in track */ |
813 switch(id) { | |
7441
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
814 case MOV_FOURCC('m','v','h','d'): { |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
815 stream_skip(demuxer->stream,12); |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
816 priv->timescale=stream_read_dword(demuxer->stream); |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
817 priv->duration=stream_read_dword(demuxer->stream); |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
818 mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sMovie header (%d bytes): tscale=%d dur=%d\n",level,"",(int)len, |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
819 (int)priv->timescale,(int)priv->duration); |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
820 break; |
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
821 } |
2532 | 822 case MOV_FOURCC('t','r','a','k'): { |
1490 | 823 // if(trak) printf("MOV: Warning! trak in trak?\n"); |
824 if(priv->track_db>=MOV_MAX_TRACKS){ | |
1973
5216f108cb4f
all error/warn/info messages moved to help_mp-en.h for translation
arpi
parents:
1567
diff
changeset
|
825 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVtooManyTrk); |
1490 | 826 return; |
827 } | |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
828 if(!priv->track_db) mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n"); |
1490 | 829 trak=malloc(sizeof(mov_track_t)); |
830 memset(trak,0,sizeof(mov_track_t)); | |
1567 | 831 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Track #%d:\n",priv->track_db); |
1490 | 832 trak->id=priv->track_db; |
2100 | 833 priv->tracks[priv->track_db]=trak; |
1490 | 834 lschunks(demuxer,level+1,pos+len,trak); |
7441
13716c8114a8
fixing edit-list playback (it uses the mvhd-timescale instead of the mdhd-one)
arpi
parents:
6928
diff
changeset
|
835 mov_build_index(trak,priv->timescale); |
2100 | 836 switch(trak->type){ |
837 case MOV_TRAK_AUDIO: { | |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
838 #if 0 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
839 struct { |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
840 int16_t version; // 0 or 1 (version 1 is qt3.0+) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
841 int16_t revision; // 0 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
842 int32_t vendor_id; // 0 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
843 int16_t channels; // 1 or 2 (Mono/Stereo) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
844 int16_t samplesize; // 8 or 16 (8Bit/16Bit) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
845 int16_t compression_id; // if version 0 then 0 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
846 // if version 1 and vbr then -2 else 0 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
847 int16_t packet_size; // 0 |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
848 uint16_t sample_rate; // samplerate (Hz) |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
849 // qt3.0+ (version == 1) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
850 uint32_t samples_per_packet; // 0 or num uncompressed samples in a packet |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
851 // if 0 below three values are also 0 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
852 uint32_t bytes_per_packet; // 0 or num compressed bytes for one channel |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
853 uint32_t bytes_per_frame; // 0 or num compressed bytes for all channels |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
854 // (channels * bytes_per_packet) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
855 uint32_t bytes_per_sample; // 0 or size of uncompressed sample |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
856 // if samples_per_packet and bytes_per_packet are constant (CBR) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
857 // then bytes_per_frame and bytes_per_sample must be 0 (else is VBR) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
858 // --- |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
859 // optional additional atom-based fields |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
860 // ([int32_t size,int32_t type,some data ],repeat) |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
861 } my_stdata; |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
862 #endif |
2100 | 863 sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db); |
864 sh->format=trak->fourcc; | |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
865 |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
866 // assumptions for below table: short is 16bit, int is 32bit, intfp is 16bit |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
867 // XXX: 32bit fixed point numbers (intfp) are only 2 Byte! |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
868 // short values are usually one byte leftpadded by zero |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
869 // int values are usually two byte leftpadded by zero |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
870 // stdata[]: |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
871 // 8 short version |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
872 // 10 short revision |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
873 // 12 int vendor_id |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
874 // 16 short channels |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
875 // 18 short samplesize |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
876 // 20 short compression_id |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
877 // 22 short packet_size (==0) |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
878 // 24 intfp sample_rate |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
879 // (26 short) unknown (==0) |
6612 | 880 // ---- qt3.0+ (version>=1) |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
881 // 28 int samples_per_packet |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
882 // 32 int bytes_per_packet |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
883 // 36 int bytes_per_frame |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
884 // 40 int bytes_per_sample |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
885 // there may be additional atoms following at 28 (version 0) |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
886 // or 44 (version 1), eg. esds atom of .MP4 files |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
887 // esds atom: |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
888 // 28 int atom size (bytes of int size, int type and data) |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
889 // 32 char[4] atom type (fourc charater code -> esds) |
5307
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
890 // 36 char[] atom data (len=size-8) |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
891 |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
892 sh->samplesize=char2short(trak->stdata,18)/8; |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
893 sh->channels=char2short(trak->stdata,16); |
5212
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
894 /*printf("MOV: timescale: %d samplerate: %d durmap: %d (%d) -> %d (%d)\n", |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
895 trak->timescale, char2short(trak->stdata,24), trak->durmap[0].dur, |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
896 trak->durmap[0].num, trak->timescale/trak->durmap[0].dur, |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
897 char2short(trak->stdata,24)/trak->durmap[0].dur);*/ |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
898 sh->samplerate=char2short(trak->stdata,24); |
5301 | 899 if((sh->samplerate < 7000) && trak->durmap) { |
5212
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
900 switch(char2short(trak->stdata,24)/trak->durmap[0].dur) { |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
901 // TODO: add more cases. |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
902 case 31: |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
903 sh->samplerate = 32000; break; |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
904 case 43: |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
905 sh->samplerate = 44100; break; |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
906 case 47: |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
907 sh->samplerate = 48000; break; |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
908 default: |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
909 mp_msg(MSGT_DEMUX, MSGL_WARN, |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
910 "MOV: unable to determine audio samplerate, " |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
911 "assuming 44.1kHz (got %d)\n", |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
912 char2short(trak->stdata,24)/trak->durmap[0].dur); |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
913 sh->samplerate = 44100; |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
914 } |
12f7cbbe7022
add alternative samplerate calculation for files with timescale\!=samplerate
atmos4
parents:
5206
diff
changeset
|
915 } |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
916 |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
917 mp_msg(MSGT_DEMUX, MSGL_INFO, "Audio bits: %d chans: %d rate: %d\n", |
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
918 trak->stdata[19],trak->stdata[17],sh->samplerate); |
6612 | 919 |
8003 | 920 if(trak->stdata_len >= 44 && trak->stdata[9]>=1){ |
6612 | 921 mp_msg(MSGT_DEMUX,MSGL_V,"Audio header: samp/pack=%d bytes/pack=%d bytes/frame=%d bytes/samp=%d \n", |
922 char2int(trak->stdata,28), | |
923 char2int(trak->stdata,32), | |
924 char2int(trak->stdata,36), | |
925 char2int(trak->stdata,40)); | |
8003 | 926 if(trak->stdata_len>=44+8){ |
927 int len=char2int(trak->stdata,44); | |
928 int fcc=char2int(trak->stdata,48); | |
929 // we have extra audio headers!!! | |
930 printf("Audio extra header: len=%d fcc=0x%X\n",len,fcc); | |
931 sh->codecdata_len = len-8; | |
932 sh->codecdata = trak->stdata+44+8; | |
933 } | |
934 } | |
6612 | 935 |
9590
ad8223e04c4f
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>. (This is the right patch)
rtognimp
parents:
9575
diff
changeset
|
936 if((trak->stdata[9]==0 || trak->stdata[9]==1) && trak->stdata_len >= 36) { // version 0 with extra atoms |
ad8223e04c4f
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>. (This is the right patch)
rtognimp
parents:
9575
diff
changeset
|
937 int adjust = (trak->stdata[9]==1)?48:0; |
ad8223e04c4f
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>. (This is the right patch)
rtognimp
parents:
9575
diff
changeset
|
938 int atom_len = char2int(trak->stdata,28+adjust); |
ad8223e04c4f
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>. (This is the right patch)
rtognimp
parents:
9575
diff
changeset
|
939 switch(char2int(trak->stdata,32+adjust)) { // atom type |
5301 | 940 case MOV_FOURCC('e','s','d','s'): { |
5242
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
941 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found MPEG4 audio Elementary Stream Descriptor atom (%d)!\n", atom_len); |
5307
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
942 if(atom_len > 8) { |
5305 | 943 esds_t esds; |
9590
ad8223e04c4f
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>. (This is the right patch)
rtognimp
parents:
9575
diff
changeset
|
944 if(!mp4_parse_esds(&trak->stdata[36+adjust], atom_len-8, &esds)) { |
5301 | 945 |
5305 | 946 sh->i_bps = esds.avgBitrate/8; |
5301 | 947 |
6928 | 948 // printf("######## audio format = %d ########\n",esds.objectTypeId); |
949 if(esds.objectTypeId==107) | |
950 sh->format=0x55; // .mp3 | |
951 | |
5301 | 952 // dump away the codec specific configuration for the AAC decoder |
6928 | 953 if(esds.decoderConfigLen){ |
5305 | 954 sh->codecdata_len = esds.decoderConfigLen; |
5301 | 955 sh->codecdata = (unsigned char *)malloc(sh->codecdata_len); |
5305 | 956 memcpy(sh->codecdata, esds.decoderConfig, sh->codecdata_len); |
6928 | 957 } |
5301 | 958 } |
5305 | 959 mp4_free_esds(&esds); // freeup esds mem |
5301 | 960 #if 0 |
961 { FILE* f=fopen("esds.dat","wb"); | |
962 fwrite(&trak->stdata[36],atom_len-8,1,f); | |
963 fclose(f); } | |
964 #endif | |
965 } | |
966 } break; | |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
967 default: |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
968 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unknown audio atom %c%c%c%c (%d)!\n", |
9590
ad8223e04c4f
Animatrix AAC fix, patch by <dimakar(at)yahoo.com>. (This is the right patch)
rtognimp
parents:
9575
diff
changeset
|
969 trak->stdata[32+adjust],trak->stdata[33+adjust],trak->stdata[34+adjust],trak->stdata[35+adjust], |
5206
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
970 atom_len); |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
971 } |
2ca5a9bfaa98
allow sh_audio struct to be initialized by demuxer, add parsing of mp4 esds header to mov demuxer, init faad from info from mov header
atmos4
parents:
5085
diff
changeset
|
972 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
973 mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s\n",&trak->fourcc); |
2543 | 974 #if 0 |
975 { FILE* f=fopen("stdata.dat","wb"); | |
976 fwrite(trak->stdata,trak->stdata_len,1,f); | |
977 fclose(f); } | |
978 { FILE* f=fopen("tkdata.dat","wb"); | |
979 fwrite(trak->tkdata,trak->tkdata_len,1,f); | |
980 fclose(f); } | |
981 #endif | |
2101 | 982 // Emulate WAVEFORMATEX struct: |
983 sh->wf=malloc(sizeof(WAVEFORMATEX)); | |
984 memset(sh->wf,0,sizeof(WAVEFORMATEX)); | |
2543 | 985 sh->wf->nChannels=(trak->stdata[16]<<8)+trak->stdata[17]; |
986 sh->wf->wBitsPerSample=(trak->stdata[18]<<8)+trak->stdata[19]; | |
987 // sh->wf->nSamplesPerSec=trak->timescale; | |
988 sh->wf->nSamplesPerSec=(trak->stdata[24]<<8)+trak->stdata[25]; | |
8061 | 989 if(trak->stdata_len >= 44 && trak->stdata[9]>=1 && char2int(trak->stdata,28)>0){ |
8009
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
990 //Audio header: samp/pack=4096 bytes/pack=743 bytes/frame=1486 bytes/samp=2 |
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
991 sh->wf->nAvgBytesPerSec=(sh->wf->nChannels*sh->wf->nSamplesPerSec* |
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
992 char2int(trak->stdata,32)+char2int(trak->stdata,28)/2) |
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
993 /char2int(trak->stdata,28); |
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
994 sh->wf->nBlockAlign=char2int(trak->stdata,36); |
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
995 } else { |
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
996 sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8; |
8105 | 997 // workaround for ms11 ima4 |
998 if (sh->format == 0x1100736d && trak->stdata_len >= 36) | |
999 sh->wf->nBlockAlign=char2int(trak->stdata,36); | |
8009
302708769c69
set up nBlockAlign, nBytesPerSec correctly if extended audio header avail.
arpi
parents:
8003
diff
changeset
|
1000 } |
2101 | 1001 // Selection: |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1002 // if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){ |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1003 // // (auto)selected audio track: |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1004 // demuxer->audio->id=priv->track_db; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1005 // demuxer->audio->sh=sh; sh->ds=demuxer->audio; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1006 // } |
2100 | 1007 break; |
1008 } | |
1009 case MOV_TRAK_VIDEO: { | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1010 int i, entry; |
10796
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1011 int flag, start, count_flag, end, palette_count, gray; |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1012 int hdr_ptr = 76; // the byte just after depth |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1013 unsigned char *palette_map; |
2100 | 1014 sh_video_t* sh=new_sh_video(demuxer,priv->track_db); |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1015 int depth = trak->stdata[75]|(trak->stdata[74]<<8); |
2100 | 1016 sh->format=trak->fourcc; |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1017 |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1018 // stdata[]: |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1019 // 8 short version |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1020 // 10 short revision |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1021 // 12 int vendor_id |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1022 // 16 int temporal_quality |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1023 // 20 int spatial_quality |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1024 // 24 short width |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1025 // 26 short height |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1026 // 28 int h_dpi |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1027 // 32 int v_dpi |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1028 // 36 int 0 |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1029 // 40 short frames_per_sample |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1030 // 42 char[4] compressor_name |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1031 // 74 short depth |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1032 // 76 short color_table_id |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1033 // additional atoms may follow, |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1034 // eg esds atom from .MP4 files |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1035 // 78 int atom size |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1036 // 82 char[4] atom type |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1037 // 86 ... atom data |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1038 |
5372
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1039 { ImageDescription* id=malloc(8+trak->stdata_len); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1040 trak->desc=id; |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1041 id->idSize=8+trak->stdata_len; |
10087 | 1042 // id->cType=bswap_32(trak->fourcc); |
1043 id->cType=le2me_32(trak->fourcc); | |
5372
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1044 id->version=char2short(trak->stdata,8); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1045 id->revisionLevel=char2short(trak->stdata,10); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1046 id->vendor=char2int(trak->stdata,12); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1047 id->temporalQuality=char2int(trak->stdata,16); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1048 id->spatialQuality=char2int(trak->stdata,20); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1049 id->width=char2short(trak->stdata,24); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1050 id->height=char2short(trak->stdata,26); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1051 id->hRes=char2int(trak->stdata,28); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1052 id->vRes=char2int(trak->stdata,32); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1053 id->dataSize=char2int(trak->stdata,36); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1054 id->frameCount=char2short(trak->stdata,40); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1055 memcpy(&id->name,trak->stdata+42,32); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1056 id->depth=char2short(trak->stdata,74); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1057 id->clutID=char2short(trak->stdata,76); |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1058 if(trak->stdata_len>78) memcpy(((char*)&id->clutID)+2,trak->stdata+78,trak->stdata_len-78); |
8158 | 1059 sh->ImageDesc=id; |
1060 #if 0 | |
5372
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1061 { FILE *f=fopen("ImageDescription","wb"); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1062 fwrite(id,id->idSize,1,f); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1063 fclose(f); |
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1064 } |
8158 | 1065 #endif |
5372
ee9dd55ef383
some under-devel code, will be required for qtx codecs
arpi
parents:
5307
diff
changeset
|
1066 } |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1067 |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1068 if(trak->stdata_len >= 86) { // extra atoms found |
5250 | 1069 int pos=78; |
5251 | 1070 int atom_len; |
5250 | 1071 while(pos+8<=trak->stdata_len && |
1072 (pos+(atom_len=char2int(trak->stdata,pos)))<=trak->stdata_len){ | |
1073 switch(char2int(trak->stdata,pos+4)) { // switch atom type | |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1074 case MOV_FOURCC('g','a','m','a'): |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1075 // intfp with gamma value at which movie was captured |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1076 // can be used to gamma correct movie display |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1077 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported Gamma-Correction movie atom (%d)!\n", |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1078 atom_len); |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1079 break; |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1080 case MOV_FOURCC('f','i','e','l'): |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1081 // 2 char-values (8bit int) that specify field handling |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1082 // see the Apple's QuickTime Fileformat PDF for more info |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1083 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported Field-Handling movie atom (%d)!\n", |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1084 atom_len); |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1085 break; |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1086 case MOV_FOURCC('m','j','q','t'): |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1087 // Motion-JPEG default quantization table |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1088 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported MJPEG-Quantization movie atom (%d)!\n", |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1089 atom_len); |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1090 break; |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1091 case MOV_FOURCC('m','j','h','t'): |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1092 // Motion-JPEG default huffman table |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1093 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unsupported MJPEG-Huffman movie atom (%d)!\n", |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1094 atom_len); |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1095 break; |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1096 case MOV_FOURCC('e','s','d','s'): |
5242
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1097 // MPEG4 Elementary Stream Descriptor header |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1098 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found MPEG4 movie Elementary Stream Descriptor atom (%d)!\n", atom_len); |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1099 // add code here to save esds header of length atom_len-8 |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1100 // beginning at stdata[86] to some variable to pass it |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1101 // on to the decoder ::atmos |
5307
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1102 if(atom_len > 8) { |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1103 esds_t esds; |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1104 if(!mp4_parse_esds(trak->stdata+pos+8, atom_len-8, &esds)) { |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1105 |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1106 // dump away the codec specific configuration for the AAC decoder |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1107 trak->stream_header_len = esds.decoderConfigLen; |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1108 trak->stream_header = (unsigned char *)malloc(trak->stream_header_len); |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1109 memcpy(trak->stream_header, esds.decoderConfig, trak->stream_header_len); |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1110 } |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1111 mp4_free_esds(&esds); // freeup esds mem |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1112 } |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1113 break; |
13190 | 1114 case MOV_FOURCC('a','v','c','C'): |
1115 // AVC decoder configuration record | |
1116 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: AVC decoder configuration record atom (%d)!\n", atom_len); | |
1117 if(atom_len > 8) { | |
1118 int i, poffs, cnt; | |
1119 // Parse some parts of avcC, just for fun :) | |
13333
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1120 // real parsing is done by avc1 decoder |
13190 | 1121 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC version: %d\n", *(trak->stdata+pos+8)); |
1122 if (*(trak->stdata+pos+8) != 1) | |
1123 mp_msg(MSGT_DEMUX, MSGL_ERR, "MOV: unknown avcC version (%d). Expexct problems.\n", *(trak->stdata+pos+9)); | |
1124 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC profile: %d\n", *(trak->stdata+pos+9)); | |
1125 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC profile compatibility: %d\n", *(trak->stdata+pos+10)); | |
1126 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC level: %d\n", *(trak->stdata+pos+11)); | |
13333
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1127 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC nal length size: %d\n", ((*(trak->stdata+pos+12))&0x03)+1); |
13190 | 1128 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC number of sequence param sets: %d\n", cnt = (*(trak->stdata+pos+13) & 0x1f)); |
1129 poffs = pos + 14; | |
1130 for (i = 0; i < cnt; i++) { | |
1131 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC sps %d have length %d\n", i, BE_16(trak->stdata+poffs)); | |
1132 poffs += BE_16(trak->stdata+poffs) + 2; | |
1133 } | |
1134 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC number of picture param sets: %d\n", *(trak->stdata+poffs)); | |
1135 poffs++; | |
1136 for (i = 0; i < cnt; i++) { | |
1137 mp_msg(MSGT_DEMUX, MSGL_V, "MOV: avcC pps %d have length %d\n", i, BE_16(trak->stdata+poffs)); | |
1138 poffs += BE_16(trak->stdata+poffs) + 2; | |
1139 } | |
1140 // Copy avcC for the AVC decoder | |
13333
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1141 // This data will be put in extradata below, where BITMAPINFOHEADER is created |
13190 | 1142 trak->stream_header_len = atom_len-8; |
1143 trak->stream_header = (unsigned char *)malloc(trak->stream_header_len); | |
1144 memcpy(trak->stream_header, trak->stdata+pos+8, trak->stream_header_len); | |
1145 } | |
1146 break; | |
6655
9eefcaf88e56
fixed endless 'unknown chunk' and doublespeed ima4 audio bugs
arpi
parents:
6612
diff
changeset
|
1147 case 0: |
9eefcaf88e56
fixed endless 'unknown chunk' and doublespeed ima4 audio bugs
arpi
parents:
6612
diff
changeset
|
1148 break; |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1149 default: |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1150 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Found unknown movie atom %c%c%c%c (%d)!\n", |
5250 | 1151 trak->stdata[pos+4],trak->stdata[pos+5],trak->stdata[pos+6],trak->stdata[pos+7], |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1152 atom_len); |
5250 | 1153 } |
6655
9eefcaf88e56
fixed endless 'unknown chunk' and doublespeed ima4 audio bugs
arpi
parents:
6612
diff
changeset
|
1154 if(atom_len<8) break; |
5250 | 1155 pos+=atom_len; |
5252 | 1156 // printf("pos=%d max=%d\n",pos,trak->stdata_len); |
5236
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1157 } |
f8a00b2c9c39
Add some atom parsing to movie trak and a bit cosmetics ;), Michael can now write esds movie header whereever he wants.
atmos4
parents:
5212
diff
changeset
|
1158 } |
5630 | 1159 sh->fps=trak->timescale/ |
1160 ((trak->durmap_size>=1)?(float)trak->durmap[0].dur:1); | |
2100 | 1161 sh->frametime=1.0f/sh->fps; |
5242
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1162 |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1163 sh->disp_w=trak->stdata[25]|(trak->stdata[24]<<8); |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1164 sh->disp_h=trak->stdata[27]|(trak->stdata[26]<<8); |
5242
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1165 // if image size is zero, fallback to display size |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1166 if(!sh->disp_w && !sh->disp_h) { |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1167 sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8); |
d4ffcbe9ed3d
Recognize and skip ftype chunk used by some .mp4 files and
atmos4
parents:
5241
diff
changeset
|
1168 sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8); |
5628 | 1169 } else if(sh->disp_w!=(trak->tkdata[77]|(trak->tkdata[76]<<8))){ |
1170 // codec and display width differ... use display one for aspect | |
1171 sh->aspect=trak->tkdata[77]|(trak->tkdata[76]<<8); | |
1172 sh->aspect/=trak->tkdata[81]|(trak->tkdata[80]<<8); | |
1173 } | |
1174 | |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1175 if(depth>32+8) printf("*** depth = 0x%X\n",depth); |
2101 | 1176 |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1177 // palettized? |
10796
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1178 gray = 0; |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1179 if (depth > 32) { depth&=31; gray = 1; } // depth > 32 means grayscale |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1180 if ((depth == 2) || (depth == 4) || (depth == 8)) |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1181 palette_count = (1 << depth); |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1182 else |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1183 palette_count = 0; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1184 |
2101 | 1185 // emulate BITMAPINFOHEADER: |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1186 if (palette_count) |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1187 { |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1188 sh->bih=malloc(sizeof(BITMAPINFOHEADER) + palette_count * 4); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1189 memset(sh->bih,0,sizeof(BITMAPINFOHEADER) + palette_count * 4); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1190 sh->bih->biSize=40 + palette_count * 4; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1191 // fetch the relevant fields |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1192 flag = BE_16(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1193 hdr_ptr += 2; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1194 start = BE_32(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1195 hdr_ptr += 4; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1196 count_flag = BE_16(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1197 hdr_ptr += 2; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1198 end = BE_16(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1199 hdr_ptr += 2; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1200 palette_map = (unsigned char *)sh->bih + 40; |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1201 mp_msg(MSGT_DEMUX, MSGL_INFO, "Allocated %d entries for palette\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1202 palette_count); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1203 mp_msg(MSGT_DEMUX, MSGL_DBG2, "QT palette: start: %x, end: %x, count flag: %d, flags: %x\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1204 start, end, count_flag, flag); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1205 |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1206 /* XXX: problems with sample (statunit6.mov) with flag&0x4 set! - alex*/ |
4332 | 1207 |
1208 // load default palette | |
4646
59eb588c7115
reinstated original palette decision logic from XAnim (was the QT spec
melanson
parents:
4645
diff
changeset
|
1209 if (flag & 0x08) |
4332 | 1210 { |
10796
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1211 if (gray) |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1212 { |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1213 mp_msg(MSGT_DEMUX, MSGL_INFO, "Using default QT grayscale palette\n"); |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1214 if (palette_count == 16) |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1215 memcpy(palette_map, qt_default_grayscale_palette_16, 16 * 4); |
12708 | 1216 else if (palette_count == 256) { |
10796
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1217 memcpy(palette_map, qt_default_grayscale_palette_256, 256 * 4); |
12708 | 1218 if (trak->fourcc == mmioFOURCC('c','v','i','d')) { |
1219 int i; | |
1220 // Hack for grayscale CVID, negative palette | |
1221 // If you have samples where this is not required contact me (rxt) | |
1222 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: greyscale cvid with default palette," | |
1223 " enabling negative palette hack.\n"); | |
1224 for (i = 0; i < 256 * 4; i++) | |
1225 palette_map[i] = palette_map[i] ^ 0xff; | |
1226 } | |
1227 } | |
10796
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1228 } |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1229 else |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1230 { |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1231 mp_msg(MSGT_DEMUX, MSGL_INFO, "Using default QT colour palette\n"); |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1232 if (palette_count == 4) |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1233 memcpy(palette_map, qt_default_palette_4, 4 * 4); |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1234 else if (palette_count == 16) |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1235 memcpy(palette_map, qt_default_palette_16, 16 * 4); |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1236 else if (palette_count == 256) |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1237 memcpy(palette_map, qt_default_palette_256, 256 * 4); |
266bf4b596a3
Support for grayscale paletted files. Patch by Dima K <dimakar@yahoo.com>
mosu
parents:
10087
diff
changeset
|
1238 } |
4332 | 1239 } |
1240 // load palette from file | |
1241 else | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1242 { |
4646
59eb588c7115
reinstated original palette decision logic from XAnim (was the QT spec
melanson
parents:
4645
diff
changeset
|
1243 mp_msg(MSGT_DEMUX, MSGL_INFO, "Loading palette from file\n"); |
4332 | 1244 for (i = start; i <= end; i++) |
1245 { | |
1246 entry = BE_16(&trak->stdata[hdr_ptr]); | |
1247 hdr_ptr += 2; | |
1248 // apparently, if count_flag is set, entry is same as i | |
1249 if (count_flag & 0x8000) | |
1250 entry = i; | |
1251 // only care about top 8 bits of 16-bit R, G, or B value | |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1252 if (entry <= palette_count && entry >= 0) |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1253 { |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1254 palette_map[entry * 4 + 2] = trak->stdata[hdr_ptr + 0]; |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1255 palette_map[entry * 4 + 1] = trak->stdata[hdr_ptr + 2]; |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1256 palette_map[entry * 4 + 0] = trak->stdata[hdr_ptr + 4]; |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1257 mp_dbg(MSGT_DEMUX, MSGL_DBG2, "QT palette: added entry: %d of %d (colors: R:%x G:%x B:%x)\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1258 entry, palette_count, |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1259 palette_map[entry * 4 + 2], |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1260 palette_map[entry * 4 + 1], |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1261 palette_map[entry * 4 + 0]); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1262 } |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1263 else |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1264 mp_msg(MSGT_DEMUX, MSGL_V, "QT palette: skipped entry (out of count): %d of %d\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1265 entry, palette_count); |
4332 | 1266 hdr_ptr += 6; |
1267 } | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1268 } |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1269 } |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1270 else |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1271 { |
13333
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1272 if (trak->fourcc == mmioFOURCC('a','v','c','1')) { |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1273 sh->bih=malloc(sizeof(BITMAPINFOHEADER) + trak->stream_header_len); |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1274 memset(sh->bih,0,sizeof(BITMAPINFOHEADER) + trak->stream_header_len); |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1275 sh->bih->biSize=40 + trak->stream_header_len; |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1276 memcpy(((unsigned char *)sh->bih)+40, trak->stream_header, trak->stream_header_len); |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1277 free (trak->stream_header); |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1278 trak->stream_header_len = 0; |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1279 trak->stream_header = NULL; |
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1280 } else { |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1281 sh->bih=malloc(sizeof(BITMAPINFOHEADER)); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1282 memset(sh->bih,0,sizeof(BITMAPINFOHEADER)); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1283 sh->bih->biSize=40; |
13333
5d4910f6aa79
AVC support moved to libavcodec, avcC atom is now passed in extradata
rtognimp
parents:
13190
diff
changeset
|
1284 } |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
1285 } |
2101 | 1286 sh->bih->biWidth=sh->disp_w; |
1287 sh->bih->biHeight=sh->disp_h; | |
1288 sh->bih->biPlanes=0; | |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
1289 sh->bih->biBitCount=depth; |
2101 | 1290 sh->bih->biCompression=trak->fourcc; |
1291 sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight; | |
1292 | |
5067
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1293 mp_msg(MSGT_DEMUX, MSGL_INFO, "Image size: %d x %d (%d bpp)\n",sh->disp_w,sh->disp_h,sh->bih->biBitCount); |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1294 if(trak->tkdata_len>81) |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1295 mp_msg(MSGT_DEMUX, MSGL_INFO, "Display size: %d x %d\n", |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1296 trak->tkdata[77]|(trak->tkdata[76]<<8), |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1297 trak->tkdata[81]|(trak->tkdata[80]<<8)); |
54fe37e1f1a7
some cleanup, fixes for video header parsing. finally we get the coded size instead of display size\!
arpi
parents:
4903
diff
changeset
|
1298 mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s Codec: '%.*s'\n",&trak->fourcc,trak->stdata[42]&31,trak->stdata+43); |
2115 | 1299 |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1300 // if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){ |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1301 // // (auto)selected video track: |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1302 // demuxer->video->id=priv->track_db; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1303 // demuxer->video->sh=sh; sh->ds=demuxer->video; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1304 // } |
2100 | 1305 break; |
1306 } | |
2786 | 1307 case MOV_TRAK_GENERIC: |
12651 | 1308 mp_msg(MSGT_DEMUX, MSGL_INFO, "Generic track - not completely understood! (id: %d)\n", |
2786 | 1309 trak->id); |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1310 /* XXX: Also this contains the FLASH data */ |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1311 |
2786 | 1312 #if 0 |
1313 { | |
1314 int pos = stream_tell(demuxer->stream); | |
1315 int i; | |
1316 int fd; | |
1317 char name[20]; | |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1318 |
2786 | 1319 for (i=0; i<trak->samples_size; i++) |
1320 { | |
1321 char buf[trak->samples[i].size]; | |
1322 stream_seek(demuxer->stream, trak->samples[i].pos); | |
1323 snprintf((char *)&name[0], 20, "samp%d", i); | |
1324 fd = open((char *)&name[0], O_CREAT|O_WRONLY); | |
1325 stream_read(demuxer->stream, &buf[0], trak->samples[i].size); | |
1326 write(fd, &buf[0], trak->samples[i].size); | |
1327 close(fd); | |
1328 } | |
1329 for (i=0; i<trak->chunks_size; i++) | |
1330 { | |
1331 char buf[trak->length]; | |
1332 stream_seek(demuxer->stream, trak->chunks[i].pos); | |
1333 snprintf((char *)&name[0], 20, "chunk%d", i); | |
1334 fd = open((char *)&name[0], O_CREAT|O_WRONLY); | |
1335 stream_read(demuxer->stream, &buf[0], trak->length); | |
1336 write(fd, &buf[0], trak->length); | |
1337 close(fd); | |
1338 } | |
1339 if (trak->samplesize > 0) | |
1340 { | |
1341 char *buf; | |
1342 | |
1343 buf = malloc(trak->samplesize); | |
1344 stream_seek(demuxer->stream, trak->chunks[0].pos); | |
1345 snprintf((char *)&name[0], 20, "trak%d", trak->id); | |
1346 fd = open((char *)&name[0], O_CREAT|O_WRONLY); | |
1347 stream_read(demuxer->stream, buf, trak->samplesize); | |
1348 write(fd, buf, trak->samplesize); | |
1349 close(fd); | |
1350 } | |
1351 stream_seek(demuxer->stream, pos); | |
1352 } | |
1353 #endif | |
1354 break; | |
2532 | 1355 default: |
1356 mp_msg(MSGT_DEMUX, MSGL_INFO, "Unknown track type found (type: %d)\n", trak->type); | |
1357 break; | |
2100 | 1358 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1359 mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n"); |
2100 | 1360 priv->track_db++; |
1490 | 1361 trak=NULL; |
2532 | 1362 break; |
1363 } | |
2148 | 1364 #ifndef HAVE_ZLIB |
2532 | 1365 case MOV_FOURCC('c','m','o','v'): { |
1973
5216f108cb4f
all error/warn/info messages moved to help_mp-en.h for translation
arpi
parents:
1567
diff
changeset
|
1366 mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
1490 | 1367 return; |
1368 } | |
2148 | 1369 #else |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1370 case MOV_FOURCC('m','o','o','v'): |
2532 | 1371 case MOV_FOURCC('c','m','o','v'): { |
2148 | 1372 // mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
1373 lschunks(demuxer,level+1,pos+len,NULL); | |
2532 | 1374 break; |
1375 } | |
1376 case MOV_FOURCC('d','c','o','m'): { | |
2148 | 1377 // int temp=stream_read_dword(demuxer->stream); |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1378 unsigned int algo=be2me_32(stream_read_dword(demuxer->stream)); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1379 mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header uses %.4s algo!\n",&algo); |
2532 | 1380 break; |
1381 } | |
1382 case MOV_FOURCC('c','m','v','d'): { | |
2148 | 1383 // int temp=stream_read_dword(demuxer->stream); |
1384 unsigned int moov_sz=stream_read_dword(demuxer->stream); | |
1385 unsigned int cmov_sz=len-4; | |
1386 unsigned char* cmov_buf=malloc(cmov_sz); | |
1387 unsigned char* moov_buf=malloc(moov_sz+16); | |
1388 int zret; | |
1389 z_stream zstrm; | |
1390 stream_t* backup; | |
1391 | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1392 mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header size: %d / %d\n",cmov_sz,moov_sz); |
2148 | 1393 |
1394 stream_read(demuxer->stream,cmov_buf,cmov_sz); | |
1395 | |
1396 zstrm.zalloc = (alloc_func)0; | |
1397 zstrm.zfree = (free_func)0; | |
1398 zstrm.opaque = (voidpf)0; | |
1399 zstrm.next_in = cmov_buf; | |
1400 zstrm.avail_in = cmov_sz; | |
1401 zstrm.next_out = moov_buf; | |
1402 zstrm.avail_out = moov_sz; | |
1403 | |
1404 zret = inflateInit(&zstrm); | |
1405 if (zret != Z_OK) | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1406 { mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov: inflateInit err %d\n",zret); |
2148 | 1407 return; |
1408 } | |
1409 zret = inflate(&zstrm, Z_NO_FLUSH); | |
1410 if ((zret != Z_OK) && (zret != Z_STREAM_END)) | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1411 { mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov inflate: ERR %d\n",zret); |
2148 | 1412 return; |
1413 } | |
1414 #if 0 | |
1415 else { | |
1416 FILE *DecOut; | |
1417 DecOut = fopen("Out.bin", "w"); | |
1418 fwrite(moov_buf, 1, moov_sz, DecOut); | |
1419 fclose(DecOut); | |
1420 } | |
1421 #endif | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1422 if(moov_sz != zstrm.total_out) |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1423 mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! moov size differs cmov: %d zlib: %d\n",moov_sz,zstrm.total_out); |
2148 | 1424 zret = inflateEnd(&zstrm); |
1425 | |
1426 backup=demuxer->stream; | |
1427 demuxer->stream=new_memory_stream(moov_buf,moov_sz); | |
1428 stream_skip(demuxer->stream,8); | |
1429 lschunks(demuxer,level+1,moov_sz,NULL); // parse uncompr. 'moov' | |
1430 //free_stream(demuxer->stream); | |
1431 demuxer->stream=backup; | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1432 free(cmov_buf); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1433 free(moov_buf); |
2532 | 1434 break; |
2148 | 1435 } |
1436 #endif | |
2532 | 1437 case MOV_FOURCC('u','d','t','a'): |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1438 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1439 unsigned int udta_id; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1440 off_t udta_len; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1441 off_t udta_size = len; |
1490 | 1442 |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1443 mp_msg(MSGT_DEMUX, MSGL_DBG2, "mov: user data record found\n"); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1444 mp_msg(MSGT_DEMUX, MSGL_V, "Quicktime Clip Info:\n"); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1445 |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1446 while((len > 8) && (udta_size > 8)) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1447 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1448 udta_len = stream_read_dword(demuxer->stream); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1449 udta_id = stream_read_dword(demuxer->stream); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1450 udta_size -= 8; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1451 mp_msg(MSGT_DEMUX, MSGL_DBG2, "udta_id: %.4s (len: %d)\n", &udta_id, udta_len); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1452 switch (udta_id) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1453 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1454 case MOV_FOURCC(0xa9,'c','p','y'): |
2542 | 1455 case MOV_FOURCC(0xa9,'d','a','y'): |
1456 case MOV_FOURCC(0xa9,'d','i','r'): | |
1457 /* 0xa9,'e','d','1' - '9' : edit timestamps */ | |
1458 case MOV_FOURCC(0xa9,'f','m','t'): | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1459 case MOV_FOURCC(0xa9,'i','n','f'): |
2542 | 1460 case MOV_FOURCC(0xa9,'p','r','d'): |
1461 case MOV_FOURCC(0xa9,'p','r','f'): | |
1462 case MOV_FOURCC(0xa9,'r','e','q'): | |
1463 case MOV_FOURCC(0xa9,'s','r','c'): | |
1464 case MOV_FOURCC('n','a','m','e'): | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1465 case MOV_FOURCC(0xa9,'n','a','m'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1466 case MOV_FOURCC(0xa9,'A','R','T'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1467 case MOV_FOURCC(0xa9,'c','m','t'): |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1468 case MOV_FOURCC(0xa9,'a','u','t'): |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1469 case MOV_FOURCC(0xa9,'s','w','r'): |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1470 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1471 off_t text_len = stream_read_word(demuxer->stream); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1472 char text[text_len+2+1]; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1473 stream_read(demuxer->stream, (char *)&text, text_len+2); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1474 text[text_len+2] = 0x0; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1475 switch(udta_id) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1476 { |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1477 case MOV_FOURCC(0xa9,'a','u','t'): |
3071 | 1478 demux_info_add(demuxer, "author", &text[2]); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1479 mp_msg(MSGT_DEMUX, MSGL_V, " Author: %s\n", &text[2]); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1480 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1481 case MOV_FOURCC(0xa9,'c','p','y'): |
3071 | 1482 demux_info_add(demuxer, "copyright", &text[2]); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1483 mp_msg(MSGT_DEMUX, MSGL_V, " Copyright: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1484 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1485 case MOV_FOURCC(0xa9,'i','n','f'): |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1486 mp_msg(MSGT_DEMUX, MSGL_V, " Info: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1487 break; |
2542 | 1488 case MOV_FOURCC('n','a','m','e'): |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1489 case MOV_FOURCC(0xa9,'n','a','m'): |
3071 | 1490 demux_info_add(demuxer, "name", &text[2]); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1491 mp_msg(MSGT_DEMUX, MSGL_V, " Name: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1492 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1493 case MOV_FOURCC(0xa9,'A','R','T'): |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1494 mp_msg(MSGT_DEMUX, MSGL_V, " Artist: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1495 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1496 case MOV_FOURCC(0xa9,'d','i','r'): |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1497 mp_msg(MSGT_DEMUX, MSGL_V, " Director: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1498 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1499 case MOV_FOURCC(0xa9,'c','m','t'): |
3071 | 1500 demux_info_add(demuxer, "comments", &text[2]); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1501 mp_msg(MSGT_DEMUX, MSGL_V, " Comment: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1502 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1503 case MOV_FOURCC(0xa9,'r','e','q'): |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1504 mp_msg(MSGT_DEMUX, MSGL_V, " Requirements: %s\n", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1505 break; |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1506 case MOV_FOURCC(0xa9,'s','w','r'): |
3071 | 1507 demux_info_add(demuxer, "encoder", &text[2]); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1508 mp_msg(MSGT_DEMUX, MSGL_V, " Software: %s\n", &text[2]); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1509 break; |
2542 | 1510 case MOV_FOURCC(0xa9,'d','a','y'): |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1511 mp_msg(MSGT_DEMUX, MSGL_V, " Creation timestamp: %s\n", &text[2]); |
2542 | 1512 break; |
1513 case MOV_FOURCC(0xa9,'f','m','t'): | |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1514 mp_msg(MSGT_DEMUX, MSGL_V, " Format: %s\n", &text[2]); |
2542 | 1515 break; |
1516 case MOV_FOURCC(0xa9,'p','r','d'): | |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1517 mp_msg(MSGT_DEMUX, MSGL_V, " Producer: %s\n", &text[2]); |
2542 | 1518 break; |
1519 case MOV_FOURCC(0xa9,'p','r','f'): | |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1520 mp_msg(MSGT_DEMUX, MSGL_V, " Performer(s): %s\n", &text[2]); |
2542 | 1521 break; |
1522 case MOV_FOURCC(0xa9,'s','r','c'): | |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1523 mp_msg(MSGT_DEMUX, MSGL_V, " Source providers: %s\n", &text[2]); |
2542 | 1524 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1525 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1526 udta_size -= 4+text_len; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1527 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1528 } |
2542 | 1529 /* some other shits: WLOC - window location, |
1530 LOOP - looping style, | |
1531 SelO - play only selected frames | |
1532 AllF - play all frames | |
1533 */ | |
1534 case MOV_FOURCC('W','L','O','C'): | |
1535 case MOV_FOURCC('L','O','O','P'): | |
1536 case MOV_FOURCC('S','e','l','O'): | |
1537 case MOV_FOURCC('A','l','l','F'): | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1538 default: |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1539 { |
10888
0e940f364a6e
Fix for borked .mov files with bogus user data length values. Patch by Marek Zelem.
mosu
parents:
10849
diff
changeset
|
1540 if( udta_len>udta_size) |
0e940f364a6e
Fix for borked .mov files with bogus user data length values. Patch by Marek Zelem.
mosu
parents:
10849
diff
changeset
|
1541 udta_len=udta_size; |
0e940f364a6e
Fix for borked .mov files with bogus user data length values. Patch by Marek Zelem.
mosu
parents:
10849
diff
changeset
|
1542 { |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1543 char dump[udta_len-4]; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1544 stream_read(demuxer->stream, (char *)&dump, udta_len-4-4); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1545 udta_size -= udta_len; |
10888
0e940f364a6e
Fix for borked .mov files with bogus user data length values. Patch by Marek Zelem.
mosu
parents:
10849
diff
changeset
|
1546 } |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1547 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1548 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1549 } |
2532 | 1550 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1551 } /* eof udta */ |
2532 | 1552 default: |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
1553 id = be2me_32(id); |
2532 | 1554 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
1555 } /* endof switch */ | |
1556 } /* endof else */ | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
1557 |
1490 | 1558 pos+=len+8; |
1559 if(pos>=endpos) break; | |
1560 if(!stream_seek(demuxer->stream,pos)) break; | |
1561 } | |
1562 } | |
1563 | |
1564 int mov_read_header(demuxer_t* demuxer){ | |
1565 mov_priv_t* priv=demuxer->priv; | |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1566 int t_no; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1567 int best_a_id=-1, best_a_len=0; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1568 int best_v_id=-1, best_v_len=0; |
1490 | 1569 |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
1570 mp_msg(MSGT_DEMUX, MSGL_DBG3, "mov_read_header!\n"); |
1490 | 1571 |
1572 // Parse header: | |
2100 | 1573 stream_reset(demuxer->stream); |
5085
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1574 if(!stream_seek(demuxer->stream,priv->moov_start)) |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1575 { |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1576 mp_msg(MSGT_DEMUX,MSGL_ERR,"MOV: Cannot seek to the beginning of the Movie header (0x%x)\n", |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1577 priv->moov_start); |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1578 return 0; |
3d558414320f
workaround in palette reader for statunit6.mov, needed to implement support for flag&0x4 and small changes to avoid some sig11-places in the badly muxed cinepak pro movs
alex
parents:
5067
diff
changeset
|
1579 } |
1490 | 1580 lschunks(demuxer, 0, priv->moov_end, NULL); |
6139
3898967fcc96
some more output cosmetics, especially for vivo and mov demuxers
arpi
parents:
5776
diff
changeset
|
1581 // mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n"); |
1490 | 1582 |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1583 // find the best (longest) streams: |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1584 for(t_no=0;t_no<priv->track_db;t_no++){ |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1585 mov_track_t* trak=priv->tracks[t_no]; |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1586 int len=(trak->samplesize) ? trak->chunks_size : trak->samples_size; |
8830
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1587 if(demuxer->a_streams[t_no]){ // need audio |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1588 if(len>best_a_len){ best_a_len=len; best_a_id=t_no; } |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1589 } |
8830
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1590 if(demuxer->v_streams[t_no]){ // need video |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1591 if(len>best_v_len){ best_v_len=len; best_v_id=t_no; } |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1592 } |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1593 } |
8830
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1594 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: longest streams: A: #%d (%d samples) V: #%d (%d samples)\n", |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1595 best_a_id,best_a_len,best_v_id,best_v_len); |
8830
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1596 if(demuxer->audio->id==-1 && best_a_id>=0) demuxer->audio->id=best_a_id; |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1597 if(demuxer->video->id==-1 && best_v_id>=0) demuxer->video->id=best_v_id; |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1598 |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1599 // setup sh pointers: |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1600 if(demuxer->audio->id>=0){ |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1601 sh_audio_t* sh=demuxer->a_streams[demuxer->audio->id]; |
8830
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1602 if(sh){ |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1603 demuxer->audio->sh=sh; sh->ds=demuxer->audio; |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1604 } else { |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1605 mp_msg(MSGT_DEMUX, MSGL_ERR, "MOV: selected audio stream (%d) does not exists\n",demuxer->audio->id); |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1606 demuxer->audio->id=-2; |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1607 } |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1608 } |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1609 if(demuxer->video->id>=0){ |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1610 sh_video_t* sh=demuxer->v_streams[demuxer->video->id]; |
8830
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1611 if(sh){ |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1612 demuxer->video->sh=sh; sh->ds=demuxer->video; |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1613 } else { |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1614 mp_msg(MSGT_DEMUX, MSGL_ERR, "MOV: selected video stream (%d) does not exists\n",demuxer->video->id); |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1615 demuxer->video->id=-2; |
f4ca727309aa
- always print the longest stream in info, not the selected one
arpi
parents:
8451
diff
changeset
|
1616 } |
8386
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1617 } |
52a4ece3bbe2
find best (longest) streams if not specified (-aid/-vid)
arpi
parents:
8315
diff
changeset
|
1618 |
8314
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1619 #if 1 |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1620 if(verbose>2){ |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1621 for(t_no=0;t_no<priv->track_db;t_no++){ |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1622 mov_track_t* trak=priv->tracks[t_no]; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1623 if(trak->type==MOV_TRAK_GENERIC){ |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1624 int i; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1625 int fd; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1626 char name[20]; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1627 mp_msg(MSGT_DEMUX, MSGL_INFO, "MOV: Track #%d: Extracting %d data chunks to files\n",t_no,trak->samples_size); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1628 for (i=0; i<trak->samples_size; i++) |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1629 { |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1630 int len=trak->samples[i].size; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1631 char buf[len]; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1632 stream_seek(demuxer->stream, trak->samples[i].pos); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1633 snprintf(name, 20, "t%02d-s%03d.%s", t_no,i, |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1634 (trak->media_handler==MOV_FOURCC('f','l','s','h')) ? |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1635 "swf":"dump"); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1636 fd = open(name, O_CREAT|O_WRONLY); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1637 // { int j; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1638 // for(j=0;j<trak->stdata_len-3; j++) |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1639 // printf("stdata[%d]=0x%X ize=0x%X\n",j,char2int(trak->stdata,j),MOV_FOURCC('z','l','i','b')); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1640 // } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1641 if( //trak->media_handler==MOV_FOURCC('s','p','r','t') && |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1642 trak->stdata_len>=16 && |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1643 char2int(trak->stdata,12)==MOV_FOURCC('z','l','i','b') |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1644 ){ |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1645 int newlen=stream_read_dword(demuxer->stream); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1646 #ifdef HAVE_ZLIB |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1647 // unzip: |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1648 z_stream zstrm; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1649 int zret; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1650 char buf2[newlen]; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1651 |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1652 len-=4; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1653 stream_read(demuxer->stream, buf, len); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1654 |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1655 zstrm.zalloc = (alloc_func)0; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1656 zstrm.zfree = (free_func)0; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1657 zstrm.opaque = (voidpf)0; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1658 zstrm.next_in = buf; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1659 zstrm.avail_in = len; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1660 zstrm.next_out = buf2; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1661 zstrm.avail_out = newlen; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1662 |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1663 zret = inflateInit(&zstrm); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1664 zret = inflate(&zstrm, Z_NO_FLUSH); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1665 if(newlen != zstrm.total_out) |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1666 mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! unzipped frame size differs hdr: %d zlib: %d\n",newlen,zstrm.total_out); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1667 |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1668 write(fd, buf2, newlen); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1669 } else { |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1670 #else |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1671 len-=4; |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1672 printf("******* ZLIB COMPRESSED SAMPLE!!!!! (%d->%d bytes) *******\n",len,newlen); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1673 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1674 { |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1675 #endif |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1676 stream_read(demuxer->stream, buf, len); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1677 write(fd, buf, len); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1678 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1679 close(fd); |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1680 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1681 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1682 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1683 } |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1684 #endif |
d7ae896c5cde
- parsing the handler reference atom (hnlr), save handler fourccs
arpi
parents:
8258
diff
changeset
|
1685 |
2127 | 1686 return 1; |
1490 | 1687 } |
2101 | 1688 |
1689 // return value: | |
1690 // 0 = EOF or no stream found | |
1691 // 1 = successfully read a packet | |
1692 int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){ | |
1693 mov_priv_t* priv=demuxer->priv; | |
1694 mov_track_t* trak=NULL; | |
1695 float pts; | |
5252 | 1696 int x; |
1697 off_t pos; | |
2101 | 1698 |
1699 if(ds->id<0 || ds->id>=priv->track_db) return 0; | |
1700 trak=priv->tracks[ds->id]; | |
1701 | |
2115 | 1702 if(trak->samplesize){ |
1703 // read chunk: | |
1704 if(trak->pos>=trak->chunks_size) return 0; // EOF | |
1705 stream_seek(demuxer->stream,trak->chunks[trak->pos].pos); | |
1706 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
3071 | 1707 if(trak->samplesize!=1) |
1708 { | |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
1709 mp_msg(MSGT_DEMUX, MSGL_DBG2, "WARNING! Samplesize(%d) != 1\n", |
3071 | 1710 trak->samplesize); |
1711 x=trak->chunks[trak->pos].size*trak->samplesize; | |
1712 } | |
1713 else | |
1714 x=trak->chunks[trak->pos].size; | |
3652
65fd971932dc
added co64 (64bit chunk offset table) chunk (needed for mov files created with xawtv) and added depth detection in video track (tested with my *.mov files (about 15-20) and worked fine)
alex
parents:
3071
diff
changeset
|
1715 // printf("X = %d\n", x); |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
1716 /* the following stuff is audio related */ |
6612 | 1717 if (trak->type == MOV_TRAK_AUDIO){ |
6718
872235b50330
workaround for empty version1 audio headers (bugreport by Sascha Sommer)
arpi
parents:
6664
diff
changeset
|
1718 if(trak->stdata_len>=44 && trak->stdata[9]>=1 && char2int(trak->stdata,28)>0){ |
6612 | 1719 // stsd version 1 - we have audio compression ratio info: |
1720 x/=char2int(trak->stdata,28); // samples/packet | |
6655
9eefcaf88e56
fixed endless 'unknown chunk' and doublespeed ima4 audio bugs
arpi
parents:
6612
diff
changeset
|
1721 // x*=char2int(trak->stdata,32); // bytes/packet |
9eefcaf88e56
fixed endless 'unknown chunk' and doublespeed ima4 audio bugs
arpi
parents:
6612
diff
changeset
|
1722 x*=char2int(trak->stdata,36); // bytes/frame |
6612 | 1723 } else { |
7754 | 1724 if(ds->ss_div && ds->ss_mul){ |
6612 | 1725 // workaround for buggy files like 7up-high-traffic-areas.mov, |
1726 // with missing stsd v1 header containing compression rate | |
2549 | 1727 x/=ds->ss_div; x*=ds->ss_mul; // compression ratio fix ! HACK ! |
1728 } else { | |
6612 | 1729 x*=(trak->stdata[16]<<8)+trak->stdata[17]; //channels |
1730 x*=(trak->stdata[18]<<8)+trak->stdata[19]; //bits/sample | |
1731 x/=8; // bits/sample | |
2549 | 1732 } |
6612 | 1733 } |
1734 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Audio sample %d bytes pts %5.3f\n",trak->chunks[trak->pos].size*trak->samplesize,pts); | |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
1735 } /* MOV_TRAK_AUDIO */ |
5252 | 1736 pos=trak->chunks[trak->pos].pos; |
2115 | 1737 } else { |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1738 int frame=trak->pos; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1739 // editlist support: |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1740 if(trak->type == MOV_TRAK_VIDEO && trak->editlist_size>=1){ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1741 // find the right editlist entry: |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1742 if(frame<trak->editlist[trak->editlist_pos].start_frame) |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1743 trak->editlist_pos=0; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1744 while(trak->editlist_pos<trak->editlist_size-1 && |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1745 frame>=trak->editlist[trak->editlist_pos+1].start_frame) |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1746 ++trak->editlist_pos; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1747 if(frame>=trak->editlist[trak->editlist_pos].start_frame+ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1748 trak->editlist[trak->editlist_pos].frames) return 0; // EOF |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1749 // calc real frame index: |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1750 frame-=trak->editlist[trak->editlist_pos].start_frame; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1751 frame+=trak->editlist[trak->editlist_pos].start_sample; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1752 // calc pts: |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1753 pts=(float)(trak->samples[frame].pts+ |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1754 trak->editlist[trak->editlist_pos].pts_offset)/(float)trak->timescale; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1755 } else { |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1756 if(frame>=trak->samples_size) return 0; // EOF |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1757 pts=(float)trak->samples[frame].pts/(float)trak->timescale; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1758 } |
2101 | 1759 // read sample: |
6664
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1760 stream_seek(demuxer->stream,trak->samples[frame].pos); |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1761 x=trak->samples[frame].size; |
b802dd0812f1
edit-list support for video - fixes various A-V sync problems (TODO: seeking)
arpi
parents:
6655
diff
changeset
|
1762 pos=trak->samples[frame].pos; |
2115 | 1763 } |
5252 | 1764 if(trak->pos==0 && trak->stream_header_len>0){ |
1765 // we have to append the stream header... | |
1766 demux_packet_t* dp=new_demux_packet(x+trak->stream_header_len); | |
1767 memcpy(dp->buffer,trak->stream_header,trak->stream_header_len); | |
1768 stream_read(demuxer->stream,dp->buffer+trak->stream_header_len,x); | |
5307
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1769 free(trak->stream_header); |
fb58b4a8fb18
Use esds parser for movie esds atom and only pass decoder specific configuration into the stream_header.
atmos4
parents:
5305
diff
changeset
|
1770 trak->stream_header = NULL; |
10849
9c472c2c60fb
Fixed seeking in MPEG4 files. Patch by Uwe Reder <Uwe.Reder@3SOFT.de>.
mosu
parents:
10796
diff
changeset
|
1771 trak->stream_header_len = 0; |
5252 | 1772 dp->pts=pts; |
1773 dp->flags=0; | |
1774 dp->pos=pos; // FIXME? | |
1775 ds_add_packet(ds,dp); | |
1776 } else | |
1777 ds_read_packet(ds,demuxer->stream,x,pts,pos,0); | |
1778 | |
2101 | 1779 ++trak->pos; |
2115 | 1780 |
2101 | 1781 return 1; |
1782 | |
1783 } | |
2227 | 1784 |
1785 static float mov_seek_track(mov_track_t* trak,float pts,int flags){ | |
1786 | |
1787 // printf("MOV track seek called %5.3f \n",pts); | |
1788 if(flags&2) pts*=trak->length; else pts*=(float)trak->timescale; | |
1789 | |
1790 if(trak->samplesize){ | |
1791 int sample=pts/trak->duration; | |
1792 // printf("MOV track seek - chunk: %d (pts: %5.3f dur=%d) \n",sample,pts,trak->duration); | |
1793 if(!(flags&1)) sample+=trak->chunks[trak->pos].sample; // relative | |
1794 trak->pos=0; | |
1795 while(trak->pos<trak->chunks_size && trak->chunks[trak->pos].sample<sample) ++trak->pos; | |
1796 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
1797 } else { | |
2545 | 1798 unsigned int ipts; |
1799 if(!(flags&1)) pts+=trak->samples[trak->pos].pts; | |
1800 if(pts<0) pts=0; | |
1801 ipts=pts; | |
1802 //printf("MOV track seek - sample: %d \n",ipts); | |
2544 | 1803 for(trak->pos=0;trak->pos<trak->samples_size;++trak->pos){ |
1804 if(trak->samples[trak->pos].pts>=ipts) break; // found it! | |
1805 } | |
1806 if(trak->keyframes_size){ | |
1807 // find nearest keyframe | |
1808 int i; | |
1809 for(i=0;i<trak->keyframes_size;i++){ | |
1810 if(trak->keyframes[i]>=trak->pos) break; | |
1811 } | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
1812 if(i>0 && (trak->keyframes[i]-trak->pos) > (trak->pos-trak->keyframes[i-1])) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
1813 --i; |
2544 | 1814 trak->pos=trak->keyframes[i]; |
1815 // printf("nearest keyframe: %d \n",trak->pos); | |
1816 } | |
2227 | 1817 pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale; |
1818 } | |
1819 | |
1820 // printf("MOV track seek done: %5.3f \n",pts); | |
1821 | |
1822 return pts; | |
1823 } | |
1824 | |
1825 void demux_seek_mov(demuxer_t *demuxer,float pts,int flags){ | |
1826 mov_priv_t* priv=demuxer->priv; | |
1827 demux_stream_t* ds; | |
1828 | |
1829 // printf("MOV seek called %5.3f flag=%d \n",pts,flags); | |
1830 | |
1831 ds=demuxer->video; | |
1832 if(ds && ds->id>=0 && ds->id<priv->track_db){ | |
1833 mov_track_t* trak=priv->tracks[ds->id]; | |
1834 //if(flags&2) pts*=(float)trak->length/(float)trak->timescale; | |
1835 //if(!(flags&1)) pts+=ds->pts; | |
1836 pts=ds->pts=mov_seek_track(trak,pts,flags); | |
1837 flags=1; // absolute seconds | |
1838 } | |
1839 | |
1840 ds=demuxer->audio; | |
1841 if(ds && ds->id>=0 && ds->id<priv->track_db){ | |
1842 mov_track_t* trak=priv->tracks[ds->id]; | |
1843 //if(flags&2) pts*=(float)trak->length/(float)trak->timescale; | |
1844 //if(!(flags&1)) pts+=ds->pts; | |
1845 ds->pts=mov_seek_track(trak,pts,flags); | |
1846 } | |
1847 | |
1848 } | |
1849 |