Mercurial > mplayer.hg
annotate libmpdemux/demux_mov.c @ 4965:923605707de6
sorry, 10l:)
author | pontscho |
---|---|
date | Thu, 07 Mar 2002 00:03:51 +0000 |
parents | d8b465e3fd88 |
children | 54fe37e1f1a7 |
rev | line source |
---|---|
2148 | 1 // QuickTime MOV file parser by A'rpi |
2 // based on TOOLS/movinfo.c by me & Al3x | |
3 // compressed header support from moov.c of the openquicktime lib. | |
2386 | 4 // References: http://openquicktime.sf.net/, http://www.heroinewarrior.com/ |
2542 | 5 // http://www.geocities.com/SiliconValley/Lakes/2160/fformats/files/mov.pdf |
1490 | 6 |
7 #include <stdio.h> | |
8 #include <stdlib.h> | |
9 #include <unistd.h> | |
10 | |
1567 | 11 #include "config.h" |
12 #include "mp_msg.h" | |
1973
5216f108cb4f
all error/warn/info messages moved to help_mp-en.h for translation
arpi
parents:
1567
diff
changeset
|
13 #include "help_mp.h" |
1490 | 14 |
15 #include "stream.h" | |
16 #include "demuxer.h" | |
17 #include "stheader.h" | |
18 | |
2386 | 19 #include "bswap.h" |
20 | |
4332 | 21 #include "qtpalette.h" |
22 | |
2148 | 23 #ifdef HAVE_ZLIB |
24 #include <zlib.h> | |
25 #endif | |
26 | |
2786 | 27 #include <fcntl.h> |
28 | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
29 #define BE_16(x) (be2me_16(*(unsigned short *)(x))) |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
30 #define BE_32(x) (be2me_32(*(unsigned int *)(x))) |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
31 |
1490 | 32 typedef struct { |
2100 | 33 unsigned int pts; // duration |
34 unsigned int size; | |
35 off_t pos; | |
36 } mov_sample_t; | |
37 | |
38 typedef struct { | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
39 unsigned int sample; // number of the first sample in the chunk |
2115 | 40 unsigned int size; // number of samples in the chunk |
41 int desc; // for multiple codecs mode - not used | |
2100 | 42 off_t pos; |
43 } mov_chunk_t; | |
44 | |
45 typedef struct { | |
46 unsigned int first; | |
47 unsigned int spc; | |
48 unsigned int sdid; | |
49 } mov_chunkmap_t; | |
50 | |
51 typedef struct { | |
2115 | 52 unsigned int num; |
53 unsigned int dur; | |
54 } mov_durmap_t; | |
55 | |
4624 | 56 #define MOV_TRAK_UNKNOWN 0 |
57 #define MOV_TRAK_VIDEO 1 | |
58 #define MOV_TRAK_AUDIO 2 | |
59 #define MOV_TRAK_FLASH 3 | |
60 #define MOV_TRAK_GENERIC 4 | |
61 #define MOV_TRAK_CODE 5 | |
62 | |
2115 | 63 typedef struct { |
1490 | 64 int id; |
65 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
|
66 off_t pos; |
2101 | 67 // |
1490 | 68 int timescale; |
2100 | 69 unsigned int length; |
2115 | 70 int samplesize; // 0 = variable |
71 int duration; // 0 = variable | |
1490 | 72 int width,height; // for video |
73 unsigned int fourcc; | |
2115 | 74 // |
2101 | 75 int tkdata_len; // track data |
76 unsigned char* tkdata; | |
77 int stdata_len; // stream data | |
78 unsigned char* stdata; | |
2100 | 79 int samples_size; |
80 mov_sample_t* samples; | |
81 int chunks_size; | |
82 mov_chunk_t* chunks; | |
83 int chunkmap_size; | |
84 mov_chunkmap_t* chunkmap; | |
2115 | 85 int durmap_size; |
86 mov_durmap_t* durmap; | |
2544 | 87 int keyframes_size; |
88 unsigned int* keyframes; | |
1490 | 89 } mov_track_t; |
90 | |
2100 | 91 void mov_build_index(mov_track_t* trak){ |
92 int i,j,s; | |
93 int last=trak->chunks_size; | |
2115 | 94 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
|
95 |
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
|
96 #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
|
97 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
|
98 { |
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
|
99 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
|
100 |
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
|
101 trak->chunks_size = trak->samples_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
|
102 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
|
103 |
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
|
104 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
|
105 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
|
106 } |
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
|
107 #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
|
108 |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
109 mp_msg(MSGT_DEMUX, MSGL_HINT, "MOV track: %d chunks, %d samples\n",trak->chunks_size,trak->samples_size); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
110 mp_msg(MSGT_DEMUX, MSGL_HINT, "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
|
111 |
2100 | 112 // process chunkmap: |
113 i=trak->chunkmap_size; | |
114 while(i>0){ | |
115 --i; | |
116 for(j=trak->chunkmap[i].first;j<last;j++){ | |
117 trak->chunks[j].desc=trak->chunkmap[i].sdid; | |
118 trak->chunks[j].size=trak->chunkmap[i].spc; | |
119 } | |
120 last=trak->chunkmap[i].first; | |
121 } | |
2115 | 122 |
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
|
123 #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
|
124 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
|
125 { |
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
|
126 /* 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
|
127 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
|
128 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
|
129 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
|
130 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
|
131 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
|
132 } |
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
|
133 #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
|
134 |
2115 | 135 // calc pts of chunks: |
136 s=0; | |
137 for(j=0;j<trak->chunks_size;j++){ | |
138 trak->chunks[j].sample=s; | |
139 s+=trak->chunks[j].size; | |
140 } | |
141 | |
4624 | 142 // workaround for fixed-size video frames (dv and uncompressed) |
143 if(!trak->samples_size && trak->type==MOV_TRAK_VIDEO){ | |
144 trak->samples_size=s; | |
145 trak->samples=malloc(sizeof(mov_sample_t)*s); | |
146 for(i=0;i<s;i++) | |
147 trak->samples[i].size=trak->samplesize; | |
148 trak->samplesize=0; | |
149 } | |
150 | |
2115 | 151 if(!trak->samples_size){ |
152 // constant sampesize | |
153 if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){ | |
2227 | 154 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
|
155 } 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 | 156 return; |
157 } | |
158 | |
159 // calc pts: | |
160 s=0; | |
161 for(j=0;j<trak->durmap_size;j++){ | |
162 for(i=0;i<trak->durmap[j].num;i++){ | |
163 trak->samples[s].pts=pts; | |
164 ++s; | |
165 pts+=trak->durmap[j].dur; | |
166 } | |
167 } | |
2100 | 168 |
169 // calc sample offsets | |
170 s=0; | |
171 for(j=0;j<trak->chunks_size;j++){ | |
172 off_t pos=trak->chunks[j].pos; | |
173 for(i=0;i<trak->chunks[j].size;i++){ | |
174 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
|
175 mp_msg(MSGT_DEMUX, MSGL_DBG3, "Sample %5d: pts=%8d off=0x%08X size=%d\n",s, |
2100 | 176 trak->samples[s].pts, |
177 (int)trak->samples[s].pos, | |
178 trak->samples[s].size); | |
179 pos+=trak->samples[s].size; | |
180 ++s; | |
181 } | |
182 } | |
183 | |
184 } | |
185 | |
1490 | 186 #define MOV_MAX_TRACKS 256 |
187 | |
188 typedef struct { | |
189 off_t moov_start; | |
190 off_t moov_end; | |
191 off_t mdat_start; | |
192 off_t mdat_end; | |
193 int track_db; | |
194 mov_track_t* tracks[MOV_MAX_TRACKS]; | |
195 } mov_priv_t; | |
196 | |
197 #define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d)) | |
198 | |
199 int mov_check_file(demuxer_t* demuxer){ | |
200 int flags=0; | |
2879 | 201 int no=0; |
1490 | 202 mov_priv_t* priv=malloc(sizeof(mov_priv_t)); |
203 | |
1567 | 204 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for MOV\n"); |
1490 | 205 |
206 memset(priv,0,sizeof(mov_priv_t)); | |
207 demuxer->priv=priv; | |
208 | |
209 while(1){ | |
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
|
210 int skipped=8; |
1490 | 211 off_t len=stream_read_dword(demuxer->stream); |
212 unsigned int id=stream_read_dword(demuxer->stream); | |
213 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
|
214 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
|
215 { |
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
|
216 #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
|
217 if (stream_read_dword(demuxer->stream) != 0) |
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
|
218 mp_msg(MSGT_DEMUX, MSGL_WARN, "64bit file, but you've MPlayer compiled without LARGEFILE support!\n"); |
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
|
219 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
|
220 #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
|
221 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
|
222 #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
|
223 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
|
224 } |
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
|
225 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
|
226 |
1490 | 227 switch(id){ |
228 case MOV_FOURCC('m','o','o','v'): | |
1567 | 229 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie header found!\n"); |
1490 | 230 priv->moov_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
|
231 priv->moov_end=priv->moov_start+len-skipped; |
1490 | 232 flags|=1; |
233 break; | |
234 case MOV_FOURCC('m','d','a','t'): | |
1567 | 235 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie DATA found!\n"); |
1490 | 236 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
|
237 priv->mdat_end=priv->mdat_start+len-skipped; |
1490 | 238 flags|=2; |
239 break; | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
240 case MOV_FOURCC('f','r','e','e'): |
2942 | 241 case MOV_FOURCC('s','k','i','p'): |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
242 /* 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
|
243 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
244 case MOV_FOURCC('w','i','d','e'): |
2879 | 245 break; |
1490 | 246 default: |
2879 | 247 if(no==0) return 0; // first chunk is bad! |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
248 id = be2me_32(id); |
1567 | 249 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
1490 | 250 } |
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
|
251 if(!stream_skip(demuxer->stream,len-skipped)) break; |
2879 | 252 ++no; |
1490 | 253 } |
2148 | 254 |
255 if(flags==1) | |
256 mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing data (mdat) chunk! Maybe broken file...\n"); | |
257 else if(flags==2) | |
258 mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing header (moov/cmov) chunk! Maybe broken file...\n"); | |
1490 | 259 |
260 return (flags==3); | |
261 } | |
262 | |
263 static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){ | |
264 mov_priv_t* priv=demuxer->priv; | |
265 while(1){ | |
266 off_t pos; | |
267 off_t len; | |
268 unsigned int id; | |
269 // | |
270 pos=stream_tell(demuxer->stream); | |
2148 | 271 // printf("stream_tell==%d\n",pos); |
1490 | 272 if(pos>=endpos) return; // END |
273 len=stream_read_dword(demuxer->stream); | |
2148 | 274 // printf("len==%d\n",len); |
1490 | 275 if(len<8) return; // error |
276 len-=8; | |
277 id=stream_read_dword(demuxer->stream); | |
278 // | |
1567 | 279 mp_msg(MSGT_DEMUX,MSGL_DBG2,"lschunks %.4s %d\n",&id,(int)len); |
1490 | 280 // |
281 if(trak){ | |
282 switch(id){ | |
3071 | 283 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
|
284 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
|
285 /* here not supported :p */ |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
286 break; |
1490 | 287 case MOV_FOURCC('t','k','h','d'): { |
1567 | 288 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sTrack header!\n",level,""); |
2101 | 289 // read codec data |
290 trak->tkdata_len=len; | |
291 trak->tkdata=malloc(trak->tkdata_len); | |
292 stream_read(demuxer->stream,trak->tkdata,trak->tkdata_len); | |
1490 | 293 break; |
294 } | |
295 case MOV_FOURCC('m','d','h','d'): { | |
2100 | 296 unsigned int tmp; |
1567 | 297 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia header!\n",level,""); |
2100 | 298 #if 0 |
299 tmp=stream_read_dword(demuxer->stream); | |
300 printf("dword1: 0x%08X (%d)\n",tmp,tmp); | |
301 tmp=stream_read_dword(demuxer->stream); | |
302 printf("dword2: 0x%08X (%d)\n",tmp,tmp); | |
303 tmp=stream_read_dword(demuxer->stream); | |
304 printf("dword3: 0x%08X (%d)\n",tmp,tmp); | |
305 tmp=stream_read_dword(demuxer->stream); | |
306 printf("dword4: 0x%08X (%d)\n",tmp,tmp); | |
307 tmp=stream_read_dword(demuxer->stream); | |
308 printf("dword5: 0x%08X (%d)\n",tmp,tmp); | |
309 tmp=stream_read_dword(demuxer->stream); | |
310 printf("dword6: 0x%08X (%d)\n",tmp,tmp); | |
311 #endif | |
312 stream_skip(demuxer->stream,12); | |
1490 | 313 // read timescale |
2100 | 314 trak->timescale=stream_read_dword(demuxer->stream); |
315 // read length | |
316 trak->length=stream_read_dword(demuxer->stream); | |
1490 | 317 break; |
318 } | |
319 case MOV_FOURCC('v','m','h','d'): { | |
1567 | 320 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sVideo header!\n",level,""); |
1490 | 321 trak->type=MOV_TRAK_VIDEO; |
322 // read video data | |
323 break; | |
324 } | |
325 case MOV_FOURCC('s','m','h','d'): { | |
1567 | 326 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSound header!\n",level,""); |
1490 | 327 trak->type=MOV_TRAK_AUDIO; |
328 // read audio data | |
329 break; | |
330 } | |
2786 | 331 case MOV_FOURCC('g','m','h','d'): { |
332 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sGeneric header!\n",level,""); | |
333 trak->type=MOV_TRAK_GENERIC; | |
334 break; | |
335 } | |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
336 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
|
337 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
|
338 trak->type=MOV_TRAK_GENERIC; |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
339 break; |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
340 } |
1490 | 341 case MOV_FOURCC('s','t','s','d'): { |
342 int i=stream_read_dword(demuxer->stream); // temp! | |
343 int count=stream_read_dword(demuxer->stream); | |
1567 | 344 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sDescription list! (cnt:%d)\n",level,"",count); |
1490 | 345 for(i=0;i<count;i++){ |
346 off_t pos=stream_tell(demuxer->stream); | |
347 off_t len=stream_read_dword(demuxer->stream); | |
348 unsigned int fourcc=stream_read_dword_le(demuxer->stream); | |
349 if(len<8) break; // error | |
1567 | 350 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s desc #%d: %.4s",level,"",i,&fourcc); |
1490 | 351 if(!i){ |
352 trak->fourcc=fourcc; | |
353 // read codec data | |
2101 | 354 trak->stdata_len=len-8; |
355 trak->stdata=malloc(trak->stdata_len); | |
356 stream_read(demuxer->stream,trak->stdata,trak->stdata_len); | |
357 if(trak->type==MOV_TRAK_VIDEO && trak->stdata_len>43){ | |
358 mp_msg(MSGT_DEMUX,MSGL_V," '%.*s'",trak->stdata_len-43,trak->stdata+43); | |
1490 | 359 } |
360 } | |
1567 | 361 mp_msg(MSGT_DEMUX,MSGL_V,"\n"); |
1490 | 362 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
|
363 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVvariableFourCC); |
1490 | 364 if(!stream_seek(demuxer->stream,pos+len)) break; |
365 } | |
366 break; | |
367 } | |
2100 | 368 case MOV_FOURCC('s','t','t','s'): { |
369 int temp=stream_read_dword(demuxer->stream); | |
370 int len=stream_read_dword(demuxer->stream); | |
371 int i; | |
372 int x=0; | |
373 unsigned int pts=0; | |
374 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample duration table! (%d blocks)\n",level,"",len); | |
2115 | 375 trak->durmap=malloc(sizeof(mov_durmap_t)*len); |
376 memset(trak->durmap,0,sizeof(mov_durmap_t)*len); | |
377 trak->durmap_size=len; | |
2100 | 378 for(i=0;i<len;i++){ |
2115 | 379 trak->durmap[i].num=stream_read_dword(demuxer->stream); |
380 trak->durmap[i].dur=stream_read_dword(demuxer->stream); | |
381 pts+=trak->durmap[i].num*trak->durmap[i].dur; | |
2386 | 382 |
2786 | 383 if(i==0 && trak->type == MOV_TRAK_VIDEO) |
2386 | 384 { |
385 sh_video_t* sh=new_sh_video(demuxer,priv->track_db); | |
386 if (!sh->fps) | |
387 sh->fps = trak->timescale/trak->durmap[i].dur; | |
388 /* initial fps */ | |
389 } | |
2100 | 390 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
391 if(trak->length!=pts) mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! pts=%d length=%d\n",pts,trak->length); |
2100 | 392 break; |
393 } | |
394 case MOV_FOURCC('s','t','s','c'): { | |
395 int temp=stream_read_dword(demuxer->stream); | |
396 int len=stream_read_dword(demuxer->stream); | |
2533 | 397 int ver = (temp << 24); |
398 int flags = (temp << 16)|(temp<<8)|temp; | |
2100 | 399 int i; |
2533 | 400 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample->Chunk mapping table! (%d blocks) (ver:%d,flags:%ld)\n", |
401 level,"",len,ver,flags); | |
2100 | 402 // read data: |
403 trak->chunkmap_size=len; | |
404 trak->chunkmap=malloc(sizeof(mov_chunkmap_t)*len); | |
405 for(i=0;i<len;i++){ | |
2103 | 406 trak->chunkmap[i].first=stream_read_dword(demuxer->stream)-1; |
2100 | 407 trak->chunkmap[i].spc=stream_read_dword(demuxer->stream); |
408 trak->chunkmap[i].sdid=stream_read_dword(demuxer->stream); | |
409 } | |
410 break; | |
411 } | |
412 case MOV_FOURCC('s','t','s','z'): { | |
413 int temp=stream_read_dword(demuxer->stream); | |
414 int ss=stream_read_dword(demuxer->stream); | |
2533 | 415 int ver = (temp << 24); |
416 int flags = (temp << 16)|(temp<<8)|temp; | |
417 int entries=stream_read_dword(demuxer->stream); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
418 int i; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
419 |
2533 | 420 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample size table! (entries=%d ss=%d) (ver:%d,flags:%ld)\n", |
421 level,"",entries,ss,ver,flags); | |
2786 | 422 trak->samplesize=ss; |
423 if (!ss) { | |
424 // variable samplesize | |
425 trak->samples=realloc(trak->samples,sizeof(mov_sample_t)*entries); | |
426 trak->samples_size=entries; | |
427 for(i=0;i<entries;i++) | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
428 trak->samples[i].size=stream_read_dword(demuxer->stream); |
2786 | 429 } |
2100 | 430 break; |
431 } | |
432 case MOV_FOURCC('s','t','c','o'): { | |
433 int temp=stream_read_dword(demuxer->stream); | |
434 int len=stream_read_dword(demuxer->stream); | |
435 int i; | |
436 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sChunk offset table! (%d chunks)\n",level,"",len); | |
437 // extend array if needed: | |
438 if(len>trak->chunks_size){ | |
439 trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len); | |
440 trak->chunks_size=len; | |
441 } | |
442 // read elements: | |
443 for(i=0;i<len;i++) trak->chunks[i].pos=stream_read_dword(demuxer->stream); | |
444 break; | |
445 } | |
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
|
446 case MOV_FOURCC('c','o','6','4'): { |
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
|
447 int temp=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
|
448 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
|
449 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
|
450 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
|
451 // 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
|
452 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
|
453 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
|
454 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
|
455 } |
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
|
456 // 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
|
457 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
|
458 { |
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
|
459 #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
|
460 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
|
461 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
|
462 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
|
463 #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
|
464 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
|
465 #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
|
466 } |
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
|
467 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
|
468 } |
2533 | 469 case MOV_FOURCC('s','t','s','s'): { |
470 int temp=stream_read_dword(demuxer->stream); | |
471 int entries=stream_read_dword(demuxer->stream); | |
472 int ver = (temp << 24); | |
473 int flags = (temp << 16)|(temp<<8)|temp; | |
474 int i; | |
2542 | 475 mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sSyncing samples (keyframes) table! (%d entries) (ver:%d,flags:%ld)\n", |
2533 | 476 level, "",entries, ver, flags); |
2544 | 477 trak->keyframes_size=entries; |
478 trak->keyframes=malloc(sizeof(unsigned int)*entries); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
479 for (i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
480 trak->keyframes[i]=stream_read_dword(demuxer->stream)-1; |
2544 | 481 // for (i=0;i<entries;i++) printf("%3d: %d\n",i,trak->keyframes[i]); |
2533 | 482 break; |
483 } | |
1490 | 484 case MOV_FOURCC('m','d','i','a'): { |
1567 | 485 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia stream!\n",level,""); |
1490 | 486 lschunks(demuxer,level+1,pos+len,trak); |
487 break; | |
488 } | |
489 case MOV_FOURCC('m','i','n','f'): { | |
1567 | 490 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia info!\n",level,""); |
1490 | 491 lschunks(demuxer,level+1,pos+len,trak); |
492 break; | |
493 } | |
494 case MOV_FOURCC('s','t','b','l'): { | |
1567 | 495 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample info!\n",level,""); |
1490 | 496 lschunks(demuxer,level+1,pos+len,trak); |
497 break; | |
498 } | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
499 case MOV_FOURCC('e','d','t','s'): { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
500 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
|
501 lschunks(demuxer,level+1,pos+len,trak); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
502 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
503 } |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
504 case MOV_FOURCC('e','l','s','t'): { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
505 int temp=stream_read_dword(demuxer->stream); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
506 int entries=stream_read_dword(demuxer->stream); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
507 int ver = (temp << 24); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
508 int flags = (temp << 16)|(temp<<8)|temp; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
509 int i; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
510 |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
511 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
|
512 level, "",entries, ver, flags); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
513 #if 0 |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
514 for (i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
515 { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
516 printf("entry#%d: dur: %ld mtime: %ld mrate: %ld\n", |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
517 i, stream_read_dword(demuxer->stream), |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
518 stream_read_dword(demuxer->stream), |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
519 stream_read_dword(demuxer->stream)); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
520 } |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
521 #endif |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
522 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
523 } |
2786 | 524 case MOV_FOURCC('c','o','d','e'): |
525 { | |
3071 | 526 #warning "Implement atom 'code' for FLASH support" |
2786 | 527 } |
2532 | 528 default: |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
529 id = be2me_32(id); |
2532 | 530 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
531 break; | |
1490 | 532 }//switch(id) |
2532 | 533 } else { /* not in track */ |
534 switch(id) { | |
535 case MOV_FOURCC('t','r','a','k'): { | |
1490 | 536 // if(trak) printf("MOV: Warning! trak in trak?\n"); |
537 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
|
538 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVtooManyTrk); |
1490 | 539 return; |
540 } | |
541 trak=malloc(sizeof(mov_track_t)); | |
542 memset(trak,0,sizeof(mov_track_t)); | |
1567 | 543 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Track #%d:\n",priv->track_db); |
1490 | 544 trak->id=priv->track_db; |
2100 | 545 priv->tracks[priv->track_db]=trak; |
1490 | 546 lschunks(demuxer,level+1,pos+len,trak); |
2100 | 547 mov_build_index(trak); |
548 switch(trak->type){ | |
549 case MOV_TRAK_AUDIO: { | |
550 sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db); | |
551 sh->format=trak->fourcc; | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
552 mp_msg(MSGT_DEMUX, MSGL_INFO, "Audio bits: %d chans: %d\n",trak->stdata[19],trak->stdata[17]); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
553 mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s\n",&trak->fourcc); |
2543 | 554 #if 0 |
555 { FILE* f=fopen("stdata.dat","wb"); | |
556 fwrite(trak->stdata,trak->stdata_len,1,f); | |
557 fclose(f); } | |
558 { FILE* f=fopen("tkdata.dat","wb"); | |
559 fwrite(trak->tkdata,trak->tkdata_len,1,f); | |
560 fclose(f); } | |
561 #endif | |
2101 | 562 // Emulate WAVEFORMATEX struct: |
563 sh->wf=malloc(sizeof(WAVEFORMATEX)); | |
564 memset(sh->wf,0,sizeof(WAVEFORMATEX)); | |
2543 | 565 sh->wf->nChannels=(trak->stdata[16]<<8)+trak->stdata[17]; |
566 sh->wf->wBitsPerSample=(trak->stdata[18]<<8)+trak->stdata[19]; | |
567 // sh->wf->nSamplesPerSec=trak->timescale; | |
568 sh->wf->nSamplesPerSec=(trak->stdata[24]<<8)+trak->stdata[25]; | |
569 sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8; | |
2101 | 570 // Selection: |
571 if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){ | |
572 // (auto)selected audio track: | |
573 demuxer->audio->id=priv->track_db; | |
574 demuxer->audio->sh=sh; sh->ds=demuxer->audio; | |
575 } | |
2100 | 576 break; |
577 } | |
578 case MOV_TRAK_VIDEO: { | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
579 int i, entry; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
580 int flag, start, count_flag, end, palette_count; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
581 int hdr_ptr = 43+33; // the byte just after depth |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
582 unsigned char *palette_map; |
2100 | 583 sh_video_t* sh=new_sh_video(demuxer,priv->track_db); |
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
|
584 int depth = trak->stdata[43+32]; /* requested by Mike Melanson for Apple RLE decoder -- alex */ |
2100 | 585 sh->format=trak->fourcc; |
2386 | 586 if(!sh->fps) sh->fps=trak->timescale; |
2100 | 587 sh->frametime=1.0f/sh->fps; |
2101 | 588 sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8); |
589 sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8); | |
590 | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
591 // palettized? |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
592 if ((depth == 2) || (depth == 4) || (depth == 8) || |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
593 (depth == 34) || (depth == 36) || (depth == 40)) |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
594 palette_count = (1 << (depth & 0x0F)); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
595 else |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
596 palette_count = 0; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
597 |
2101 | 598 // emulate BITMAPINFOHEADER: |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
599 if (palette_count) |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
600 { |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
601 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
|
602 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
|
603 sh->bih->biSize=40 + palette_count * 4; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
604 // fetch the relevant fields |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
605 flag = BE_16(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
606 hdr_ptr += 2; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
607 start = BE_32(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
608 hdr_ptr += 4; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
609 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
|
610 hdr_ptr += 2; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
611 end = BE_16(&trak->stdata[hdr_ptr]); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
612 hdr_ptr += 2; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
613 palette_map = (unsigned char *)sh->bih + 40; |
4332 | 614 |
615 // load default palette | |
4646
59eb588c7115
reinstated original palette decision logic from XAnim (was the QT spec
melanson
parents:
4645
diff
changeset
|
616 if (flag & 0x08) |
4332 | 617 { |
4646
59eb588c7115
reinstated original palette decision logic from XAnim (was the QT spec
melanson
parents:
4645
diff
changeset
|
618 mp_msg(MSGT_DEMUX, MSGL_INFO, "Using default QT palette\n"); |
4332 | 619 if (palette_count == 4) |
620 memcpy(palette_map, qt_default_palette_4, 4 * 4); | |
621 else if (palette_count == 16) | |
622 memcpy(palette_map, qt_default_palette_16, 16 * 4); | |
623 if (palette_count == 256) | |
624 memcpy(palette_map, qt_default_palette_256, 256 * 4); | |
625 } | |
626 // load palette from file | |
627 else | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
628 { |
4646
59eb588c7115
reinstated original palette decision logic from XAnim (was the QT spec
melanson
parents:
4645
diff
changeset
|
629 mp_msg(MSGT_DEMUX, MSGL_INFO, "Loading palette from file\n"); |
4332 | 630 for (i = start; i <= end; i++) |
631 { | |
632 entry = BE_16(&trak->stdata[hdr_ptr]); | |
633 hdr_ptr += 2; | |
634 // apparently, if count_flag is set, entry is same as i | |
635 if (count_flag & 0x8000) | |
636 entry = i; | |
637 // only care about top 8 bits of 16-bit R, G, or B value | |
4371 | 638 palette_map[entry * 4 + 2] = trak->stdata[hdr_ptr + 0]; |
4332 | 639 palette_map[entry * 4 + 1] = trak->stdata[hdr_ptr + 2]; |
4371 | 640 palette_map[entry * 4 + 0] = trak->stdata[hdr_ptr + 4]; |
4332 | 641 hdr_ptr += 6; |
642 } | |
4129
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
643 } |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
644 } |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
645 else |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
646 { |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
647 sh->bih=malloc(sizeof(BITMAPINFOHEADER)); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
648 memset(sh->bih,0,sizeof(BITMAPINFOHEADER)); |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
649 sh->bih->biSize=40; |
31cd2e0bb961
QT demuxer loads palette information from files that transport palettes in
melanson
parents:
3999
diff
changeset
|
650 } |
2101 | 651 sh->bih->biWidth=sh->disp_w; |
652 sh->bih->biHeight=sh->disp_h; | |
653 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
|
654 sh->bih->biBitCount=depth; |
2101 | 655 sh->bih->biCompression=trak->fourcc; |
656 sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight; | |
657 | |
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
|
658 mp_msg(MSGT_DEMUX, MSGL_INFO, "Image size: %d x %d (%dbits)\n",sh->disp_w,sh->disp_h,sh->bih->biBitCount); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
659 mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s Codec: '%.*s'\n",&trak->fourcc,trak->stdata_len-43,trak->stdata+43); |
2115 | 660 |
2101 | 661 if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){ |
662 // (auto)selected video track: | |
663 demuxer->video->id=priv->track_db; | |
664 demuxer->video->sh=sh; sh->ds=demuxer->video; | |
665 } | |
2100 | 666 break; |
667 } | |
2786 | 668 case MOV_TRAK_GENERIC: |
669 mp_msg(MSGT_DEMUX, MSGL_INFO, "Generic track - not completly understood! (id: %d)\n", | |
670 trak->id); | |
3071 | 671 #warning "Also this contains the FLASH data" |
2786 | 672 #if 0 |
673 mp_msg(MSGT_DEMUX, MSGL_INFO, "Extracting samples to files (possibly this is an flash anim)\n"); | |
674 { | |
675 int pos = stream_tell(demuxer->stream); | |
676 int i; | |
677 int fd; | |
678 char name[20]; | |
679 | |
680 for (i=0; i<trak->samples_size; i++) | |
681 { | |
682 char buf[trak->samples[i].size]; | |
683 stream_seek(demuxer->stream, trak->samples[i].pos); | |
684 snprintf((char *)&name[0], 20, "samp%d", i); | |
685 fd = open((char *)&name[0], O_CREAT|O_WRONLY); | |
686 stream_read(demuxer->stream, &buf[0], trak->samples[i].size); | |
687 write(fd, &buf[0], trak->samples[i].size); | |
688 close(fd); | |
689 } | |
690 for (i=0; i<trak->chunks_size; i++) | |
691 { | |
692 char buf[trak->length]; | |
693 stream_seek(demuxer->stream, trak->chunks[i].pos); | |
694 snprintf((char *)&name[0], 20, "chunk%d", i); | |
695 fd = open((char *)&name[0], O_CREAT|O_WRONLY); | |
696 stream_read(demuxer->stream, &buf[0], trak->length); | |
697 write(fd, &buf[0], trak->length); | |
698 close(fd); | |
699 } | |
700 if (trak->samplesize > 0) | |
701 { | |
702 char *buf; | |
703 | |
704 buf = malloc(trak->samplesize); | |
705 stream_seek(demuxer->stream, trak->chunks[0].pos); | |
706 snprintf((char *)&name[0], 20, "trak%d", trak->id); | |
707 fd = open((char *)&name[0], O_CREAT|O_WRONLY); | |
708 stream_read(demuxer->stream, buf, trak->samplesize); | |
709 write(fd, buf, trak->samplesize); | |
710 close(fd); | |
711 } | |
712 stream_seek(demuxer->stream, pos); | |
713 } | |
714 #endif | |
715 break; | |
2532 | 716 default: |
717 mp_msg(MSGT_DEMUX, MSGL_INFO, "Unknown track type found (type: %d)\n", trak->type); | |
718 break; | |
2100 | 719 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
720 mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n"); |
2100 | 721 priv->track_db++; |
1490 | 722 trak=NULL; |
2532 | 723 break; |
724 } | |
2148 | 725 #ifndef HAVE_ZLIB |
2532 | 726 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
|
727 mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
1490 | 728 return; |
729 } | |
2148 | 730 #else |
2532 | 731 case MOV_FOURCC('c','m','o','v'): { |
2148 | 732 // mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
733 lschunks(demuxer,level+1,pos+len,NULL); | |
2532 | 734 break; |
735 } | |
736 case MOV_FOURCC('d','c','o','m'): { | |
2148 | 737 // int temp=stream_read_dword(demuxer->stream); |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
738 unsigned int len=be2me_32(stream_read_dword(demuxer->stream)); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
739 mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header uses %.4s algo!\n",&len); |
2532 | 740 break; |
741 } | |
742 case MOV_FOURCC('c','m','v','d'): { | |
2148 | 743 // int temp=stream_read_dword(demuxer->stream); |
744 unsigned int moov_sz=stream_read_dword(demuxer->stream); | |
745 unsigned int cmov_sz=len-4; | |
746 unsigned char* cmov_buf=malloc(cmov_sz); | |
747 unsigned char* moov_buf=malloc(moov_sz+16); | |
748 int zret; | |
749 z_stream zstrm; | |
750 stream_t* backup; | |
751 | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
752 mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header size: %d / %d\n",cmov_sz,moov_sz); |
2148 | 753 |
754 stream_read(demuxer->stream,cmov_buf,cmov_sz); | |
755 | |
756 zstrm.zalloc = (alloc_func)0; | |
757 zstrm.zfree = (free_func)0; | |
758 zstrm.opaque = (voidpf)0; | |
759 zstrm.next_in = cmov_buf; | |
760 zstrm.avail_in = cmov_sz; | |
761 zstrm.next_out = moov_buf; | |
762 zstrm.avail_out = moov_sz; | |
763 | |
764 zret = inflateInit(&zstrm); | |
765 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
|
766 { mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov: inflateInit err %d\n",zret); |
2148 | 767 return; |
768 } | |
769 zret = inflate(&zstrm, Z_NO_FLUSH); | |
770 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
|
771 { mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov inflate: ERR %d\n",zret); |
2148 | 772 return; |
773 } | |
774 #if 0 | |
775 else { | |
776 FILE *DecOut; | |
777 DecOut = fopen("Out.bin", "w"); | |
778 fwrite(moov_buf, 1, moov_sz, DecOut); | |
779 fclose(DecOut); | |
780 } | |
781 #endif | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
782 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
|
783 mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! moov size differs cmov: %d zlib: %d\n",moov_sz,zstrm.total_out); |
2148 | 784 zret = inflateEnd(&zstrm); |
785 | |
786 backup=demuxer->stream; | |
787 demuxer->stream=new_memory_stream(moov_buf,moov_sz); | |
788 stream_skip(demuxer->stream,8); | |
789 lschunks(demuxer,level+1,moov_sz,NULL); // parse uncompr. 'moov' | |
790 //free_stream(demuxer->stream); | |
791 demuxer->stream=backup; | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
792 free(cmov_buf); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
793 free(moov_buf); |
2532 | 794 break; |
2148 | 795 } |
796 #endif | |
2532 | 797 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
|
798 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
799 unsigned int udta_id; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
800 off_t udta_len; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
801 off_t udta_size = len; |
1490 | 802 |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
803 mp_msg(MSGT_DEMUX, MSGL_DBG2, "mov: user data record found\n"); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
804 mp_msg(MSGT_DEMUX, MSGL_INFO, "Quicktime Clip Info:\n"); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
805 |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
806 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
|
807 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
808 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
|
809 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
|
810 udta_size -= 8; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
811 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
|
812 switch (udta_id) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
813 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
814 case MOV_FOURCC(0xa9,'c','p','y'): |
2542 | 815 case MOV_FOURCC(0xa9,'d','a','y'): |
816 case MOV_FOURCC(0xa9,'d','i','r'): | |
817 /* 0xa9,'e','d','1' - '9' : edit timestamps */ | |
818 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
|
819 case MOV_FOURCC(0xa9,'i','n','f'): |
2542 | 820 case MOV_FOURCC(0xa9,'p','r','d'): |
821 case MOV_FOURCC(0xa9,'p','r','f'): | |
822 case MOV_FOURCC(0xa9,'r','e','q'): | |
823 case MOV_FOURCC(0xa9,'s','r','c'): | |
824 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
|
825 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
|
826 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
|
827 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
|
828 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
|
829 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
|
830 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
831 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
|
832 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
|
833 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
|
834 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
|
835 switch(udta_id) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
836 { |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
837 case MOV_FOURCC(0xa9,'a','u','t'): |
3071 | 838 demux_info_add(demuxer, "author", &text[2]); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
839 mp_msg(MSGT_DEMUX, MSGL_INFO, " Author: %s\n", &text[2]); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
840 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
841 case MOV_FOURCC(0xa9,'c','p','y'): |
3071 | 842 demux_info_add(demuxer, "copyright", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
843 mp_msg(MSGT_DEMUX, MSGL_INFO, " Copyright: %s\n", &text[2]); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
844 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
845 case MOV_FOURCC(0xa9,'i','n','f'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
846 mp_msg(MSGT_DEMUX, MSGL_INFO, " Info: %s\n", &text[2]); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
847 break; |
2542 | 848 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
|
849 case MOV_FOURCC(0xa9,'n','a','m'): |
3071 | 850 demux_info_add(demuxer, "name", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
851 mp_msg(MSGT_DEMUX, MSGL_INFO, " Name: %s\n", &text[2]); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
852 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
853 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
|
854 mp_msg(MSGT_DEMUX, MSGL_INFO, " Artist: %s\n", &text[2]); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
855 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
856 case MOV_FOURCC(0xa9,'d','i','r'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
857 mp_msg(MSGT_DEMUX, MSGL_INFO, " Director: %s\n", &text[2]); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
858 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
859 case MOV_FOURCC(0xa9,'c','m','t'): |
3071 | 860 demux_info_add(demuxer, "comments", &text[2]); |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
861 mp_msg(MSGT_DEMUX, MSGL_INFO, " Comment: %s\n", &text[2]); |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
862 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
863 case MOV_FOURCC(0xa9,'r','e','q'): |
2542 | 864 mp_msg(MSGT_DEMUX, MSGL_INFO, " 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
|
865 break; |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
866 case MOV_FOURCC(0xa9,'s','w','r'): |
3071 | 867 demux_info_add(demuxer, "encoder", &text[2]); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
868 mp_msg(MSGT_DEMUX, MSGL_INFO, " Software: %s\n", &text[2]); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
869 break; |
2542 | 870 case MOV_FOURCC(0xa9,'d','a','y'): |
871 mp_msg(MSGT_DEMUX, MSGL_INFO, " Creation timestamp: %s\n", &text[2]); | |
872 break; | |
873 case MOV_FOURCC(0xa9,'f','m','t'): | |
874 mp_msg(MSGT_DEMUX, MSGL_INFO, " Format: %s\n", &text[2]); | |
875 break; | |
876 case MOV_FOURCC(0xa9,'p','r','d'): | |
877 mp_msg(MSGT_DEMUX, MSGL_INFO, " Producer: %s\n", &text[2]); | |
878 break; | |
879 case MOV_FOURCC(0xa9,'p','r','f'): | |
880 mp_msg(MSGT_DEMUX, MSGL_INFO, " Performer(s): %s\n", &text[2]); | |
881 break; | |
882 case MOV_FOURCC(0xa9,'s','r','c'): | |
883 mp_msg(MSGT_DEMUX, MSGL_INFO, " Source providers: %s\n", &text[2]); | |
884 break; | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
885 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
886 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
|
887 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
888 } |
2542 | 889 /* some other shits: WLOC - window location, |
890 LOOP - looping style, | |
891 SelO - play only selected frames | |
892 AllF - play all frames | |
893 */ | |
894 case MOV_FOURCC('W','L','O','C'): | |
895 case MOV_FOURCC('L','O','O','P'): | |
896 case MOV_FOURCC('S','e','l','O'): | |
897 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
|
898 default: |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
899 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
900 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
|
901 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
|
902 udta_size -= udta_len; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
903 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
904 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
905 } |
2532 | 906 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
907 } /* eof udta */ |
2532 | 908 default: |
4903
d8b465e3fd88
fixed some endian issues, like changing bswap_32() -> be2me_32(), and
melanson
parents:
4646
diff
changeset
|
909 id = be2me_32(id); |
2532 | 910 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
911 } /* endof switch */ | |
912 } /* endof else */ | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
913 |
1490 | 914 pos+=len+8; |
915 if(pos>=endpos) break; | |
916 if(!stream_seek(demuxer->stream,pos)) break; | |
917 } | |
918 } | |
919 | |
920 int mov_read_header(demuxer_t* demuxer){ | |
921 mov_priv_t* priv=demuxer->priv; | |
922 | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
923 mp_msg(MSGT_DEMUX, MSGL_DBG3, "mov_read_header!\n"); |
1490 | 924 |
925 // Parse header: | |
2100 | 926 stream_reset(demuxer->stream); |
1490 | 927 if(!stream_seek(demuxer->stream,priv->moov_start)) return 0; // ??? |
928 lschunks(demuxer, 0, priv->moov_end, NULL); | |
929 | |
2127 | 930 return 1; |
1490 | 931 } |
2101 | 932 |
933 // return value: | |
934 // 0 = EOF or no stream found | |
935 // 1 = successfully read a packet | |
936 int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){ | |
937 mov_priv_t* priv=demuxer->priv; | |
938 mov_track_t* trak=NULL; | |
939 float pts; | |
940 | |
941 if(ds->id<0 || ds->id>=priv->track_db) return 0; | |
942 trak=priv->tracks[ds->id]; | |
943 | |
2115 | 944 if(trak->samplesize){ |
945 // read chunk: | |
2419 | 946 int x; |
2115 | 947 if(trak->pos>=trak->chunks_size) return 0; // EOF |
948 stream_seek(demuxer->stream,trak->chunks[trak->pos].pos); | |
949 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
3071 | 950 if(trak->samplesize!=1) |
951 { | |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
952 mp_msg(MSGT_DEMUX, MSGL_DBG2, "WARNING! Samplesize(%d) != 1\n", |
3071 | 953 trak->samplesize); |
954 x=trak->chunks[trak->pos].size*trak->samplesize; | |
955 } | |
956 else | |
957 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
|
958 // printf("X = %d\n", x); |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
959 /* the following stuff is audio related */ |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
960 if (trak->type == MOV_TRAK_AUDIO) |
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
961 { |
4624 | 962 if(trak->stdata_len>=36 && trak->stdata[30] && trak->stdata[31]){ |
2543 | 963 // extended stsd header - works for CBR MP3: |
964 x/=(trak->stdata[30]<<8)+trak->stdata[31]; // samples/packet | |
965 // x*=(trak->stdata[34]<<8)+trak->stdata[35]; // bytes/packet | |
966 x*=(trak->stdata[38]<<8)+trak->stdata[39]; // bytes/frame | |
967 } else { | |
968 // works for ima4: -- we should find this info in mov headers! | |
2549 | 969 if(ds->ss_div!=1 || ds->ss_mul!=1){ |
970 x/=ds->ss_div; x*=ds->ss_mul; // compression ratio fix ! HACK ! | |
971 } else { | |
972 x*=(trak->stdata[18]<<8)+trak->stdata[19];x/=8; // bits/sample | |
973 } | |
2543 | 974 } |
4645
33c2fc18138c
added nmhd, added checking for audio trak in demux_mov_fill_buffer
alex
parents:
4624
diff
changeset
|
975 } /* MOV_TRAK_AUDIO */ |
2419 | 976 ds_read_packet(ds,demuxer->stream,x,pts,trak->chunks[trak->pos].pos,0); |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
977 if(ds==demuxer->audio) mp_msg(MSGT_DEMUX, MSGL_DBG2, "sample %d bytes pts %5.3f\n",trak->chunks[trak->pos].size*trak->samplesize,pts); |
2115 | 978 } else { |
2101 | 979 // read sample: |
980 if(trak->pos>=trak->samples_size) return 0; // EOF | |
981 stream_seek(demuxer->stream,trak->samples[trak->pos].pos); | |
982 pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale; | |
983 ds_read_packet(ds,demuxer->stream,trak->samples[trak->pos].size,pts,trak->samples[trak->pos].pos,0); | |
2115 | 984 } |
2101 | 985 ++trak->pos; |
2115 | 986 |
2101 | 987 return 1; |
988 | |
989 } | |
2227 | 990 |
991 static float mov_seek_track(mov_track_t* trak,float pts,int flags){ | |
992 | |
993 // printf("MOV track seek called %5.3f \n",pts); | |
994 if(flags&2) pts*=trak->length; else pts*=(float)trak->timescale; | |
995 | |
996 if(trak->samplesize){ | |
997 int sample=pts/trak->duration; | |
998 // printf("MOV track seek - chunk: %d (pts: %5.3f dur=%d) \n",sample,pts,trak->duration); | |
999 if(!(flags&1)) sample+=trak->chunks[trak->pos].sample; // relative | |
1000 trak->pos=0; | |
1001 while(trak->pos<trak->chunks_size && trak->chunks[trak->pos].sample<sample) ++trak->pos; | |
1002 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
1003 } else { | |
2545 | 1004 unsigned int ipts; |
1005 if(!(flags&1)) pts+=trak->samples[trak->pos].pts; | |
1006 if(pts<0) pts=0; | |
1007 ipts=pts; | |
1008 //printf("MOV track seek - sample: %d \n",ipts); | |
2544 | 1009 for(trak->pos=0;trak->pos<trak->samples_size;++trak->pos){ |
1010 if(trak->samples[trak->pos].pts>=ipts) break; // found it! | |
1011 } | |
1012 if(trak->keyframes_size){ | |
1013 // find nearest keyframe | |
1014 int i; | |
1015 for(i=0;i<trak->keyframes_size;i++){ | |
1016 if(trak->keyframes[i]>=trak->pos) break; | |
1017 } | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
1018 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
|
1019 --i; |
2544 | 1020 trak->pos=trak->keyframes[i]; |
1021 // printf("nearest keyframe: %d \n",trak->pos); | |
1022 } | |
2227 | 1023 pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale; |
1024 } | |
1025 | |
1026 // printf("MOV track seek done: %5.3f \n",pts); | |
1027 | |
1028 return pts; | |
1029 } | |
1030 | |
1031 void demux_seek_mov(demuxer_t *demuxer,float pts,int flags){ | |
1032 mov_priv_t* priv=demuxer->priv; | |
1033 demux_stream_t* ds; | |
1034 | |
1035 // printf("MOV seek called %5.3f flag=%d \n",pts,flags); | |
1036 | |
1037 ds=demuxer->video; | |
1038 if(ds && ds->id>=0 && ds->id<priv->track_db){ | |
1039 mov_track_t* trak=priv->tracks[ds->id]; | |
1040 //if(flags&2) pts*=(float)trak->length/(float)trak->timescale; | |
1041 //if(!(flags&1)) pts+=ds->pts; | |
1042 pts=ds->pts=mov_seek_track(trak,pts,flags); | |
1043 flags=1; // absolute seconds | |
1044 } | |
1045 | |
1046 ds=demuxer->audio; | |
1047 if(ds && ds->id>=0 && ds->id<priv->track_db){ | |
1048 mov_track_t* trak=priv->tracks[ds->id]; | |
1049 //if(flags&2) pts*=(float)trak->length/(float)trak->timescale; | |
1050 //if(!(flags&1)) pts+=ds->pts; | |
1051 ds->pts=mov_seek_track(trak,pts,flags); | |
1052 } | |
1053 | |
1054 } | |
1055 |