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