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