Mercurial > mplayer.hg
annotate demux_mov.c @ 2127:e6ce221dee06
.mov support can be disabled
author | arpi |
---|---|
date | Sun, 07 Oct 2001 21:59:49 +0000 |
parents | fe1cd4a5109a |
children | 0c6cef85d507 |
rev | line source |
---|---|
1490 | 1 // QuickTime MOV file parser |
2 // based on TOOLS/movinfo.c by A'rpi & Al3x | |
3 | |
4 #include <stdio.h> | |
5 #include <stdlib.h> | |
6 #include <unistd.h> | |
7 | |
1567 | 8 #include "config.h" |
9 #include "mp_msg.h" | |
1973
5216f108cb4f
all error/warn/info messages moved to help_mp-en.h for translation
arpi
parents:
1567
diff
changeset
|
10 #include "help_mp.h" |
1490 | 11 |
12 #include "stream.h" | |
13 #include "demuxer.h" | |
14 | |
15 #include "wine/mmreg.h" | |
16 #include "wine/avifmt.h" | |
17 #include "wine/vfw.h" | |
18 | |
19 #include "codec-cfg.h" | |
20 #include "stheader.h" | |
21 | |
22 typedef struct { | |
2100 | 23 unsigned int pts; // duration |
24 unsigned int size; | |
25 off_t pos; | |
26 } mov_sample_t; | |
27 | |
28 typedef struct { | |
2115 | 29 unsigned int sample; // number of the first sample in teh chunk |
30 unsigned int size; // number of samples in the chunk | |
31 int desc; // for multiple codecs mode - not used | |
2100 | 32 off_t pos; |
33 } mov_chunk_t; | |
34 | |
35 typedef struct { | |
36 unsigned int first; | |
37 unsigned int spc; | |
38 unsigned int sdid; | |
39 } mov_chunkmap_t; | |
40 | |
41 typedef struct { | |
2115 | 42 unsigned int num; |
43 unsigned int dur; | |
44 } mov_durmap_t; | |
45 | |
46 typedef struct { | |
1490 | 47 int id; |
48 int type; | |
2101 | 49 int pos; |
50 // | |
1490 | 51 int timescale; |
2100 | 52 unsigned int length; |
2115 | 53 int samplesize; // 0 = variable |
54 int duration; // 0 = variable | |
1490 | 55 int width,height; // for video |
56 unsigned int fourcc; | |
2115 | 57 // |
2101 | 58 int tkdata_len; // track data |
59 unsigned char* tkdata; | |
60 int stdata_len; // stream data | |
61 unsigned char* stdata; | |
2100 | 62 int samples_size; |
63 mov_sample_t* samples; | |
64 int chunks_size; | |
65 mov_chunk_t* chunks; | |
66 int chunkmap_size; | |
67 mov_chunkmap_t* chunkmap; | |
2115 | 68 int durmap_size; |
69 mov_durmap_t* durmap; | |
1490 | 70 } mov_track_t; |
71 | |
2100 | 72 void mov_build_index(mov_track_t* trak){ |
73 int i,j,s; | |
74 int last=trak->chunks_size; | |
2115 | 75 unsigned int pts=0; |
2100 | 76 printf("MOV track: %d chunks, %d samples\n",trak->chunks_size,trak->samples_size); |
77 printf("pts=%d scale=%d time=%5.3f\n",trak->length,trak->timescale,(float)trak->length/(float)trak->timescale); | |
78 // process chunkmap: | |
79 i=trak->chunkmap_size; | |
80 while(i>0){ | |
81 --i; | |
82 for(j=trak->chunkmap[i].first;j<last;j++){ | |
83 trak->chunks[j].desc=trak->chunkmap[i].sdid; | |
84 trak->chunks[j].size=trak->chunkmap[i].spc; | |
85 } | |
86 last=trak->chunkmap[i].first; | |
87 } | |
2115 | 88 |
89 // calc pts of chunks: | |
90 s=0; | |
91 for(j=0;j<trak->chunks_size;j++){ | |
92 trak->chunks[j].sample=s; | |
93 s+=trak->chunks[j].size; | |
94 } | |
95 | |
96 if(!trak->samples_size){ | |
97 // constant sampesize | |
98 if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){ | |
99 } else printf("*** constant samplesize & variable duration not yet supported! ***\nContact the author if you have such sample file!\n"); | |
100 return; | |
101 } | |
102 | |
103 // calc pts: | |
104 s=0; | |
105 for(j=0;j<trak->durmap_size;j++){ | |
106 for(i=0;i<trak->durmap[j].num;i++){ | |
107 trak->samples[s].pts=pts; | |
108 ++s; | |
109 pts+=trak->durmap[j].dur; | |
110 } | |
111 } | |
2100 | 112 |
113 // calc sample offsets | |
114 s=0; | |
115 for(j=0;j<trak->chunks_size;j++){ | |
116 off_t pos=trak->chunks[j].pos; | |
117 for(i=0;i<trak->chunks[j].size;i++){ | |
118 trak->samples[s].pos=pos; | |
119 #if 0 | |
120 printf("Sample %5d: pts=%8d off=0x%08X size=%d\n",s, | |
121 trak->samples[s].pts, | |
122 (int)trak->samples[s].pos, | |
123 trak->samples[s].size); | |
124 #endif | |
125 pos+=trak->samples[s].size; | |
126 ++s; | |
127 } | |
128 } | |
129 | |
130 } | |
131 | |
1490 | 132 #define MOV_MAX_TRACKS 256 |
133 | |
134 #define MOV_TRAK_UNKNOWN 0 | |
135 #define MOV_TRAK_VIDEO 1 | |
136 #define MOV_TRAK_AUDIO 2 | |
137 | |
138 typedef struct { | |
139 off_t moov_start; | |
140 off_t moov_end; | |
141 off_t mdat_start; | |
142 off_t mdat_end; | |
143 int track_db; | |
144 mov_track_t* tracks[MOV_MAX_TRACKS]; | |
145 } mov_priv_t; | |
146 | |
147 #define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d)) | |
148 | |
149 int mov_check_file(demuxer_t* demuxer){ | |
150 int flags=0; | |
151 mov_priv_t* priv=malloc(sizeof(mov_priv_t)); | |
152 | |
1567 | 153 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for MOV\n"); |
1490 | 154 |
155 memset(priv,0,sizeof(mov_priv_t)); | |
156 demuxer->priv=priv; | |
157 | |
158 while(1){ | |
159 off_t len=stream_read_dword(demuxer->stream); | |
160 unsigned int id=stream_read_dword(demuxer->stream); | |
161 if(stream_eof(demuxer->stream)) break; // EOF | |
162 if(len<8) break; // invalid chunk | |
163 switch(id){ | |
164 case MOV_FOURCC('m','o','o','v'): | |
1567 | 165 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie header found!\n"); |
1490 | 166 priv->moov_start=stream_tell(demuxer->stream); |
167 priv->moov_end=priv->moov_start+len-8; | |
168 flags|=1; | |
169 break; | |
170 case MOV_FOURCC('m','d','a','t'): | |
1567 | 171 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Movie DATA found!\n"); |
1490 | 172 priv->mdat_start=stream_tell(demuxer->stream); |
173 priv->mdat_end=priv->mdat_start+len-8; | |
174 flags|=2; | |
175 break; | |
176 default: | |
1567 | 177 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: unknown chunk: %.4s %d\n",&id,(int)len); |
1490 | 178 } |
179 if(!stream_skip(demuxer->stream,len-8)) break; | |
180 } | |
181 | |
182 return (flags==3); | |
183 } | |
184 | |
185 static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){ | |
186 mov_priv_t* priv=demuxer->priv; | |
187 while(1){ | |
188 off_t pos; | |
189 off_t len; | |
190 unsigned int id; | |
191 // | |
192 pos=stream_tell(demuxer->stream); | |
193 if(pos>=endpos) return; // END | |
194 len=stream_read_dword(demuxer->stream); | |
195 if(len<8) return; // error | |
196 len-=8; | |
197 id=stream_read_dword(demuxer->stream); | |
198 // | |
1567 | 199 mp_msg(MSGT_DEMUX,MSGL_DBG2,"lschunks %.4s %d\n",&id,(int)len); |
1490 | 200 // |
201 if(trak){ | |
202 switch(id){ | |
203 case MOV_FOURCC('t','k','h','d'): { | |
1567 | 204 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sTrack header!\n",level,""); |
2101 | 205 // read codec data |
206 trak->tkdata_len=len; | |
207 trak->tkdata=malloc(trak->tkdata_len); | |
208 stream_read(demuxer->stream,trak->tkdata,trak->tkdata_len); | |
1490 | 209 break; |
210 } | |
211 case MOV_FOURCC('m','d','h','d'): { | |
2100 | 212 unsigned int tmp; |
1567 | 213 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia header!\n",level,""); |
2100 | 214 #if 0 |
215 tmp=stream_read_dword(demuxer->stream); | |
216 printf("dword1: 0x%08X (%d)\n",tmp,tmp); | |
217 tmp=stream_read_dword(demuxer->stream); | |
218 printf("dword2: 0x%08X (%d)\n",tmp,tmp); | |
219 tmp=stream_read_dword(demuxer->stream); | |
220 printf("dword3: 0x%08X (%d)\n",tmp,tmp); | |
221 tmp=stream_read_dword(demuxer->stream); | |
222 printf("dword4: 0x%08X (%d)\n",tmp,tmp); | |
223 tmp=stream_read_dword(demuxer->stream); | |
224 printf("dword5: 0x%08X (%d)\n",tmp,tmp); | |
225 tmp=stream_read_dword(demuxer->stream); | |
226 printf("dword6: 0x%08X (%d)\n",tmp,tmp); | |
227 #endif | |
228 stream_skip(demuxer->stream,12); | |
1490 | 229 // read timescale |
2100 | 230 trak->timescale=stream_read_dword(demuxer->stream); |
231 // read length | |
232 trak->length=stream_read_dword(demuxer->stream); | |
1490 | 233 break; |
234 } | |
235 case MOV_FOURCC('v','m','h','d'): { | |
1567 | 236 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sVideo header!\n",level,""); |
1490 | 237 trak->type=MOV_TRAK_VIDEO; |
238 // read video data | |
239 break; | |
240 } | |
241 case MOV_FOURCC('s','m','h','d'): { | |
1567 | 242 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSound header!\n",level,""); |
1490 | 243 trak->type=MOV_TRAK_AUDIO; |
244 // read audio data | |
245 break; | |
246 } | |
247 case MOV_FOURCC('s','t','s','d'): { | |
248 int i=stream_read_dword(demuxer->stream); // temp! | |
249 int count=stream_read_dword(demuxer->stream); | |
1567 | 250 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sDescription list! (cnt:%d)\n",level,"",count); |
1490 | 251 for(i=0;i<count;i++){ |
252 off_t pos=stream_tell(demuxer->stream); | |
253 off_t len=stream_read_dword(demuxer->stream); | |
254 unsigned int fourcc=stream_read_dword_le(demuxer->stream); | |
255 if(len<8) break; // error | |
1567 | 256 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*s desc #%d: %.4s",level,"",i,&fourcc); |
1490 | 257 if(!i){ |
258 trak->fourcc=fourcc; | |
259 // read codec data | |
2101 | 260 trak->stdata_len=len-8; |
261 trak->stdata=malloc(trak->stdata_len); | |
262 stream_read(demuxer->stream,trak->stdata,trak->stdata_len); | |
263 if(trak->type==MOV_TRAK_VIDEO && trak->stdata_len>43){ | |
264 mp_msg(MSGT_DEMUX,MSGL_V," '%.*s'",trak->stdata_len-43,trak->stdata+43); | |
1490 | 265 } |
266 } | |
1567 | 267 mp_msg(MSGT_DEMUX,MSGL_V,"\n"); |
1490 | 268 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
|
269 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVvariableFourCC); |
1490 | 270 if(!stream_seek(demuxer->stream,pos+len)) break; |
271 } | |
272 break; | |
273 } | |
2100 | 274 case MOV_FOURCC('s','t','t','s'): { |
275 int temp=stream_read_dword(demuxer->stream); | |
276 int len=stream_read_dword(demuxer->stream); | |
277 int i; | |
278 int x=0; | |
279 unsigned int pts=0; | |
280 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample duration table! (%d blocks)\n",level,"",len); | |
2115 | 281 trak->durmap=malloc(sizeof(mov_durmap_t)*len); |
282 memset(trak->durmap,0,sizeof(mov_durmap_t)*len); | |
283 trak->durmap_size=len; | |
2100 | 284 for(i=0;i<len;i++){ |
2115 | 285 trak->durmap[i].num=stream_read_dword(demuxer->stream); |
286 trak->durmap[i].dur=stream_read_dword(demuxer->stream); | |
287 pts+=trak->durmap[i].num*trak->durmap[i].dur; | |
2100 | 288 } |
289 if(trak->length!=pts) printf("Warning! pts=%d length=%d\n",pts,trak->length); | |
290 break; | |
291 } | |
292 case MOV_FOURCC('s','t','s','c'): { | |
293 int temp=stream_read_dword(demuxer->stream); | |
294 int len=stream_read_dword(demuxer->stream); | |
295 int i; | |
296 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample->Chunk mapping table! (%d blocks)\n",level,"",len); | |
297 // read data: | |
298 trak->chunkmap_size=len; | |
299 trak->chunkmap=malloc(sizeof(mov_chunkmap_t)*len); | |
300 for(i=0;i<len;i++){ | |
2103 | 301 trak->chunkmap[i].first=stream_read_dword(demuxer->stream)-1; |
2100 | 302 trak->chunkmap[i].spc=stream_read_dword(demuxer->stream); |
303 trak->chunkmap[i].sdid=stream_read_dword(demuxer->stream); | |
304 } | |
305 break; | |
306 } | |
307 case MOV_FOURCC('s','t','s','z'): { | |
308 int temp=stream_read_dword(demuxer->stream); | |
309 int ss=stream_read_dword(demuxer->stream); | |
310 int len=stream_read_dword(demuxer->stream); | |
311 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample size table! len=%d ss=%d\n",level,"",len,ss); | |
2115 | 312 trak->samplesize=ss; |
313 if(!ss){ | |
314 // variable samplesize | |
315 int i; | |
2100 | 316 trak->samples=realloc(trak->samples,sizeof(mov_sample_t)*len); |
317 trak->samples_size=len; | |
2115 | 318 for(i=0;i<len;i++) |
319 trak->samples[i].size=stream_read_dword(demuxer->stream); | |
2100 | 320 } |
321 break; | |
322 } | |
323 case MOV_FOURCC('s','t','c','o'): { | |
324 int temp=stream_read_dword(demuxer->stream); | |
325 int len=stream_read_dword(demuxer->stream); | |
326 int i; | |
327 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sChunk offset table! (%d chunks)\n",level,"",len); | |
328 // extend array if needed: | |
329 if(len>trak->chunks_size){ | |
330 trak->chunks=realloc(trak->chunks,sizeof(mov_chunk_t)*len); | |
331 trak->chunks_size=len; | |
332 } | |
333 // read elements: | |
334 for(i=0;i<len;i++) trak->chunks[i].pos=stream_read_dword(demuxer->stream); | |
335 break; | |
336 } | |
1490 | 337 case MOV_FOURCC('m','d','i','a'): { |
1567 | 338 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia stream!\n",level,""); |
1490 | 339 lschunks(demuxer,level+1,pos+len,trak); |
340 break; | |
341 } | |
342 case MOV_FOURCC('m','i','n','f'): { | |
1567 | 343 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sMedia info!\n",level,""); |
1490 | 344 lschunks(demuxer,level+1,pos+len,trak); |
345 break; | |
346 } | |
347 case MOV_FOURCC('s','t','b','l'): { | |
1567 | 348 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: %*sSample info!\n",level,""); |
1490 | 349 lschunks(demuxer,level+1,pos+len,trak); |
350 break; | |
351 } | |
352 }//switch(id) | |
353 } else | |
354 if(id==MOV_FOURCC('t','r','a','k')){ | |
355 // if(trak) printf("MOV: Warning! trak in trak?\n"); | |
356 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
|
357 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_MOVtooManyTrk); |
1490 | 358 return; |
359 } | |
360 trak=malloc(sizeof(mov_track_t)); | |
361 memset(trak,0,sizeof(mov_track_t)); | |
1567 | 362 mp_msg(MSGT_DEMUX,MSGL_V,"MOV: Track #%d:\n",priv->track_db); |
1490 | 363 trak->id=priv->track_db; |
2100 | 364 priv->tracks[priv->track_db]=trak; |
1490 | 365 lschunks(demuxer,level+1,pos+len,trak); |
2100 | 366 mov_build_index(trak); |
367 switch(trak->type){ | |
368 case MOV_TRAK_AUDIO: { | |
369 sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db); | |
370 sh->format=trak->fourcc; | |
2101 | 371 printf("!!! audio bits: %d chans: %d\n",trak->stdata[19],trak->stdata[17]); |
2115 | 372 printf("Fourcc: %.4s\n",&trak->fourcc); |
2101 | 373 // Emulate WAVEFORMATEX struct: |
374 sh->wf=malloc(sizeof(WAVEFORMATEX)); | |
375 memset(sh->wf,0,sizeof(WAVEFORMATEX)); | |
376 sh->wf->nChannels=trak->stdata[17]; | |
377 sh->wf->wBitsPerSample=trak->stdata[19]; | |
378 sh->wf->nSamplesPerSec=trak->timescale; | |
379 sh->wf->nAvgBytesPerSec=sh->wf->nChannels*((sh->wf->wBitsPerSample+7)/8)*sh->wf->nSamplesPerSec; | |
380 // Selection: | |
381 if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){ | |
382 // (auto)selected audio track: | |
383 demuxer->audio->id=priv->track_db; | |
384 demuxer->audio->sh=sh; sh->ds=demuxer->audio; | |
385 } | |
2100 | 386 break; |
387 } | |
388 case MOV_TRAK_VIDEO: { | |
389 sh_video_t* sh=new_sh_video(demuxer,priv->track_db); | |
390 sh->format=trak->fourcc; | |
391 sh->fps=trak->timescale; | |
392 sh->frametime=1.0f/sh->fps; | |
2101 | 393 sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8); |
394 sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8); | |
395 | |
396 // emulate BITMAPINFOHEADER: | |
397 sh->bih=malloc(sizeof(BITMAPINFOHEADER)); | |
398 memset(sh->bih,0,sizeof(BITMAPINFOHEADER)); | |
399 sh->bih->biSize=40; | |
400 sh->bih->biWidth=sh->disp_w; | |
401 sh->bih->biHeight=sh->disp_h; | |
402 sh->bih->biPlanes=0; | |
403 sh->bih->biBitCount=16; | |
404 sh->bih->biCompression=trak->fourcc; | |
405 sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight; | |
406 | |
407 printf("Image size: %d x %d\n",sh->disp_w,sh->disp_h); | |
2115 | 408 printf("Fourcc: %.4s Codec: '%.*s'\n",&trak->fourcc,trak->stdata_len-43,trak->stdata+43); |
409 | |
2101 | 410 if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){ |
411 // (auto)selected video track: | |
412 demuxer->video->id=priv->track_db; | |
413 demuxer->video->sh=sh; sh->ds=demuxer->video; | |
414 } | |
2100 | 415 break; |
416 } | |
417 } | |
418 printf("--------------\n"); | |
419 priv->track_db++; | |
1490 | 420 trak=NULL; |
421 } else | |
422 if(id==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
|
423 mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVcomprhdr); |
1490 | 424 return; |
425 } | |
426 | |
427 pos+=len+8; | |
428 if(pos>=endpos) break; | |
429 if(!stream_seek(demuxer->stream,pos)) break; | |
430 } | |
431 } | |
432 | |
433 int mov_read_header(demuxer_t* demuxer){ | |
434 mov_priv_t* priv=demuxer->priv; | |
435 | |
2100 | 436 printf("mov_read_header!\n"); |
1490 | 437 |
438 // Parse header: | |
2100 | 439 stream_reset(demuxer->stream); |
1490 | 440 if(!stream_seek(demuxer->stream,priv->moov_start)) return 0; // ??? |
441 lschunks(demuxer, 0, priv->moov_end, NULL); | |
442 | |
2127 | 443 #if 1 |
444 return 1; | |
445 #else | |
1973
5216f108cb4f
all error/warn/info messages moved to help_mp-en.h for translation
arpi
parents:
1567
diff
changeset
|
446 mp_msg(MSGT_DEMUX,MSGL_ERR,MSGTR_MOVnotyetsupp); |
2127 | 447 return 0; |
448 #endif | |
1490 | 449 } |
2101 | 450 |
451 // return value: | |
452 // 0 = EOF or no stream found | |
453 // 1 = successfully read a packet | |
454 int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){ | |
455 mov_priv_t* priv=demuxer->priv; | |
456 mov_track_t* trak=NULL; | |
457 float pts; | |
458 | |
459 if(ds->id<0 || ds->id>=priv->track_db) return 0; | |
460 trak=priv->tracks[ds->id]; | |
461 | |
2115 | 462 if(trak->samplesize){ |
463 // read chunk: | |
464 if(trak->pos>=trak->chunks_size) return 0; // EOF | |
465 stream_seek(demuxer->stream,trak->chunks[trak->pos].pos); | |
466 pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale; | |
467 ds_read_packet(ds,demuxer->stream,trak->chunks[trak->pos].size*trak->samplesize,pts,trak->chunks[trak->pos].pos,0); | |
468 } else { | |
2101 | 469 // read sample: |
470 if(trak->pos>=trak->samples_size) return 0; // EOF | |
471 stream_seek(demuxer->stream,trak->samples[trak->pos].pos); | |
472 pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale; | |
473 ds_read_packet(ds,demuxer->stream,trak->samples[trak->pos].size,pts,trak->samples[trak->pos].pos,0); | |
2115 | 474 } |
2101 | 475 ++trak->pos; |
2115 | 476 |
2101 | 477 return 1; |
478 | |
479 } |