Mercurial > mplayer.hg
annotate libmpdemux/demux_mov.c @ 2559:54ef00c7e2ad
codecs section renumbered!
author | gabucino |
---|---|
date | Tue, 30 Oct 2001 17:06:17 +0000 |
parents | 66837325b929 |
children | 1907e5771e81 |
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 | |
2148 | 21 #ifdef HAVE_ZLIB |
22 #include <zlib.h> | |
23 #endif | |
24 | |
1490 | 25 typedef struct { |
2100 | 26 unsigned int pts; // duration |
27 unsigned int size; | |
28 off_t pos; | |
29 } mov_sample_t; | |
30 | |
31 typedef struct { | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
32 unsigned int sample; // number of the first sample in the chunk |
2115 | 33 unsigned int size; // number of samples in the chunk |
34 int desc; // for multiple codecs mode - not used | |
2100 | 35 off_t pos; |
36 } mov_chunk_t; | |
37 | |
38 typedef struct { | |
39 unsigned int first; | |
40 unsigned int spc; | |
41 unsigned int sdid; | |
42 } mov_chunkmap_t; | |
43 | |
44 typedef struct { | |
2115 | 45 unsigned int num; |
46 unsigned int dur; | |
47 } mov_durmap_t; | |
48 | |
49 typedef struct { | |
1490 | 50 int id; |
51 int type; | |
2101 | 52 int pos; |
53 // | |
1490 | 54 int timescale; |
2100 | 55 unsigned int length; |
2115 | 56 int samplesize; // 0 = variable |
57 int duration; // 0 = variable | |
1490 | 58 int width,height; // for video |
59 unsigned int fourcc; | |
2115 | 60 // |
2101 | 61 int tkdata_len; // track data |
62 unsigned char* tkdata; | |
63 int stdata_len; // stream data | |
64 unsigned char* stdata; | |
2100 | 65 int samples_size; |
66 mov_sample_t* samples; | |
67 int chunks_size; | |
68 mov_chunk_t* chunks; | |
69 int chunkmap_size; | |
70 mov_chunkmap_t* chunkmap; | |
2115 | 71 int durmap_size; |
72 mov_durmap_t* durmap; | |
2544 | 73 int keyframes_size; |
74 unsigned int* keyframes; | |
1490 | 75 } mov_track_t; |
76 | |
2100 | 77 void mov_build_index(mov_track_t* trak){ |
78 int i,j,s; | |
79 int last=trak->chunks_size; | |
2115 | 80 unsigned int pts=0; |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
81 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
|
82 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
|
83 |
2100 | 84 // process chunkmap: |
85 i=trak->chunkmap_size; | |
86 while(i>0){ | |
87 --i; | |
88 for(j=trak->chunkmap[i].first;j<last;j++){ | |
89 trak->chunks[j].desc=trak->chunkmap[i].sdid; | |
90 trak->chunks[j].size=trak->chunkmap[i].spc; | |
91 } | |
92 last=trak->chunkmap[i].first; | |
93 } | |
2115 | 94 |
95 // calc pts of chunks: | |
96 s=0; | |
97 for(j=0;j<trak->chunks_size;j++){ | |
98 trak->chunks[j].sample=s; | |
99 s+=trak->chunks[j].size; | |
100 } | |
101 | |
102 if(!trak->samples_size){ | |
103 // constant sampesize | |
104 if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){ | |
2227 | 105 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
|
106 } 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 | 107 return; |
108 } | |
109 | |
110 // calc pts: | |
111 s=0; | |
112 for(j=0;j<trak->durmap_size;j++){ | |
113 for(i=0;i<trak->durmap[j].num;i++){ | |
114 trak->samples[s].pts=pts; | |
115 ++s; | |
116 pts+=trak->durmap[j].dur; | |
117 } | |
118 } | |
2100 | 119 |
120 // calc sample offsets | |
121 s=0; | |
122 for(j=0;j<trak->chunks_size;j++){ | |
123 off_t pos=trak->chunks[j].pos; | |
124 for(i=0;i<trak->chunks[j].size;i++){ | |
125 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
|
126 mp_msg(MSGT_DEMUX, MSGL_DBG3, "Sample %5d: pts=%8d off=0x%08X size=%d\n",s, |
2100 | 127 trak->samples[s].pts, |
128 (int)trak->samples[s].pos, | |
129 trak->samples[s].size); | |
130 pos+=trak->samples[s].size; | |
131 ++s; | |
132 } | |
133 } | |
134 | |
135 } | |
136 | |
1490 | 137 #define MOV_MAX_TRACKS 256 |
138 | |
139 #define MOV_TRAK_UNKNOWN 0 | |
140 #define MOV_TRAK_VIDEO 1 | |
141 #define MOV_TRAK_AUDIO 2 | |
2532 | 142 #define MOV_TRAK_FLASH 3 |
1490 | 143 |
144 typedef struct { | |
145 off_t moov_start; | |
146 off_t moov_end; | |
147 off_t mdat_start; | |
148 off_t mdat_end; | |
149 int track_db; | |
150 mov_track_t* tracks[MOV_MAX_TRACKS]; | |
151 } mov_priv_t; | |
152 | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
153 #warning "FIXME - mov support is only working perfectly on Little Endian systems?!" |
1490 | 154 #define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d)) |
155 | |
156 int mov_check_file(demuxer_t* demuxer){ | |
157 int flags=0; | |
158 mov_priv_t* priv=malloc(sizeof(mov_priv_t)); | |
159 | |
1567 | 160 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for MOV\n"); |
1490 | 161 |
162 memset(priv,0,sizeof(mov_priv_t)); | |
163 demuxer->priv=priv; | |
164 | |
165 while(1){ | |
166 off_t len=stream_read_dword(demuxer->stream); | |
167 unsigned int id=stream_read_dword(demuxer->stream); | |
168 if(stream_eof(demuxer->stream)) break; // EOF | |
169 if(len<8) break; // invalid chunk | |
170 switch(id){ | |
171 case MOV_FOURCC('m','o','o','v'): | |
1567 | 172 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie header found!\n"); |
1490 | 173 priv->moov_start=stream_tell(demuxer->stream); |
174 priv->moov_end=priv->moov_start+len-8; | |
175 flags|=1; | |
176 break; | |
177 case MOV_FOURCC('m','d','a','t'): | |
1567 | 178 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie DATA found!\n"); |
1490 | 179 priv->mdat_start=stream_tell(demuxer->stream); |
180 priv->mdat_end=priv->mdat_start+len-8; | |
181 flags|=2; | |
182 break; | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
183 case MOV_FOURCC('f','r','e','e'): |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
184 /* 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
|
185 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
186 case MOV_FOURCC('w','i','d','e'): |
1490 | 187 default: |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
188 id = bswap_32(id); |
1567 | 189 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
1490 | 190 } |
191 if(!stream_skip(demuxer->stream,len-8)) break; | |
192 } | |
2148 | 193 |
194 if(flags==1) | |
195 mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing data (mdat) chunk! Maybe broken file...\n"); | |
196 else if(flags==2) | |
197 mp_msg(MSGT_DEMUX,MSGL_WARN,"MOV: missing header (moov/cmov) chunk! Maybe broken file...\n"); | |
1490 | 198 |
199 return (flags==3); | |
200 } | |
201 | |
202 static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){ | |
203 mov_priv_t* priv=demuxer->priv; | |
204 while(1){ | |
205 off_t pos; | |
206 off_t len; | |
207 unsigned int id; | |
208 // | |
209 pos=stream_tell(demuxer->stream); | |
2148 | 210 // printf("stream_tell==%d\n",pos); |
1490 | 211 if(pos>=endpos) return; // END |
212 len=stream_read_dword(demuxer->stream); | |
2148 | 213 // printf("len==%d\n",len); |
1490 | 214 if(len<8) return; // error |
215 len-=8; | |
216 id=stream_read_dword(demuxer->stream); | |
217 // | |
1567 | 218 mp_msg(MSGT_DEMUX,MSGL_DBG2,"lschunks %.4s %d\n",&id,(int)len); |
1490 | 219 // |
220 if(trak){ | |
221 switch(id){ | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
222 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
|
223 /* here not supported :p */ |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
224 break; |
1490 | 225 case MOV_FOURCC('t','k','h','d'): { |
1567 | 226 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sTrack header!\n",level,""); |
2101 | 227 // read codec data |
228 trak->tkdata_len=len; | |
229 trak->tkdata=malloc(trak->tkdata_len); | |
230 stream_read(demuxer->stream,trak->tkdata,trak->tkdata_len); | |
1490 | 231 break; |
232 } | |
233 case MOV_FOURCC('m','d','h','d'): { | |
2100 | 234 unsigned int tmp; |
1567 | 235 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia header!\n",level,""); |
2100 | 236 #if 0 |
237 tmp=stream_read_dword(demuxer->stream); | |
238 printf("dword1: 0x%08X (%d)\n",tmp,tmp); | |
239 tmp=stream_read_dword(demuxer->stream); | |
240 printf("dword2: 0x%08X (%d)\n",tmp,tmp); | |
241 tmp=stream_read_dword(demuxer->stream); | |
242 printf("dword3: 0x%08X (%d)\n",tmp,tmp); | |
243 tmp=stream_read_dword(demuxer->stream); | |
244 printf("dword4: 0x%08X (%d)\n",tmp,tmp); | |
245 tmp=stream_read_dword(demuxer->stream); | |
246 printf("dword5: 0x%08X (%d)\n",tmp,tmp); | |
247 tmp=stream_read_dword(demuxer->stream); | |
248 printf("dword6: 0x%08X (%d)\n",tmp,tmp); | |
249 #endif | |
250 stream_skip(demuxer->stream,12); | |
1490 | 251 // read timescale |
2100 | 252 trak->timescale=stream_read_dword(demuxer->stream); |
253 // read length | |
254 trak->length=stream_read_dword(demuxer->stream); | |
1490 | 255 break; |
256 } | |
257 case MOV_FOURCC('v','m','h','d'): { | |
1567 | 258 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sVideo header!\n",level,""); |
1490 | 259 trak->type=MOV_TRAK_VIDEO; |
260 // read video data | |
261 break; | |
262 } | |
263 case MOV_FOURCC('s','m','h','d'): { | |
1567 | 264 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSound header!\n",level,""); |
1490 | 265 trak->type=MOV_TRAK_AUDIO; |
266 // read audio data | |
267 break; | |
268 } | |
269 case MOV_FOURCC('s','t','s','d'): { | |
270 int i=stream_read_dword(demuxer->stream); // temp! | |
271 int count=stream_read_dword(demuxer->stream); | |
1567 | 272 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sDescription list! (cnt:%d)\n",level,"",count); |
1490 | 273 for(i=0;i<count;i++){ |
274 off_t pos=stream_tell(demuxer->stream); | |
275 off_t len=stream_read_dword(demuxer->stream); | |
276 unsigned int fourcc=stream_read_dword_le(demuxer->stream); | |
277 if(len<8) break; // error | |
1567 | 278 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s desc #%d: %.4s",level,"",i,&fourcc); |
1490 | 279 if(!i){ |
280 trak->fourcc=fourcc; | |
281 // read codec data | |
2101 | 282 trak->stdata_len=len-8; |
283 trak->stdata=malloc(trak->stdata_len); | |
284 stream_read(demuxer->stream,trak->stdata,trak->stdata_len); | |
285 if(trak->type==MOV_TRAK_VIDEO && trak->stdata_len>43){ | |
286 mp_msg(MSGT_DEMUX,MSGL_V," '%.*s'",trak->stdata_len-43,trak->stdata+43); | |
1490 | 287 } |
288 } | |
1567 | 289 mp_msg(MSGT_DEMUX,MSGL_V,"\n"); |
1490 | 290 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
|
291 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVvariableFourCC); |
1490 | 292 if(!stream_seek(demuxer->stream,pos+len)) break; |
293 } | |
294 break; | |
295 } | |
2100 | 296 case MOV_FOURCC('s','t','t','s'): { |
297 int temp=stream_read_dword(demuxer->stream); | |
298 int len=stream_read_dword(demuxer->stream); | |
299 int i; | |
300 int x=0; | |
301 unsigned int pts=0; | |
302 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample duration table! (%d blocks)\n",level,"",len); | |
2115 | 303 trak->durmap=malloc(sizeof(mov_durmap_t)*len); |
304 memset(trak->durmap,0,sizeof(mov_durmap_t)*len); | |
305 trak->durmap_size=len; | |
2100 | 306 for(i=0;i<len;i++){ |
2115 | 307 trak->durmap[i].num=stream_read_dword(demuxer->stream); |
308 trak->durmap[i].dur=stream_read_dword(demuxer->stream); | |
309 pts+=trak->durmap[i].num*trak->durmap[i].dur; | |
2386 | 310 |
311 if(i==0) | |
312 { | |
313 sh_video_t* sh=new_sh_video(demuxer,priv->track_db); | |
314 if (!sh->fps) | |
315 sh->fps = trak->timescale/trak->durmap[i].dur; | |
316 /* initial fps */ | |
317 } | |
2100 | 318 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
319 if(trak->length!=pts) mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! pts=%d length=%d\n",pts,trak->length); |
2100 | 320 break; |
321 } | |
322 case MOV_FOURCC('s','t','s','c'): { | |
323 int temp=stream_read_dword(demuxer->stream); | |
324 int len=stream_read_dword(demuxer->stream); | |
2533 | 325 int ver = (temp << 24); |
326 int flags = (temp << 16)|(temp<<8)|temp; | |
2100 | 327 int i; |
2533 | 328 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample->Chunk mapping table! (%d blocks) (ver:%d,flags:%ld)\n", |
329 level,"",len,ver,flags); | |
2100 | 330 // read data: |
331 trak->chunkmap_size=len; | |
332 trak->chunkmap=malloc(sizeof(mov_chunkmap_t)*len); | |
333 for(i=0;i<len;i++){ | |
2103 | 334 trak->chunkmap[i].first=stream_read_dword(demuxer->stream)-1; |
2100 | 335 trak->chunkmap[i].spc=stream_read_dword(demuxer->stream); |
336 trak->chunkmap[i].sdid=stream_read_dword(demuxer->stream); | |
337 } | |
338 break; | |
339 } | |
340 case MOV_FOURCC('s','t','s','z'): { | |
341 int temp=stream_read_dword(demuxer->stream); | |
342 int ss=stream_read_dword(demuxer->stream); | |
2533 | 343 int ver = (temp << 24); |
344 int flags = (temp << 16)|(temp<<8)|temp; | |
345 int entries=stream_read_dword(demuxer->stream); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
346 int i; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
347 |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
348 trak->samplesize=ss; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
349 if (ss) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
350 { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
351 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample size table! (fixed ss=%d) (ver:%d,flags:%ld)\n", |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
352 level,"",ss,ver,flags); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
353 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
354 } |
2533 | 355 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample size table! (entries=%d ss=%d) (ver:%d,flags:%ld)\n", |
356 level,"",entries,ss,ver,flags); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
357 // variable samplesize |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
358 trak->samples=realloc(trak->samples,sizeof(mov_sample_t)*entries); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
359 trak->samples_size=entries; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
360 for(i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
361 trak->samples[i].size=stream_read_dword(demuxer->stream); |
2100 | 362 break; |
363 } | |
364 case MOV_FOURCC('s','t','c','o'): { | |
365 int temp=stream_read_dword(demuxer->stream); | |
366 int len=stream_read_dword(demuxer->stream); | |
367 int i; | |
368 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sChunk offset table! (%d chunks)\n",level,"",len); | |
369 // extend array if needed: | |
370 if(len>trak->chunks_size){ | |
371 trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len); | |
372 trak->chunks_size=len; | |
373 } | |
374 // read elements: | |
375 for(i=0;i<len;i++) trak->chunks[i].pos=stream_read_dword(demuxer->stream); | |
376 break; | |
377 } | |
2533 | 378 case MOV_FOURCC('s','t','s','s'): { |
379 int temp=stream_read_dword(demuxer->stream); | |
380 int entries=stream_read_dword(demuxer->stream); | |
381 int ver = (temp << 24); | |
382 int flags = (temp << 16)|(temp<<8)|temp; | |
383 int i; | |
2542 | 384 mp_msg(MSGT_DEMUX, MSGL_V,"MOV: %*sSyncing samples (keyframes) table! (%d entries) (ver:%d,flags:%ld)\n", |
2533 | 385 level, "",entries, ver, flags); |
2544 | 386 trak->keyframes_size=entries; |
387 trak->keyframes=malloc(sizeof(unsigned int)*entries); | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
388 for (i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
389 trak->keyframes[i]=stream_read_dword(demuxer->stream)-1; |
2544 | 390 // for (i=0;i<entries;i++) printf("%3d: %d\n",i,trak->keyframes[i]); |
2533 | 391 break; |
392 } | |
1490 | 393 case MOV_FOURCC('m','d','i','a'): { |
1567 | 394 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia stream!\n",level,""); |
1490 | 395 lschunks(demuxer,level+1,pos+len,trak); |
396 break; | |
397 } | |
398 case MOV_FOURCC('m','i','n','f'): { | |
1567 | 399 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia info!\n",level,""); |
1490 | 400 lschunks(demuxer,level+1,pos+len,trak); |
401 break; | |
402 } | |
403 case MOV_FOURCC('s','t','b','l'): { | |
1567 | 404 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample info!\n",level,""); |
1490 | 405 lschunks(demuxer,level+1,pos+len,trak); |
406 break; | |
407 } | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
408 case MOV_FOURCC('e','d','t','s'): { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
409 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
|
410 lschunks(demuxer,level+1,pos+len,trak); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
411 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
412 } |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
413 case MOV_FOURCC('e','l','s','t'): { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
414 int temp=stream_read_dword(demuxer->stream); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
415 int entries=stream_read_dword(demuxer->stream); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
416 int ver = (temp << 24); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
417 int flags = (temp << 16)|(temp<<8)|temp; |
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 |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
420 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
|
421 level, "",entries, ver, flags); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
422 #if 0 |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
423 for (i=0;i<entries;i++) |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
424 { |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
425 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
|
426 i, stream_read_dword(demuxer->stream), |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
427 stream_read_dword(demuxer->stream), |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
428 stream_read_dword(demuxer->stream)); |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
429 } |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
430 #endif |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
431 break; |
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
432 } |
2532 | 433 default: |
434 id = bswap_32(id); | |
435 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); | |
436 break; | |
1490 | 437 }//switch(id) |
2532 | 438 } else { /* not in track */ |
439 switch(id) { | |
440 case MOV_FOURCC('t','r','a','k'): { | |
1490 | 441 // if(trak) printf("MOV: Warning! trak in trak?\n"); |
442 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
|
443 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVtooManyTrk); |
1490 | 444 return; |
445 } | |
446 trak=malloc(sizeof(mov_track_t)); | |
447 memset(trak,0,sizeof(mov_track_t)); | |
1567 | 448 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Track #%d:\n",priv->track_db); |
1490 | 449 trak->id=priv->track_db; |
2100 | 450 priv->tracks[priv->track_db]=trak; |
1490 | 451 lschunks(demuxer,level+1,pos+len,trak); |
2100 | 452 mov_build_index(trak); |
453 switch(trak->type){ | |
454 case MOV_TRAK_AUDIO: { | |
455 sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db); | |
456 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
|
457 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
|
458 mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s\n",&trak->fourcc); |
2543 | 459 #if 0 |
460 { FILE* f=fopen("stdata.dat","wb"); | |
461 fwrite(trak->stdata,trak->stdata_len,1,f); | |
462 fclose(f); } | |
463 { FILE* f=fopen("tkdata.dat","wb"); | |
464 fwrite(trak->tkdata,trak->tkdata_len,1,f); | |
465 fclose(f); } | |
466 #endif | |
2101 | 467 // Emulate WAVEFORMATEX struct: |
468 sh->wf=malloc(sizeof(WAVEFORMATEX)); | |
469 memset(sh->wf,0,sizeof(WAVEFORMATEX)); | |
2543 | 470 sh->wf->nChannels=(trak->stdata[16]<<8)+trak->stdata[17]; |
471 sh->wf->wBitsPerSample=(trak->stdata[18]<<8)+trak->stdata[19]; | |
472 // sh->wf->nSamplesPerSec=trak->timescale; | |
473 sh->wf->nSamplesPerSec=(trak->stdata[24]<<8)+trak->stdata[25]; | |
474 sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8; | |
2101 | 475 // Selection: |
476 if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){ | |
477 // (auto)selected audio track: | |
478 demuxer->audio->id=priv->track_db; | |
479 demuxer->audio->sh=sh; sh->ds=demuxer->audio; | |
480 } | |
2100 | 481 break; |
482 } | |
483 case MOV_TRAK_VIDEO: { | |
484 sh_video_t* sh=new_sh_video(demuxer,priv->track_db); | |
485 sh->format=trak->fourcc; | |
2386 | 486 if(!sh->fps) sh->fps=trak->timescale; |
2100 | 487 sh->frametime=1.0f/sh->fps; |
2101 | 488 sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8); |
489 sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8); | |
490 | |
491 // emulate BITMAPINFOHEADER: | |
492 sh->bih=malloc(sizeof(BITMAPINFOHEADER)); | |
493 memset(sh->bih,0,sizeof(BITMAPINFOHEADER)); | |
494 sh->bih->biSize=40; | |
495 sh->bih->biWidth=sh->disp_w; | |
496 sh->bih->biHeight=sh->disp_h; | |
497 sh->bih->biPlanes=0; | |
498 sh->bih->biBitCount=16; | |
499 sh->bih->biCompression=trak->fourcc; | |
500 sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight; | |
501 | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
502 mp_msg(MSGT_DEMUX, MSGL_INFO, "Image size: %d x %d\n",sh->disp_w,sh->disp_h); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
503 mp_msg(MSGT_DEMUX, MSGL_INFO, "Fourcc: %.4s Codec: '%.*s'\n",&trak->fourcc,trak->stdata_len-43,trak->stdata+43); |
2115 | 504 |
2101 | 505 if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){ |
506 // (auto)selected video track: | |
507 demuxer->video->id=priv->track_db; | |
508 demuxer->video->sh=sh; sh->ds=demuxer->video; | |
509 } | |
2100 | 510 break; |
511 } | |
2532 | 512 default: |
513 mp_msg(MSGT_DEMUX, MSGL_INFO, "Unknown track type found (type: %d)\n", trak->type); | |
514 break; | |
2100 | 515 } |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
516 mp_msg(MSGT_DEMUX, MSGL_INFO, "--------------\n"); |
2100 | 517 priv->track_db++; |
1490 | 518 trak=NULL; |
2532 | 519 break; |
520 } | |
2148 | 521 #ifndef HAVE_ZLIB |
2532 | 522 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
|
523 mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
1490 | 524 return; |
525 } | |
2148 | 526 #else |
2532 | 527 case MOV_FOURCC('c','m','o','v'): { |
2148 | 528 // mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
529 lschunks(demuxer,level+1,pos+len,NULL); | |
2532 | 530 break; |
531 } | |
532 case MOV_FOURCC('d','c','o','m'): { | |
2148 | 533 // int temp=stream_read_dword(demuxer->stream); |
2386 | 534 unsigned int len=bswap_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
|
535 mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header uses %.4s algo!\n",&len); |
2532 | 536 break; |
537 } | |
538 case MOV_FOURCC('c','m','v','d'): { | |
2148 | 539 // int temp=stream_read_dword(demuxer->stream); |
540 unsigned int moov_sz=stream_read_dword(demuxer->stream); | |
541 unsigned int cmov_sz=len-4; | |
542 unsigned char* cmov_buf=malloc(cmov_sz); | |
543 unsigned char* moov_buf=malloc(moov_sz+16); | |
544 int zret; | |
545 z_stream zstrm; | |
546 stream_t* backup; | |
547 | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
548 mp_msg(MSGT_DEMUX, MSGL_INFO, "Compressed header size: %d / %d\n",cmov_sz,moov_sz); |
2148 | 549 |
550 stream_read(demuxer->stream,cmov_buf,cmov_sz); | |
551 | |
552 zstrm.zalloc = (alloc_func)0; | |
553 zstrm.zfree = (free_func)0; | |
554 zstrm.opaque = (voidpf)0; | |
555 zstrm.next_in = cmov_buf; | |
556 zstrm.avail_in = cmov_sz; | |
557 zstrm.next_out = moov_buf; | |
558 zstrm.avail_out = moov_sz; | |
559 | |
560 zret = inflateInit(&zstrm); | |
561 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
|
562 { mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov: inflateInit err %d\n",zret); |
2148 | 563 return; |
564 } | |
565 zret = inflate(&zstrm, Z_NO_FLUSH); | |
566 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
|
567 { mp_msg(MSGT_DEMUX, MSGL_ERR, "QT cmov inflate: ERR %d\n",zret); |
2148 | 568 return; |
569 } | |
570 #if 0 | |
571 else { | |
572 FILE *DecOut; | |
573 DecOut = fopen("Out.bin", "w"); | |
574 fwrite(moov_buf, 1, moov_sz, DecOut); | |
575 fclose(DecOut); | |
576 } | |
577 #endif | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
578 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
|
579 mp_msg(MSGT_DEMUX, MSGL_WARN, "Warning! moov size differs cmov: %d zlib: %d\n",moov_sz,zstrm.total_out); |
2148 | 580 zret = inflateEnd(&zstrm); |
581 | |
582 backup=demuxer->stream; | |
583 demuxer->stream=new_memory_stream(moov_buf,moov_sz); | |
584 stream_skip(demuxer->stream,8); | |
585 lschunks(demuxer,level+1,moov_sz,NULL); // parse uncompr. 'moov' | |
586 //free_stream(demuxer->stream); | |
587 demuxer->stream=backup; | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
588 free(cmov_buf); |
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
589 free(moov_buf); |
2532 | 590 break; |
2148 | 591 } |
592 #endif | |
2532 | 593 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
|
594 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
595 unsigned int udta_id; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
596 off_t udta_len; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
597 off_t udta_size = len; |
1490 | 598 |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
599 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
|
600 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
|
601 |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
602 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
|
603 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
604 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
|
605 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
|
606 udta_size -= 8; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
607 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
|
608 switch (udta_id) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
609 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
610 case MOV_FOURCC(0xa9,'c','p','y'): |
2542 | 611 case MOV_FOURCC(0xa9,'d','a','y'): |
612 case MOV_FOURCC(0xa9,'d','i','r'): | |
613 /* 0xa9,'e','d','1' - '9' : edit timestamps */ | |
614 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
|
615 case MOV_FOURCC(0xa9,'i','n','f'): |
2542 | 616 case MOV_FOURCC(0xa9,'p','r','d'): |
617 case MOV_FOURCC(0xa9,'p','r','f'): | |
618 case MOV_FOURCC(0xa9,'r','e','q'): | |
619 case MOV_FOURCC(0xa9,'s','r','c'): | |
620 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
|
621 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
|
622 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
|
623 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
|
624 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
|
625 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
|
626 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
627 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
|
628 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
|
629 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
|
630 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
|
631 switch(udta_id) |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
632 { |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
633 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
|
634 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
|
635 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
636 case MOV_FOURCC(0xa9,'c','p','y'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
637 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
|
638 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
639 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
|
640 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
|
641 break; |
2542 | 642 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
|
643 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
|
644 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
|
645 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
646 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
|
647 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
|
648 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
649 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
|
650 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
|
651 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
652 case MOV_FOURCC(0xa9,'c','m','t'): |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
653 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
|
654 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
655 case MOV_FOURCC(0xa9,'r','e','q'): |
2542 | 656 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
|
657 break; |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
658 case MOV_FOURCC(0xa9,'s','w','r'): |
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, " 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
|
660 break; |
2542 | 661 case MOV_FOURCC(0xa9,'d','a','y'): |
662 mp_msg(MSGT_DEMUX, MSGL_INFO, " Creation timestamp: %s\n", &text[2]); | |
663 break; | |
664 case MOV_FOURCC(0xa9,'f','m','t'): | |
665 mp_msg(MSGT_DEMUX, MSGL_INFO, " Format: %s\n", &text[2]); | |
666 break; | |
667 case MOV_FOURCC(0xa9,'p','r','d'): | |
668 mp_msg(MSGT_DEMUX, MSGL_INFO, " Producer: %s\n", &text[2]); | |
669 break; | |
670 case MOV_FOURCC(0xa9,'p','r','f'): | |
671 mp_msg(MSGT_DEMUX, MSGL_INFO, " Performer(s): %s\n", &text[2]); | |
672 break; | |
673 case MOV_FOURCC(0xa9,'s','r','c'): | |
674 mp_msg(MSGT_DEMUX, MSGL_INFO, " Source providers: %s\n", &text[2]); | |
675 break; | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
676 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
677 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
|
678 break; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
679 } |
2542 | 680 /* some other shits: WLOC - window location, |
681 LOOP - looping style, | |
682 SelO - play only selected frames | |
683 AllF - play all frames | |
684 */ | |
685 case MOV_FOURCC('W','L','O','C'): | |
686 case MOV_FOURCC('L','O','O','P'): | |
687 case MOV_FOURCC('S','e','l','O'): | |
688 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
|
689 default: |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
690 { |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
691 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
|
692 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
|
693 udta_size -= udta_len; |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
694 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
695 } |
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
696 } |
2532 | 697 break; |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
698 } /* eof udta */ |
2532 | 699 default: |
700 id = bswap_32(id); | |
701 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); | |
702 } /* endof switch */ | |
703 } /* endof else */ | |
2429
8d00b25169af
handling free chunk (wide needs implementation) and displaying clip info (datas from udta chunk)
alex
parents:
2419
diff
changeset
|
704 |
1490 | 705 pos+=len+8; |
706 if(pos>=endpos) break; | |
707 if(!stream_seek(demuxer->stream,pos)) break; | |
708 } | |
709 } | |
710 | |
711 int mov_read_header(demuxer_t* demuxer){ | |
712 mov_priv_t* priv=demuxer->priv; | |
713 | |
2483
22bfa362af42
added two new clip info types, all printf's were upgraded to mp_msg
alex
parents:
2429
diff
changeset
|
714 mp_msg(MSGT_DEMUX, MSGL_DBG3, "mov_read_header!\n"); |
1490 | 715 |
716 // Parse header: | |
2100 | 717 stream_reset(demuxer->stream); |
1490 | 718 if(!stream_seek(demuxer->stream,priv->moov_start)) return 0; // ??? |
719 lschunks(demuxer, 0, priv->moov_end, NULL); | |
720 | |
2127 | 721 return 1; |
1490 | 722 } |
2101 | 723 |
724 // return value: | |
725 // 0 = EOF or no stream found | |
726 // 1 = successfully read a packet | |
727 int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){ | |
728 mov_priv_t* priv=demuxer->priv; | |
729 mov_track_t* trak=NULL; | |
730 float pts; | |
731 | |
732 if(ds->id<0 || ds->id>=priv->track_db) return 0; | |
733 trak=priv->tracks[ds->id]; | |
734 | |
2115 | 735 if(trak->samplesize){ |
736 // read chunk: | |
2419 | 737 int x; |
2115 | 738 if(trak->pos>=trak->chunks_size) return 0; // EOF |
739 stream_seek(demuxer->stream,trak->chunks[trak->pos].pos); | |
740 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
2543 | 741 x=trak->chunks[trak->pos].size; |
742 // x=trak->chunks[trak->pos].size*trak->samplesize; | |
743 if(trak->samplesize!=1) printf("WARNING! Samplesize=%d \n",trak->samplesize); | |
744 if(trak->stdata_len>=36){ | |
745 // extended stsd header - works for CBR MP3: | |
746 x/=(trak->stdata[30]<<8)+trak->stdata[31]; // samples/packet | |
747 // x*=(trak->stdata[34]<<8)+trak->stdata[35]; // bytes/packet | |
748 x*=(trak->stdata[38]<<8)+trak->stdata[39]; // bytes/frame | |
749 } else { | |
750 // works for ima4: -- we should find this info in mov headers! | |
2549 | 751 if(ds->ss_div!=1 || ds->ss_mul!=1){ |
752 x/=ds->ss_div; x*=ds->ss_mul; // compression ratio fix ! HACK ! | |
753 } else { | |
754 x*=(trak->stdata[18]<<8)+trak->stdata[19];x/=8; // bits/sample | |
755 } | |
2543 | 756 } |
2419 | 757 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
|
758 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 | 759 } else { |
2101 | 760 // read sample: |
761 if(trak->pos>=trak->samples_size) return 0; // EOF | |
762 stream_seek(demuxer->stream,trak->samples[trak->pos].pos); | |
763 pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale; | |
764 ds_read_packet(ds,demuxer->stream,trak->samples[trak->pos].size,pts,trak->samples[trak->pos].pos,0); | |
2115 | 765 } |
2101 | 766 ++trak->pos; |
2115 | 767 |
2101 | 768 return 1; |
769 | |
770 } | |
2227 | 771 |
772 static float mov_seek_track(mov_track_t* trak,float pts,int flags){ | |
773 | |
774 // printf("MOV track seek called %5.3f \n",pts); | |
775 if(flags&2) pts*=trak->length; else pts*=(float)trak->timescale; | |
776 | |
777 if(trak->samplesize){ | |
778 int sample=pts/trak->duration; | |
779 // printf("MOV track seek - chunk: %d (pts: %5.3f dur=%d) \n",sample,pts,trak->duration); | |
780 if(!(flags&1)) sample+=trak->chunks[trak->pos].sample; // relative | |
781 trak->pos=0; | |
782 while(trak->pos<trak->chunks_size && trak->chunks[trak->pos].sample<sample) ++trak->pos; | |
783 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
784 } else { | |
2545 | 785 unsigned int ipts; |
786 if(!(flags&1)) pts+=trak->samples[trak->pos].pts; | |
787 if(pts<0) pts=0; | |
788 ipts=pts; | |
789 //printf("MOV track seek - sample: %d \n",ipts); | |
2544 | 790 for(trak->pos=0;trak->pos<trak->samples_size;++trak->pos){ |
791 if(trak->samples[trak->pos].pts>=ipts) break; // found it! | |
792 } | |
793 if(trak->keyframes_size){ | |
794 // find nearest keyframe | |
795 int i; | |
796 for(i=0;i<trak->keyframes_size;i++){ | |
797 if(trak->keyframes[i]>=trak->pos) break; | |
798 } | |
2546
c9485365537d
added edit atom (edit list), some comments and typos fixes
alex
parents:
2545
diff
changeset
|
799 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
|
800 --i; |
2544 | 801 trak->pos=trak->keyframes[i]; |
802 // printf("nearest keyframe: %d \n",trak->pos); | |
803 } | |
2227 | 804 pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale; |
805 } | |
806 | |
807 // printf("MOV track seek done: %5.3f \n",pts); | |
808 | |
809 return pts; | |
810 } | |
811 | |
812 void demux_seek_mov(demuxer_t *demuxer,float pts,int flags){ | |
813 mov_priv_t* priv=demuxer->priv; | |
814 demux_stream_t* ds; | |
815 | |
816 // printf("MOV seek called %5.3f flag=%d \n",pts,flags); | |
817 | |
818 ds=demuxer->video; | |
819 if(ds && ds->id>=0 && ds->id<priv->track_db){ | |
820 mov_track_t* trak=priv->tracks[ds->id]; | |
821 //if(flags&2) pts*=(float)trak->length/(float)trak->timescale; | |
822 //if(!(flags&1)) pts+=ds->pts; | |
823 pts=ds->pts=mov_seek_track(trak,pts,flags); | |
824 flags=1; // absolute seconds | |
825 } | |
826 | |
827 ds=demuxer->audio; | |
828 if(ds && ds->id>=0 && ds->id<priv->track_db){ | |
829 mov_track_t* trak=priv->tracks[ds->id]; | |
830 //if(flags&2) pts*=(float)trak->length/(float)trak->timescale; | |
831 //if(!(flags&1)) pts+=ds->pts; | |
832 ds->pts=mov_seek_track(trak,pts,flags); | |
833 } | |
834 | |
835 } | |
836 |