Mercurial > mplayer.hg
comparison libmpdemux/demuxer.c @ 2310:9e059416eea6
libdemuxer...
author | arpi |
---|---|
date | Sat, 20 Oct 2001 18:49:08 +0000 |
parents | demuxer.c@10b279d72a8f |
children | d0e1c32ad432 |
comparison
equal
deleted
inserted
replaced
2309:3128b9d8b4ea | 2310:9e059416eea6 |
---|---|
1 //=================== DEMUXER v2.5 ========================= | |
2 | |
3 #include <stdio.h> | |
4 #include <stdlib.h> | |
5 #include <unistd.h> | |
6 | |
7 #include <sys/types.h> | |
8 #include <sys/stat.h> | |
9 | |
10 #include "config.h" | |
11 #include "mp_msg.h" | |
12 #include "help_mp.h" | |
13 | |
14 #include "stream.h" | |
15 #include "demuxer.h" | |
16 | |
17 #include "wine/mmreg.h" | |
18 #include "wine/avifmt.h" | |
19 #include "wine/vfw.h" | |
20 | |
21 #include "codec-cfg.h" | |
22 #include "stheader.h" | |
23 | |
24 void free_demuxer_stream(demux_stream_t *ds){ | |
25 ds_free_packs(ds); | |
26 free(ds); | |
27 } | |
28 | |
29 demux_stream_t* new_demuxer_stream(struct demuxer_st *demuxer,int id){ | |
30 demux_stream_t* ds=malloc(sizeof(demux_stream_t)); | |
31 ds->buffer_pos=ds->buffer_size=0; | |
32 ds->buffer=NULL; | |
33 ds->pts=0; | |
34 ds->pts_bytes=0; | |
35 ds->eof=0; | |
36 ds->pos=0; | |
37 ds->dpos=0; | |
38 ds->pack_no=0; | |
39 //--------------- | |
40 ds->packs=0; | |
41 ds->bytes=0; | |
42 ds->first=ds->last=NULL; | |
43 ds->id=id; | |
44 ds->demuxer=demuxer; | |
45 //---------------- | |
46 ds->asf_seq=-1; | |
47 ds->asf_packet=NULL; | |
48 //---------------- | |
49 ds->sh=NULL; | |
50 return ds; | |
51 } | |
52 | |
53 demuxer_t* new_demuxer(stream_t *stream,int type,int a_id,int v_id,int s_id){ | |
54 demuxer_t *d=malloc(sizeof(demuxer_t)); | |
55 memset(d,0,sizeof(demuxer_t)); | |
56 d->stream=stream; | |
57 d->movi_start=stream->start_pos; | |
58 d->movi_end=stream->end_pos; | |
59 d->seekable=1; | |
60 d->synced=0; | |
61 d->filepos=0; | |
62 d->audio=new_demuxer_stream(d,a_id); | |
63 d->video=new_demuxer_stream(d,v_id); | |
64 d->sub=new_demuxer_stream(d,s_id); | |
65 d->type=type; | |
66 stream_reset(stream); | |
67 stream_seek(stream,stream->start_pos); | |
68 return d; | |
69 } | |
70 | |
71 sh_audio_t* new_sh_audio(demuxer_t *demuxer,int id){ | |
72 if(demuxer->a_streams[id]){ | |
73 mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_AudioStreamRedefined,id); | |
74 } else { | |
75 mp_msg(MSGT_DEMUXER,MSGL_V,"==> Found audio stream: %d\n",id); | |
76 demuxer->a_streams[id]=malloc(sizeof(sh_audio_t)); | |
77 memset(demuxer->a_streams[id],0,sizeof(sh_audio_t)); | |
78 } | |
79 return demuxer->a_streams[id]; | |
80 } | |
81 | |
82 void free_sh_audio(sh_audio_t* sh){ | |
83 if(sh->a_in_buffer) free(sh->a_in_buffer); | |
84 if(sh->a_buffer) free(sh->a_buffer); | |
85 if(sh->wf) free(sh->wf); | |
86 free(sh); | |
87 } | |
88 | |
89 sh_video_t* new_sh_video(demuxer_t *demuxer,int id){ | |
90 if(demuxer->v_streams[id]){ | |
91 mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_VideoStreamRedefined,id); | |
92 } else { | |
93 mp_msg(MSGT_DEMUXER,MSGL_V,"==> Found video stream: %d\n",id); | |
94 demuxer->v_streams[id]=malloc(sizeof(sh_video_t)); | |
95 memset(demuxer->v_streams[id],0,sizeof(sh_video_t)); | |
96 } | |
97 return demuxer->v_streams[id]; | |
98 } | |
99 | |
100 void free_sh_video(sh_video_t* sh){ | |
101 if(sh->our_out_buffer) free(sh->our_out_buffer); | |
102 if(sh->bih) free(sh->bih); | |
103 free(sh); | |
104 } | |
105 | |
106 void free_demuxer(demuxer_t *demuxer){ | |
107 int i; | |
108 // free streams: | |
109 for(i=0;i<256;i++){ | |
110 if(demuxer->a_streams[i]) free_sh_audio(demuxer->a_streams[i]); | |
111 if(demuxer->v_streams[i]) free_sh_video(demuxer->v_streams[i]); | |
112 } | |
113 //if(sh_audio) free_sh_audio(sh_audio); | |
114 //if(sh_video) free_sh_video(sh_video); | |
115 // free demuxers: | |
116 free_demuxer_stream(demuxer->audio); | |
117 free_demuxer_stream(demuxer->video); | |
118 free(demuxer); | |
119 } | |
120 | |
121 | |
122 void ds_add_packet(demux_stream_t *ds,demux_packet_t* dp){ | |
123 // demux_packet_t* dp=new_demux_packet(len); | |
124 // stream_read(stream,dp->buffer,len); | |
125 // dp->pts=pts; //(float)pts/90000.0f; | |
126 // dp->pos=pos; | |
127 // append packet to DS stream: | |
128 ++ds->packs; | |
129 ds->bytes+=dp->len; | |
130 if(ds->last){ | |
131 // next packet in stream | |
132 ds->last->next=dp; | |
133 ds->last=dp; | |
134 } else { | |
135 // first packet in stream | |
136 ds->first=ds->last=dp; | |
137 } | |
138 mp_dbg(MSGT_DEMUXER,MSGL_DBG2,"DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n", | |
139 (ds==ds->demuxer->audio)?"d_audio":"d_video", | |
140 dp->len,dp->pts,(unsigned int)dp->pos,ds->demuxer->audio->packs,ds->demuxer->video->packs); | |
141 } | |
142 | |
143 void ds_read_packet(demux_stream_t *ds,stream_t *stream,int len,float pts,off_t pos,int flags){ | |
144 demux_packet_t* dp=new_demux_packet(len); | |
145 stream_read(stream,dp->buffer,len); | |
146 dp->pts=pts; //(float)pts/90000.0f; | |
147 dp->pos=pos; | |
148 dp->flags=flags; | |
149 // append packet to DS stream: | |
150 ds_add_packet(ds,dp); | |
151 } | |
152 | |
153 // return value: | |
154 // 0 = EOF or no stream found or invalid type | |
155 // 1 = successfully read a packet | |
156 int demux_mpg_es_fill_buffer(demuxer_t *demux); | |
157 int demux_mpg_fill_buffer(demuxer_t *demux); | |
158 int demux_avi_fill_buffer(demuxer_t *demux); | |
159 int demux_avi_fill_buffer_ni(demuxer_t *demux,demux_stream_t *ds); | |
160 int demux_avi_fill_buffer_nini(demuxer_t *demux,demux_stream_t *ds); | |
161 int demux_asf_fill_buffer(demuxer_t *demux); | |
162 int demux_mov_fill_buffer(demuxer_t *demux,demux_stream_t* ds); | |
163 | |
164 int demux_fill_buffer(demuxer_t *demux,demux_stream_t *ds){ | |
165 // Note: parameter 'ds' can be NULL! | |
166 // printf("demux->type=%d\n",demux->type); | |
167 switch(demux->type){ | |
168 case DEMUXER_TYPE_MPEG_ES: return demux_mpg_es_fill_buffer(demux); | |
169 case DEMUXER_TYPE_MPEG_PS: return demux_mpg_fill_buffer(demux); | |
170 case DEMUXER_TYPE_AVI: return demux_avi_fill_buffer(demux); | |
171 case DEMUXER_TYPE_AVI_NI: return demux_avi_fill_buffer_ni(demux,ds); | |
172 case DEMUXER_TYPE_AVI_NINI: return demux_avi_fill_buffer_nini(demux,ds); | |
173 case DEMUXER_TYPE_ASF: return demux_asf_fill_buffer(demux); | |
174 case DEMUXER_TYPE_MOV: return demux_mov_fill_buffer(demux,ds); | |
175 } | |
176 return 0; | |
177 } | |
178 | |
179 // return value: | |
180 // 0 = EOF | |
181 // 1 = succesfull | |
182 int ds_fill_buffer(demux_stream_t *ds){ | |
183 demuxer_t *demux=ds->demuxer; | |
184 if(ds->buffer) free(ds->buffer); | |
185 if(verbose>2){ | |
186 if(ds==demux->audio) mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_audio) called\n");else | |
187 if(ds==demux->video) mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_video) called\n");else | |
188 mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(unknown 0x%X) called\n",(unsigned int)ds); | |
189 } | |
190 while(1){ | |
191 if(ds->packs){ | |
192 demux_packet_t *p=ds->first; | |
193 // copy useful data: | |
194 ds->buffer=p->buffer; | |
195 ds->buffer_pos=0; | |
196 ds->buffer_size=p->len; | |
197 ds->pos=p->pos; | |
198 ds->dpos+=p->len; // !!! | |
199 ++ds->pack_no; | |
200 if(p->pts){ | |
201 ds->pts=p->pts; | |
202 ds->pts_bytes=0; | |
203 } | |
204 ds->pts_bytes+=p->len; // !!! | |
205 ds->flags=p->flags; | |
206 // free packet: | |
207 ds->bytes-=p->len; | |
208 ds->first=p->next; | |
209 if(!ds->first) ds->last=NULL; | |
210 free(p); | |
211 --ds->packs; | |
212 return 1; //ds->buffer_size; | |
213 } | |
214 if(demux->audio->packs>=MAX_PACKS || demux->audio->bytes>=MAX_PACK_BYTES){ | |
215 mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyAudioInBuffer,demux->audio->packs,demux->audio->bytes); | |
216 mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI); | |
217 break; | |
218 } | |
219 if(demux->video->packs>=MAX_PACKS || demux->video->bytes>=MAX_PACK_BYTES){ | |
220 mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyVideoInBuffer,demux->video->packs,demux->video->bytes); | |
221 mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI); | |
222 break; | |
223 } | |
224 if(!demux_fill_buffer(demux,ds)){ | |
225 mp_dbg(MSGT_DEMUXER,MSGL_DBG2,"ds_fill_buffer()->demux_fill_buffer() failed\n"); | |
226 break; // EOF | |
227 } | |
228 } | |
229 ds->buffer_pos=ds->buffer_size=0; | |
230 ds->buffer=NULL; | |
231 mp_msg(MSGT_DEMUXER,MSGL_V,"ds_fill_buffer: EOF reached (stream: %s) \n",ds==demux->audio?"audio":"video"); | |
232 ds->eof=1; | |
233 return 0; | |
234 } | |
235 | |
236 int demux_read_data(demux_stream_t *ds,unsigned char* mem,int len){ | |
237 int x; | |
238 int bytes=0; | |
239 while(len>0){ | |
240 x=ds->buffer_size-ds->buffer_pos; | |
241 if(x==0){ | |
242 if(!ds_fill_buffer(ds)) return bytes; | |
243 } else { | |
244 if(x>len) x=len; | |
245 if(mem) memcpy(mem+bytes,&ds->buffer[ds->buffer_pos],x); | |
246 bytes+=x;len-=x;ds->buffer_pos+=x; | |
247 } | |
248 } | |
249 return bytes; | |
250 } | |
251 | |
252 int demux_read_data_pack(demux_stream_t *ds,unsigned char* mem,int len){ | |
253 int x; | |
254 int bytes=0; | |
255 while(len>0){ | |
256 x=ds->buffer_size-ds->buffer_pos; | |
257 if(x==0){ | |
258 if(!ds_fill_buffer(ds)) return bytes; | |
259 } else { | |
260 if(x>len) x=len; | |
261 if(mem) memcpy(mem+bytes,&ds->buffer[ds->buffer_pos],x); | |
262 bytes+=x;len-=x;ds->buffer_pos+=x; | |
263 return bytes; // stop at end of package! (for correct timestamping) | |
264 } | |
265 } | |
266 return bytes; | |
267 } | |
268 | |
269 | |
270 void ds_free_packs(demux_stream_t *ds){ | |
271 demux_packet_t *dp=ds->first; | |
272 while(dp){ | |
273 demux_packet_t *dn=dp->next; | |
274 free(dp->buffer); | |
275 free(dp); | |
276 dp=dn; | |
277 } | |
278 if(ds->asf_packet){ | |
279 // free unfinished .asf fragments: | |
280 free(ds->asf_packet->buffer); | |
281 free(ds->asf_packet); | |
282 ds->asf_packet=NULL; | |
283 } | |
284 ds->first=ds->last=NULL; | |
285 ds->packs=0; // !!!!! | |
286 ds->bytes=0; | |
287 if(ds->buffer) free(ds->buffer); | |
288 ds->buffer=NULL; | |
289 ds->buffer_pos=ds->buffer_size; | |
290 ds->pts=0; ds->pts_bytes=0; | |
291 } | |
292 | |
293 int ds_get_packet(demux_stream_t *ds,unsigned char **start){ | |
294 while(1){ | |
295 int len; | |
296 if(ds->buffer_pos>=ds->buffer_size){ | |
297 if(!ds_fill_buffer(ds)){ | |
298 // EOF | |
299 *start = NULL; | |
300 return -1; | |
301 } | |
302 } | |
303 len=ds->buffer_size-ds->buffer_pos; | |
304 *start = &ds->buffer[ds->buffer_pos]; | |
305 ds->buffer_pos+=len; | |
306 return len; | |
307 } | |
308 } | |
309 | |
310 int ds_get_packet_sub(demux_stream_t *ds,unsigned char **start){ | |
311 while(1){ | |
312 int len; | |
313 if(ds->buffer_pos>=ds->buffer_size){ | |
314 *start = NULL; | |
315 if(!ds->packs) return -1; // no sub | |
316 if(!ds_fill_buffer(ds)) return -1; // EOF | |
317 } | |
318 len=ds->buffer_size-ds->buffer_pos; | |
319 *start = &ds->buffer[ds->buffer_pos]; | |
320 ds->buffer_pos+=len; | |
321 return len; | |
322 } | |
323 } | |
324 | |
325 // ==================================================================== | |
326 | |
327 // feed-back from demuxers: | |
328 extern int num_elementary_packets100; // for MPEG-ES fileformat detection | |
329 extern int num_elementary_packets101; | |
330 extern int num_elementary_packetsPES; | |
331 extern int num_elementary_packets1B6; | |
332 | |
333 // commandline options, flags: | |
334 //extern int seek_to_byte; | |
335 extern int force_ni; | |
336 extern int pts_from_bps; | |
337 | |
338 extern int audio_id; | |
339 extern int video_id; | |
340 extern int dvdsub_id; | |
341 | |
342 void read_avi_header(demuxer_t *demuxer,int index_mode); | |
343 int asf_check_header(demuxer_t *demuxer); | |
344 int read_asf_header(demuxer_t *demuxer); | |
345 demux_stream_t* demux_avi_select_stream(demuxer_t *demux,unsigned int id); | |
346 demuxer_t* demux_open_avi(demuxer_t* demuxer); | |
347 int mov_check_file(demuxer_t* demuxer); | |
348 int mov_read_header(demuxer_t* demuxer); | |
349 | |
350 | |
351 demuxer_t* demux_open(stream_t *stream,int file_format,int audio_id,int video_id,int dvdsub_id){ | |
352 | |
353 //int file_format=(*file_format_ptr); | |
354 | |
355 demuxer_t *demuxer=NULL; | |
356 | |
357 demux_stream_t *d_audio=NULL; | |
358 demux_stream_t *d_video=NULL; | |
359 | |
360 sh_audio_t *sh_audio=NULL; | |
361 sh_video_t *sh_video=NULL; | |
362 | |
363 //printf("demux_open(%p,%d,%d,%d,%d) \n",stream,file_format,audio_id,video_id,dvdsub_id); | |
364 | |
365 //=============== Try to open as AVI file: ================= | |
366 if(file_format==DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_AVI){ | |
367 demuxer=new_demuxer(stream,DEMUXER_TYPE_AVI,audio_id,video_id,dvdsub_id); | |
368 { //---- RIFF header: | |
369 int id=stream_read_dword_le(demuxer->stream); // "RIFF" | |
370 if(id==mmioFOURCC('R','I','F','F')){ | |
371 stream_read_dword_le(demuxer->stream); //filesize | |
372 id=stream_read_dword_le(demuxer->stream); // "AVI " | |
373 if(id==formtypeAVI){ | |
374 mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_DetectedAVIfile); | |
375 file_format=DEMUXER_TYPE_AVI; | |
376 } | |
377 } | |
378 } | |
379 } | |
380 //=============== Try to open as ASF file: ================= | |
381 if(file_format==DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_ASF){ | |
382 demuxer=new_demuxer(stream,DEMUXER_TYPE_ASF,audio_id,video_id,dvdsub_id); | |
383 if(asf_check_header(demuxer)){ | |
384 mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_DetectedASFfile); | |
385 file_format=DEMUXER_TYPE_ASF; | |
386 } | |
387 } | |
388 //=============== Try to open as MPEG-PS file: ================= | |
389 if(file_format==DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_MPEG_PS){ | |
390 int pes=1; | |
391 while(pes>=0){ | |
392 demuxer=new_demuxer(stream,DEMUXER_TYPE_MPEG_PS,audio_id,video_id,dvdsub_id); | |
393 if(!pes) demuxer->synced=1; // hack! | |
394 num_elementary_packets100=0; | |
395 num_elementary_packets101=0; | |
396 num_elementary_packets1B6=0; | |
397 num_elementary_packetsPES=0; | |
398 | |
399 if(ds_fill_buffer(demuxer->video)){ | |
400 if(!pes) | |
401 mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_DetectedMPEGPESfile); | |
402 else | |
403 mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_DetectedMPEGPSfile); | |
404 file_format=DEMUXER_TYPE_MPEG_PS; | |
405 } else { | |
406 // some hack to get meaningfull error messages to our unhappy users: | |
407 if(num_elementary_packets100>=2 && num_elementary_packets101>=2 && | |
408 abs(num_elementary_packets101-num_elementary_packets100)<8){ | |
409 if(num_elementary_packetsPES>=4 && num_elementary_packetsPES>=num_elementary_packets100-4){ | |
410 --pes;continue; // tricky... | |
411 } | |
412 file_format=DEMUXER_TYPE_MPEG_ES; // <-- hack is here :) | |
413 } else { | |
414 if(demuxer->synced==2) | |
415 mp_msg(MSGT_DEMUXER,MSGL_ERR,"MPEG: " MSGTR_MissingVideoStreamBug); | |
416 else | |
417 mp_msg(MSGT_DEMUXER,MSGL_V,"Not MPEG System Stream format... (maybe Transport Stream?)\n"); | |
418 } | |
419 } | |
420 break; | |
421 } | |
422 } | |
423 //=============== Try to open as MPEG-ES file: ================= | |
424 if(file_format==DEMUXER_TYPE_MPEG_ES){ // little hack, see above! | |
425 demuxer=new_demuxer(stream,DEMUXER_TYPE_MPEG_ES,audio_id,video_id,dvdsub_id); | |
426 if(!ds_fill_buffer(demuxer->video)){ | |
427 mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_InvalidMPEGES); | |
428 file_format=DEMUXER_TYPE_UNKNOWN; | |
429 } else { | |
430 mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_DetectedMPEGESfile); | |
431 } | |
432 } | |
433 //=============== Try to open as MOV file: ================= | |
434 #if 1 | |
435 if(file_format==DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_MOV){ | |
436 demuxer=new_demuxer(stream,DEMUXER_TYPE_MOV,audio_id,video_id,dvdsub_id); | |
437 if(mov_check_file(demuxer)){ | |
438 mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_DetectedQTMOVfile); | |
439 file_format=DEMUXER_TYPE_MOV; | |
440 } | |
441 } | |
442 #endif | |
443 //=============== Unknown, exiting... =========================== | |
444 if(file_format==DEMUXER_TYPE_UNKNOWN){ | |
445 mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_FormatNotRecognized); | |
446 return NULL; | |
447 // GUI_MSG( mplUnknowFileType ) | |
448 } | |
449 //====== File format recognized, set up these for compatibility: ========= | |
450 d_audio=demuxer->audio; | |
451 d_video=demuxer->video; | |
452 //d_dvdsub=demuxer->sub; | |
453 | |
454 demuxer->file_format=file_format; | |
455 | |
456 switch(file_format){ | |
457 case DEMUXER_TYPE_MOV: { | |
458 if(!mov_read_header(demuxer)) return NULL; | |
459 // sh_video=d_video->sh;if(sh_video) sh_video->ds=d_video; | |
460 // sh_audio=d_audio->sh;if(sh_audio) sh_audio->ds=d_audio; | |
461 break; | |
462 } | |
463 case DEMUXER_TYPE_AVI: { | |
464 return (demuxer_t*) demux_open_avi(demuxer); | |
465 // break; | |
466 } | |
467 case DEMUXER_TYPE_ASF: { | |
468 //---- ASF header: | |
469 read_asf_header(demuxer); | |
470 stream_reset(demuxer->stream); | |
471 stream_seek(demuxer->stream,demuxer->movi_start); | |
472 // demuxer->idx_pos=0; | |
473 // demuxer->endpos=avi_header.movi_end; | |
474 if(!ds_fill_buffer(d_video)){ | |
475 mp_msg(MSGT_DEMUXER,MSGL_WARN,"ASF: " MSGTR_MissingVideoStream); | |
476 sh_video=NULL; | |
477 //printf("ASF: missing video stream!? contact the author, it may be a bug :(\n"); | |
478 //GUI_MSG( mplASFErrorMissingVideoStream ) | |
479 } else { | |
480 sh_video=d_video->sh;sh_video->ds=d_video; | |
481 sh_video->fps=1000.0f; sh_video->frametime=0.001f; // 1ms | |
482 mp_msg(MSGT_DEMUXER,MSGL_INFO,"VIDEO: [%.4s] %ldx%ld %dbpp\n", | |
483 (char *)&sh_video->bih->biCompression, | |
484 sh_video->bih->biWidth, | |
485 sh_video->bih->biHeight, | |
486 sh_video->bih->biBitCount); | |
487 // sh_video->i_bps=10*asf_packetsize; // FIXME! | |
488 } | |
489 if(audio_id!=-2){ | |
490 mp_msg(MSGT_DEMUXER,MSGL_V,"ASF: Searching for audio stream (id:%d)\n",d_audio->id); | |
491 if(!ds_fill_buffer(d_audio)){ | |
492 mp_msg(MSGT_DEMUXER,MSGL_INFO,"ASF: " MSGTR_MissingAudioStream); | |
493 sh_audio=NULL; | |
494 } else { | |
495 sh_audio=d_audio->sh;sh_audio->ds=d_audio; | |
496 sh_audio->format=sh_audio->wf->wFormatTag; | |
497 } | |
498 } | |
499 break; | |
500 } | |
501 case DEMUXER_TYPE_MPEG_ES: { | |
502 sh_audio=NULL; // ES streams has no audio channel | |
503 d_video->sh=new_sh_video(demuxer,0); // create dummy video stream header, id=0 | |
504 sh_video=d_video->sh;sh_video->ds=d_video; | |
505 break; | |
506 } | |
507 case DEMUXER_TYPE_MPEG_PS: { | |
508 sh_video=d_video->sh;sh_video->ds=d_video; | |
509 if(demuxer->stream->type!=STREAMTYPE_VCD) demuxer->movi_start=0; // for VCD | |
510 | |
511 if(audio_id!=-2) { | |
512 if(!ds_fill_buffer(d_audio)){ | |
513 mp_msg(MSGT_DEMUXER,MSGL_INFO,"MPEG: " MSGTR_MissingAudioStream); | |
514 sh_audio=NULL; | |
515 } else { | |
516 sh_audio=d_audio->sh;sh_audio->ds=d_audio; | |
517 switch(d_audio->id & 0xE0){ // 1110 0000 b (high 3 bit: type low 5: id) | |
518 case 0x00: sh_audio->format=0x50;break; // mpeg | |
519 case 0xA0: sh_audio->format=0x10001;break; // dvd pcm | |
520 case 0x80: sh_audio->format=0x2000;break; // ac3 | |
521 default: sh_audio=NULL; // unknown type | |
522 } | |
523 } | |
524 } | |
525 break; | |
526 } | |
527 } // switch(file_format) | |
528 | |
529 return demuxer; | |
530 } | |
531 | |
532 int demux_seek_avi(demuxer_t *demuxer,float rel_seek_secs,int flags); | |
533 int demux_seek_asf(demuxer_t *demuxer,float rel_seek_secs,int flags); | |
534 int demux_seek_mpg(demuxer_t *demuxer,float rel_seek_secs,int flags); | |
535 void demux_seek_mov(demuxer_t *demuxer,float pts,int flags); | |
536 | |
537 int demux_seek(demuxer_t *demuxer,float rel_seek_secs,int flags){ | |
538 demux_stream_t *d_audio=demuxer->audio; | |
539 demux_stream_t *d_video=demuxer->video; | |
540 sh_audio_t *sh_audio=d_audio->sh; | |
541 sh_video_t *sh_video=d_video->sh; | |
542 | |
543 if(!demuxer->seekable){ | |
544 if(demuxer->file_format==DEMUXER_TYPE_AVI) | |
545 mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CantSeekRawAVI); | |
546 else | |
547 mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CantSeekFile); | |
548 return 0; | |
549 } | |
550 | |
551 // clear demux buffers: | |
552 if(sh_audio){ ds_free_packs(d_audio);sh_audio->a_buffer_len=0;} | |
553 ds_free_packs(d_video); | |
554 | |
555 demuxer->stream->eof=0; // clear eof flag | |
556 | |
557 if(sh_audio) sh_audio->timer=0; | |
558 sh_video->timer=0; // !!!!!! | |
559 | |
560 switch(demuxer->file_format){ | |
561 | |
562 case DEMUXER_TYPE_AVI: | |
563 demux_seek_avi(demuxer,rel_seek_secs,flags); break; | |
564 | |
565 case DEMUXER_TYPE_ASF: | |
566 demux_seek_asf(demuxer,rel_seek_secs,flags); break; | |
567 | |
568 case DEMUXER_TYPE_MPEG_ES: | |
569 case DEMUXER_TYPE_MPEG_PS: | |
570 demux_seek_mpg(demuxer,rel_seek_secs,flags); break; | |
571 | |
572 case DEMUXER_TYPE_MOV: | |
573 demux_seek_mov(demuxer,rel_seek_secs,flags); break; | |
574 | |
575 } // switch(demuxer->file_format) | |
576 | |
577 return 1; | |
578 } | |
579 | |
580 |