1 //=================== DEMUXER v2.5 =========================
16 #include "libvo/fastmemcpy.h"
23 #include "libaf/af_format.h"
25 extern void resync_video_stream(sh_video_t
*sh_video
);
26 extern void resync_audio_stream(sh_audio_t
*sh_audio
);
29 extern demuxer_desc_t demuxer_desc_rawaudio
;
30 extern demuxer_desc_t demuxer_desc_rawvideo
;
31 extern demuxer_desc_t demuxer_desc_tv
;
32 extern demuxer_desc_t demuxer_desc_mf
;
33 extern demuxer_desc_t demuxer_desc_avi
;
34 extern demuxer_desc_t demuxer_desc_y4m
;
35 extern demuxer_desc_t demuxer_desc_asf
;
36 extern demuxer_desc_t demuxer_desc_nuv
;
37 extern demuxer_desc_t demuxer_desc_real
;
38 extern demuxer_desc_t demuxer_desc_smjpeg
;
39 extern demuxer_desc_t demuxer_desc_matroska
;
40 extern demuxer_desc_t demuxer_desc_realaudio
;
41 extern demuxer_desc_t demuxer_desc_vqf
;
42 extern demuxer_desc_t demuxer_desc_mov
;
43 extern demuxer_desc_t demuxer_desc_vivo
;
44 extern demuxer_desc_t demuxer_desc_fli
;
45 extern demuxer_desc_t demuxer_desc_film
;
46 extern demuxer_desc_t demuxer_desc_roq
;
47 extern demuxer_desc_t demuxer_desc_gif
;
48 extern demuxer_desc_t demuxer_desc_ogg
;
49 extern demuxer_desc_t demuxer_desc_avs
;
50 extern demuxer_desc_t demuxer_desc_pva
;
51 extern demuxer_desc_t demuxer_desc_nsv
;
52 extern demuxer_desc_t demuxer_desc_mpeg_ts
;
53 extern demuxer_desc_t demuxer_desc_lmlm4
;
54 extern demuxer_desc_t demuxer_desc_mpeg_ps
;
55 extern demuxer_desc_t demuxer_desc_mpeg_pes
;
56 extern demuxer_desc_t demuxer_desc_mpeg_es
;
57 extern demuxer_desc_t demuxer_desc_mpeg_gxf
;
58 extern demuxer_desc_t demuxer_desc_mpeg4_es
;
59 extern demuxer_desc_t demuxer_desc_h264_es
;
60 extern demuxer_desc_t demuxer_desc_rawdv
;
61 extern demuxer_desc_t demuxer_desc_mpc
;
62 extern demuxer_desc_t demuxer_desc_audio
;
63 extern demuxer_desc_t demuxer_desc_xmms
;
64 extern demuxer_desc_t demuxer_desc_mpeg_ty
;
65 extern demuxer_desc_t demuxer_desc_rtp
;
66 extern demuxer_desc_t demuxer_desc_lavf
;
67 extern demuxer_desc_t demuxer_desc_aac
;
68 extern demuxer_desc_t demuxer_desc_nut
;
70 demuxer_desc_t
* demuxer_list
[] = {
71 &demuxer_desc_rawaudio
,
72 &demuxer_desc_rawvideo
,
84 &demuxer_desc_matroska
,
85 &demuxer_desc_realaudio
,
102 &demuxer_desc_mpeg_ts
,
104 &demuxer_desc_mpeg_ps
,
105 &demuxer_desc_mpeg_pes
,
106 &demuxer_desc_mpeg_es
,
107 &demuxer_desc_mpeg_gxf
,
108 &demuxer_desc_mpeg4_es
,
109 &demuxer_desc_h264_es
,
114 &demuxer_desc_mpeg_ty
,
115 #ifdef STREAMING_LIVE555
118 #if defined(USE_LIBAVFORMAT) || defined(USE_LIBAVFORMAT_SO)
134 void free_demuxer_stream(demux_stream_t
*ds
){
139 demux_stream_t
* new_demuxer_stream(struct demuxer_st
*demuxer
,int id
){
140 demux_stream_t
* ds
=malloc(sizeof(demux_stream_t
));
141 ds
->buffer_pos
=ds
->buffer_size
=0;
152 ds
->first
=ds
->last
=ds
->current
=NULL
;
159 ds
->ss_mul
=ds
->ss_div
=0;
167 * Get demuxer description structure for a given demuxer type
169 * @param file_format type of the demuxer
170 * @return structure for the demuxer, NULL if not found
172 static demuxer_desc_t
* get_demuxer_desc_from_type(int file_format
)
176 for (i
= 0; demuxer_list
[i
]; i
++)
177 if (file_format
== demuxer_list
[i
]->type
)
178 return demuxer_list
[i
];
184 demuxer_t
* new_demuxer(stream_t
*stream
,int type
,int a_id
,int v_id
,int s_id
,char *filename
){
185 demuxer_t
*d
=malloc(sizeof(demuxer_t
));
186 memset(d
,0,sizeof(demuxer_t
));
188 d
->stream_pts
= MP_NOPTS_VALUE
;
189 d
->movi_start
=stream
->start_pos
;
190 d
->movi_end
=stream
->end_pos
;
194 d
->audio
=new_demuxer_stream(d
,a_id
);
195 d
->video
=new_demuxer_stream(d
,v_id
);
196 d
->sub
=new_demuxer_stream(d
,s_id
);
199 if (!(d
->desc
= get_demuxer_desc_from_type(type
)))
200 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,"BUG! Invalid demuxer type in new_demuxer(), big troubles ahead.");
201 if(filename
) // Filename hack for avs_check_file
202 d
->filename
=strdup(filename
);
203 stream_reset(stream
);
204 stream_seek(stream
,stream
->start_pos
);
208 sh_sub_t
*new_sh_sub_sid(demuxer_t
*demuxer
, int id
, int sid
) {
209 if (id
> MAX_S_STREAMS
- 1 || id
< 0) {
210 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,"Requested sub stream id overflow (%d > %d)\n",
214 if (demuxer
->s_streams
[id
])
215 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, "Sub stream %i redefined\n", id
);
217 sh_sub_t
*sh
= calloc(1, sizeof(sh_sub_t
));
218 demuxer
->s_streams
[id
] = sh
;
220 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SUBTITLE_ID=%d\n", sid
);
222 return demuxer
->s_streams
[id
];
225 sh_audio_t
* new_sh_audio_aid(demuxer_t
*demuxer
,int id
,int aid
){
226 if(id
> MAX_A_STREAMS
-1 || id
< 0)
228 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,"Requested audio stream id overflow (%d > %d)\n",
232 if(demuxer
->a_streams
[id
]){
233 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,MSGTR_AudioStreamRedefined
,id
);
236 mp_msg(MSGT_DEMUXER
,MSGL_V
,MSGTR_FoundAudioStream
,id
);
237 demuxer
->a_streams
[id
]=calloc(1, sizeof(sh_audio_t
));
238 sh
= demuxer
->a_streams
[id
];
241 sh
->sample_format
=AF_FORMAT_S16_NE
;
242 sh
->audio_out_minsize
=8192;/* default size, maybe not enough for Win32/ACM*/
243 sh
->pts
=MP_NOPTS_VALUE
;
244 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AUDIO_ID=%d\n", aid
);
246 ((sh_audio_t
*)demuxer
->a_streams
[id
])->aid
= aid
;
247 return demuxer
->a_streams
[id
];
250 void free_sh_audio(demuxer_t
*demuxer
, int id
) {
251 sh_audio_t
*sh
= demuxer
->a_streams
[id
];
252 demuxer
->a_streams
[id
] = NULL
;
253 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
,"DEMUXER: freeing sh_audio at %p\n",sh
);
254 if(sh
->wf
) free(sh
->wf
);
258 sh_video_t
* new_sh_video_vid(demuxer_t
*demuxer
,int id
,int vid
){
259 if(id
> MAX_V_STREAMS
-1 || id
< 0)
261 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,"Requested video stream id overflow (%d > %d)\n",
265 if(demuxer
->v_streams
[id
]){
266 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,MSGTR_VideoStreamRedefined
,id
);
268 mp_msg(MSGT_DEMUXER
,MSGL_V
,MSGTR_FoundVideoStream
,id
);
269 demuxer
->v_streams
[id
]=calloc(1, sizeof(sh_video_t
));
270 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VIDEO_ID=%d\n", vid
);
272 ((sh_video_t
*)demuxer
->v_streams
[id
])->vid
= vid
;
273 return demuxer
->v_streams
[id
];
276 void free_sh_video(sh_video_t
* sh
){
277 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
,"DEMUXER: freeing sh_video at %p\n",sh
);
278 if(sh
->bih
) free(sh
->bih
);
282 void free_demuxer(demuxer_t
*demuxer
){
284 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
,"DEMUXER: freeing demuxer at %p\n",demuxer
);
285 if(demuxer
->desc
->close
)
286 demuxer
->desc
->close(demuxer
);
287 // Very ugly hack to make it behave like old implementation
288 if (demuxer
->desc
->type
== DEMUXER_TYPE_DEMUXERS
)
289 goto skip_streamfree
;
291 for(i
= 0; i
< MAX_A_STREAMS
; i
++)
292 if(demuxer
->a_streams
[i
]) free_sh_audio(demuxer
, i
);
293 for(i
= 0; i
< MAX_V_STREAMS
; i
++)
294 if(demuxer
->v_streams
[i
]) free_sh_video(demuxer
->v_streams
[i
]);
296 free_demuxer_stream(demuxer
->audio
);
297 free_demuxer_stream(demuxer
->video
);
298 free_demuxer_stream(demuxer
->sub
);
301 for(i
=0;demuxer
->info
[i
] != NULL
; i
++)
302 free(demuxer
->info
[i
]);
305 if(demuxer
->filename
)
306 free(demuxer
->filename
);
307 if (demuxer
->chapters
) {
308 for (i
=0; i
<demuxer
->num_chapters
; i
++)
309 if (demuxer
->chapters
[i
].name
)
310 free(demuxer
->chapters
[i
].name
);
311 free(demuxer
->chapters
);
317 void ds_add_packet(demux_stream_t
*ds
,demux_packet_t
* dp
){
318 // demux_packet_t* dp=new_demux_packet(len);
319 // stream_read(stream,dp->buffer,len);
320 // dp->pts=pts; //(float)pts/90000.0f;
322 // append packet to DS stream:
326 // next packet in stream
330 // first packet in stream
331 ds
->first
=ds
->last
=dp
;
333 mp_dbg(MSGT_DEMUXER
,MSGL_DBG2
,"DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n",
334 (ds
==ds
->demuxer
->audio
)?"d_audio":"d_video",
335 dp
->len
,dp
->pts
,(unsigned int)dp
->pos
,ds
->demuxer
->audio
->packs
,ds
->demuxer
->video
->packs
);
338 void ds_read_packet(demux_stream_t
*ds
, stream_t
*stream
, int len
, double pts
, off_t pos
, int flags
) {
339 demux_packet_t
* dp
=new_demux_packet(len
);
340 len
= stream_read(stream
,dp
->buffer
,len
);
341 resize_demux_packet(dp
, len
);
342 dp
->pts
=pts
; //(float)pts/90000.0f;
345 // append packet to DS stream:
346 ds_add_packet(ds
,dp
);
350 // 0 = EOF or no stream found or invalid type
351 // 1 = successfully read a packet
353 int demux_fill_buffer(demuxer_t
*demux
,demux_stream_t
*ds
){
354 // Note: parameter 'ds' can be NULL!
355 // printf("demux->type=%d\n",demux->type);
356 return demux
->desc
->fill_buffer(demux
, ds
);
362 int ds_fill_buffer(demux_stream_t
*ds
){
363 demuxer_t
*demux
=ds
->demuxer
;
364 if(ds
->current
) free_demux_packet(ds
->current
);
365 if( mp_msg_test(MSGT_DEMUXER
,MSGL_DBG3
) ){
366 if(ds
==demux
->audio
) mp_dbg(MSGT_DEMUXER
,MSGL_DBG3
,"ds_fill_buffer(d_audio) called\n");else
367 if(ds
==demux
->video
) mp_dbg(MSGT_DEMUXER
,MSGL_DBG3
,"ds_fill_buffer(d_video) called\n");else
368 if(ds
==demux
->sub
) mp_dbg(MSGT_DEMUXER
,MSGL_DBG3
,"ds_fill_buffer(d_sub) called\n");else
369 mp_dbg(MSGT_DEMUXER
,MSGL_DBG3
,"ds_fill_buffer(unknown 0x%X) called\n",(unsigned int)ds
);
373 demux_packet_t
*p
=ds
->first
;
375 ds
->buffer
=p
->buffer
;
377 ds
->buffer_size
=p
->len
;
379 ds
->dpos
+=p
->len
; // !!!
381 if (p
->pts
!= (correct_pts
? MP_NOPTS_VALUE
: 0)) {
385 ds
->pts_bytes
+=p
->len
; // !!!
386 if(p
->stream_pts
!= MP_NOPTS_VALUE
) demux
->stream_pts
=p
->stream_pts
;
392 if(!ds
->first
) ds
->last
=NULL
;
394 return 1; //ds->buffer_size;
396 if(demux
->audio
->packs
>=MAX_PACKS
|| demux
->audio
->bytes
>=MAX_PACK_BYTES
){
397 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,MSGTR_TooManyAudioInBuffer
,demux
->audio
->packs
,demux
->audio
->bytes
);
398 mp_msg(MSGT_DEMUXER
,MSGL_HINT
,MSGTR_MaybeNI
);
401 if(demux
->video
->packs
>=MAX_PACKS
|| demux
->video
->bytes
>=MAX_PACK_BYTES
){
402 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,MSGTR_TooManyVideoInBuffer
,demux
->video
->packs
,demux
->video
->bytes
);
403 mp_msg(MSGT_DEMUXER
,MSGL_HINT
,MSGTR_MaybeNI
);
406 if(!demux_fill_buffer(demux
,ds
)){
407 mp_dbg(MSGT_DEMUXER
,MSGL_DBG2
,"ds_fill_buffer()->demux_fill_buffer() failed\n");
411 ds
->buffer_pos
=ds
->buffer_size
=0;
414 mp_msg(MSGT_DEMUXER
,MSGL_V
,"ds_fill_buffer: EOF reached (stream: %s) \n",ds
==demux
->audio
?"audio":"video");
419 int demux_read_data(demux_stream_t
*ds
,unsigned char* mem
,int len
){
423 x
=ds
->buffer_size
-ds
->buffer_pos
;
425 if(!ds_fill_buffer(ds
)) return bytes
;
428 if(mem
) memcpy(mem
+bytes
,&ds
->buffer
[ds
->buffer_pos
],x
);
429 bytes
+=x
;len
-=x
;ds
->buffer_pos
+=x
;
435 int demux_read_data_pack(demux_stream_t
*ds
,unsigned char* mem
,int len
){
439 x
=ds
->buffer_size
-ds
->buffer_pos
;
441 if(!ds_fill_buffer(ds
)) return bytes
;
444 if(mem
) memcpy(mem
+bytes
,&ds
->buffer
[ds
->buffer_pos
],x
);
445 bytes
+=x
;len
-=x
;ds
->buffer_pos
+=x
;
446 return bytes
; // stop at end of package! (for correct timestamping)
453 * \brief read data until the given 3-byte pattern is encountered, up to maxlen
454 * \param mem memory to read data into, may be NULL to discard data
455 * \param maxlen maximum number of bytes to read
456 * \param read number of bytes actually read
457 * \param pattern pattern to search for (lowest 8 bits are ignored)
458 * \return whether pattern was found
460 int demux_pattern_3(demux_stream_t
*ds
, unsigned char *mem
, int maxlen
,
461 int *read
, uint32_t pattern
) {
462 register uint32_t head
= 0xffffff00;
463 register uint32_t pat
= pattern
& 0xffffff00;
466 register unsigned char *ds_buf
= &ds
->buffer
[ds
->buffer_size
];
467 int len
= ds
->buffer_size
- ds
->buffer_pos
;
468 register long pos
= -len
;
469 if (unlikely(pos
>= 0)) { // buffer is empty
476 } while (++pos
&& head
!= pat
);
478 if (total_len
+ len
> maxlen
)
479 len
= maxlen
- total_len
;
480 len
= demux_read_data(ds
, mem
? &mem
[total_len
] : NULL
, len
);
482 } while ((head
!= pat
|| total_len
< 3) && total_len
< maxlen
&& !ds
->eof
);
485 return total_len
>= 3 && head
== pat
;
488 void ds_free_packs(demux_stream_t
*ds
){
489 demux_packet_t
*dp
=ds
->first
;
491 demux_packet_t
*dn
=dp
->next
;
492 free_demux_packet(dp
);
496 // free unfinished .asf fragments:
497 free(ds
->asf_packet
->buffer
);
498 free(ds
->asf_packet
);
501 ds
->first
=ds
->last
=NULL
;
502 ds
->packs
=0; // !!!!!
504 if(ds
->current
) free_demux_packet(ds
->current
);
507 ds
->buffer_pos
=ds
->buffer_size
;
508 ds
->pts
=0; ds
->pts_bytes
=0;
511 int ds_get_packet(demux_stream_t
*ds
,unsigned char **start
){
514 if(ds
->buffer_pos
>=ds
->buffer_size
){
515 if(!ds_fill_buffer(ds
)){
521 len
=ds
->buffer_size
-ds
->buffer_pos
;
522 *start
= &ds
->buffer
[ds
->buffer_pos
];
528 int ds_get_packet_pts(demux_stream_t
*ds
,unsigned char **start
, double *pts
)
531 *pts
= MP_NOPTS_VALUE
;
532 if(ds
->buffer_pos
>=ds
->buffer_size
){
533 if (!ds_fill_buffer(ds
)) {
539 // Should use MP_NOPTS_VALUE for "unknown pts" in the packets too
540 // Return pts unless this read starts from the middle of a packet
541 if (!ds
->buffer_pos
&& (correct_pts
|| ds
->current
->pts
))
542 *pts
= ds
->current
->pts
;
543 len
=ds
->buffer_size
-ds
->buffer_pos
;
544 *start
= &ds
->buffer
[ds
->buffer_pos
];
549 int ds_get_packet_sub(demux_stream_t
*ds
,unsigned char **start
){
552 if(ds
->buffer_pos
>=ds
->buffer_size
){
554 if(!ds
->packs
) return -1; // no sub
555 if(!ds_fill_buffer(ds
)) return -1; // EOF
557 len
=ds
->buffer_size
-ds
->buffer_pos
;
558 *start
= &ds
->buffer
[ds
->buffer_pos
];
564 double ds_get_next_pts(demux_stream_t
*ds
)
566 demuxer_t
* demux
= ds
->demuxer
;
568 if(demux
->audio
->packs
>=MAX_PACKS
|| demux
->audio
->bytes
>=MAX_PACK_BYTES
){
569 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,MSGTR_TooManyAudioInBuffer
,demux
->audio
->packs
,demux
->audio
->bytes
);
570 mp_msg(MSGT_DEMUXER
,MSGL_HINT
,MSGTR_MaybeNI
);
571 return MP_NOPTS_VALUE
;
573 if(demux
->video
->packs
>=MAX_PACKS
|| demux
->video
->bytes
>=MAX_PACK_BYTES
){
574 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,MSGTR_TooManyVideoInBuffer
,demux
->video
->packs
,demux
->video
->bytes
);
575 mp_msg(MSGT_DEMUXER
,MSGL_HINT
,MSGTR_MaybeNI
);
576 return MP_NOPTS_VALUE
;
578 if(!demux_fill_buffer(demux
,ds
))
579 return MP_NOPTS_VALUE
;
581 return ds
->first
->pts
;
584 // ====================================================================
586 // commandline options, flags:
588 extern int pts_from_bps
;
590 //extern int audio_id;
591 //extern int video_id;
592 //extern int dvdsub_id;
594 void demuxer_help(void)
598 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "Available demuxers:\n");
599 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " demuxer: type info: (comment)\n");
600 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_DEMUXERS\n");
601 for (i
= 0; demuxer_list
[i
]; i
++) {
602 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Don't display special demuxers
604 if (demuxer_list
[i
]->comment
&& strlen(demuxer_list
[i
]->comment
))
605 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s (%s)\n",
606 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
, demuxer_list
[i
]->info
, demuxer_list
[i
]->comment
);
608 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s\n",
609 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
, demuxer_list
[i
]->info
);
615 * Get demuxer type for a given demuxer name
617 * @param demuxer_name string with demuxer name of demuxer number
618 * @param force will be set if demuxer should be forced.
620 * @return DEMUXER_TYPE_xxx, -1 if error or not found
622 int get_demuxer_type_from_name(char *demuxer_name
, int *force
)
628 if (!demuxer_name
|| !demuxer_name
[0])
629 return DEMUXER_TYPE_UNKNOWN
;
630 if (force
) *force
= demuxer_name
[0] == '+';
631 if (demuxer_name
[0] == '+')
632 demuxer_name
= &demuxer_name
[1];
633 for (i
= 0; demuxer_list
[i
]; i
++) {
634 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Can't select special demuxers from commandline
636 if (strcmp(demuxer_name
, demuxer_list
[i
]->name
) == 0)
637 return demuxer_list
[i
]->type
;
640 // No match found, try to parse name as an integer (demuxer number)
641 type_int
= strtol(demuxer_name
, &endptr
, 0);
642 if (*endptr
) // Conversion failed
644 if ((type_int
> 0) && (type_int
<= DEMUXER_TYPE_MAX
))
645 return (int)type_int
;
650 int extension_parsing
=1; // 0=off 1=mixed (used only for unstable formats)
655 NOTE : Several demuxers may be opened at the same time so
656 demuxers should NEVER rely on an external var to enable them
657 self. If a demuxer can't do any autodection it should only use
658 file_format. The user can explictly set file_format with the -demuxer
659 option so there is really no need for another extra var.
660 For conivence an option can be added to set file_format directly
661 to the right type (ex: rawaudio,rawvideo).
662 Also the stream can override the file_format so a demuxer wich rely
663 on a special stream type can set file_format at the stream level
667 static demuxer_t
* demux_open_stream(stream_t
*stream
, int file_format
,
668 int force
, int audio_id
, int video_id
, int dvdsub_id
,
671 //int file_format=(*file_format_ptr);
673 demuxer_t
*demuxer
=NULL
;
675 sh_video_t
*sh_video
=NULL
;
677 demuxer_desc_t
*demuxer_desc
;
681 //printf("demux_open(%p,%d,%d,%d,%d) \n",stream,file_format,audio_id,video_id,dvdsub_id);
683 // If somebody requested a demuxer check it
685 if ((demuxer_desc
= get_demuxer_desc_from_type(file_format
))) {
686 demuxer
= new_demuxer(stream
,demuxer_desc
->type
,audio_id
,video_id
,dvdsub_id
,filename
);
687 if (demuxer_desc
->check_file
)
688 fformat
= demuxer_desc
->check_file(demuxer
);
689 if (force
|| !demuxer_desc
->check_file
)
690 fformat
= demuxer_desc
->type
;
692 if (fformat
== demuxer_desc
->type
) {
693 demuxer_t
*demux2
= demuxer
;
694 // Move messages to demuxer detection code?
695 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, MSGTR_Detected_XXX_FileFormat
, demuxer_desc
->shortdesc
);
696 file_format
= demuxer_desc
->type
= fformat
;
697 if (!demuxer
->desc
->open
|| (demux2
= demuxer
->desc
->open(demuxer
))) {
702 // Format changed after check, recurse
703 free_demuxer(demuxer
);
704 return demux_open_stream(stream
, fformat
, force
,
705 audio_id
, video_id
, dvdsub_id
, filename
);
708 // Check failed for forced demuxer, quit
709 free_demuxer(demuxer
);
714 // Test demuxers with safe file checks
715 for (i
= 0; (demuxer_desc
= demuxer_list
[i
]); i
++) {
716 if (demuxer_desc
->safe_check
) {
717 demuxer
= new_demuxer(stream
,demuxer_desc
->type
,audio_id
,video_id
,dvdsub_id
,filename
);
718 if ((fformat
= demuxer_desc
->check_file(demuxer
)) != 0) {
719 if (fformat
== demuxer_desc
->type
) {
720 demuxer_t
*demux2
= demuxer
;
721 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, MSGTR_Detected_XXX_FileFormat
, demuxer_desc
->shortdesc
);
722 file_format
= fformat
;
723 if (!demuxer
->desc
->open
|| (demux2
= demuxer
->desc
->open(demuxer
))) {
728 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
729 return demuxer
; // handled in mplayer.c
730 // Format changed after check, recurse
731 free_demuxer(demuxer
);
732 demuxer
=demux_open_stream(stream
, fformat
, force
,
733 audio_id
, video_id
, dvdsub_id
, filename
);
734 if(demuxer
) return demuxer
; // done!
735 file_format
= DEMUXER_TYPE_UNKNOWN
;
738 free_demuxer(demuxer
);
743 // If no forced demuxer perform file extension based detection
744 // Ok. We're over the stable detectable fileformats, the next ones are a bit
745 // fuzzy. So by default (extension_parsing==1) try extension-based detection
747 if(file_format
==DEMUXER_TYPE_UNKNOWN
&& filename
&& extension_parsing
==1){
748 file_format
=demuxer_type_by_filename(filename
);
749 if(file_format
!=DEMUXER_TYPE_UNKNOWN
){
750 // we like recursion :)
751 demuxer
=demux_open_stream(stream
, file_format
, force
,
752 audio_id
, video_id
, dvdsub_id
, filename
);
753 if(demuxer
) return demuxer
; // done!
754 file_format
=DEMUXER_TYPE_UNKNOWN
; // continue fuzzy guessing...
755 mp_msg(MSGT_DEMUXER
,MSGL_V
,"demuxer: continue fuzzy content-based format guessing...\n");
759 // Try detection for all other demuxers
760 for (i
= 0; (demuxer_desc
= demuxer_list
[i
]); i
++) {
761 if (!demuxer_desc
->safe_check
&& demuxer_desc
->check_file
) {
762 demuxer
= new_demuxer(stream
,demuxer_desc
->type
,audio_id
,video_id
,dvdsub_id
,filename
);
763 if ((fformat
= demuxer_desc
->check_file(demuxer
)) != 0) {
764 if (fformat
== demuxer_desc
->type
) {
765 demuxer_t
*demux2
= demuxer
;
766 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, MSGTR_Detected_XXX_FileFormat
, demuxer_desc
->shortdesc
);
767 file_format
= fformat
;
768 if (!demuxer
->desc
->open
|| (demux2
= demuxer
->desc
->open(demuxer
))) {
773 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
774 return demuxer
; // handled in mplayer.c
775 // Format changed after check, recurse
776 free_demuxer(demuxer
);
777 demuxer
=demux_open_stream(stream
, fformat
, force
,
778 audio_id
, video_id
, dvdsub_id
, filename
);
779 if(demuxer
) return demuxer
; // done!
780 file_format
= DEMUXER_TYPE_UNKNOWN
;
783 free_demuxer(demuxer
);
789 //====== File format recognized, set up these for compatibility: =========
792 demuxer
->file_format
=file_format
;
794 if ((sh_video
=demuxer
->video
->sh
) && sh_video
->bih
){
795 int biComp
=le2me_32(sh_video
->bih
->biCompression
);
796 mp_msg(MSGT_DEMUX
,MSGL_INFO
,"VIDEO: [%.4s] %dx%d %dbpp %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n",
798 sh_video
->bih
->biWidth
,
799 sh_video
->bih
->biHeight
,
800 sh_video
->bih
->biBitCount
,
802 sh_video
->i_bps
*0.008f
,
803 sh_video
->i_bps
/1024.0f
);
808 char* audio_stream
= NULL
;
809 char* sub_stream
= NULL
;
810 int demuxer_type
= 0; // used by rawaudio and rawvideo
811 int audio_stream_cache
= 0;
813 char *demuxer_name
= NULL
; // parameter from -demuxer
814 char *audio_demuxer_name
= NULL
; // parameter from -audio-demuxer
815 char *sub_demuxer_name
= NULL
; // parameter from -sub-demuxer
817 extern int hr_mp3_seek
;
819 extern float stream_cache_min_percent
;
820 extern float stream_cache_seek_min_percent
;
822 demuxer_t
* demux_open(stream_t
*vs
,int file_format
,int audio_id
,int video_id
,int dvdsub_id
,char* filename
){
823 stream_t
*as
= NULL
,*ss
= NULL
;
824 demuxer_t
*vd
,*ad
= NULL
,*sd
= NULL
;
825 int afmt
=DEMUXER_TYPE_UNKNOWN
,sfmt
= DEMUXER_TYPE_UNKNOWN
;
826 int audio_demuxer_type
= 0, sub_demuxer_type
= 0;
827 int demuxer_force
= 0, audio_demuxer_force
= 0,
828 sub_demuxer_force
= 0;
830 if ((demuxer_type
= get_demuxer_type_from_name(demuxer_name
, &demuxer_force
)) < 0) {
831 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,"-demuxer %s does not exist.\n",demuxer_name
);
833 if ((audio_demuxer_type
= get_demuxer_type_from_name(audio_demuxer_name
, &audio_demuxer_force
)) < 0) {
834 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,"-audio-demuxer %s does not exist.\n",audio_demuxer_name
);
836 if ((sub_demuxer_type
= get_demuxer_type_from_name(sub_demuxer_name
, &sub_demuxer_force
)) < 0) {
837 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,"-sub-demuxer %s does not exist.\n",sub_demuxer_name
);
841 as
= open_stream(audio_stream
,0,&afmt
);
843 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,MSGTR_CannotOpenAudioStream
,audio_stream
);
846 if(audio_stream_cache
) {
847 if(!stream_enable_cache(as
,audio_stream_cache
*1024,audio_stream_cache
*1024*(stream_cache_min_percent
/ 100.0),
848 audio_stream_cache
*1024*(stream_cache_seek_min_percent
/ 100.0))) {
850 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,"Can't enable audio stream cache\n");
856 ss
= open_stream(sub_stream
,0,&sfmt
);
858 mp_msg(MSGT_DEMUXER
,MSGL_ERR
,MSGTR_CannotOpenSubtitlesStream
,sub_stream
);
863 vd
= demux_open_stream(vs
, demuxer_type
? demuxer_type
: file_format
,
864 demuxer_force
, audio_stream
? -2 : audio_id
, video_id
,
865 sub_stream
? -2 : dvdsub_id
, filename
);
867 if(as
) free_stream(as
);
868 if(ss
) free_stream(ss
);
872 ad
= demux_open_stream(as
, audio_demuxer_type
? audio_demuxer_type
: afmt
,
873 audio_demuxer_force
, audio_id
, -2, -2, audio_stream
);
875 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,MSGTR_OpeningAudioDemuxerFailed
,audio_stream
);
878 else if(ad
->audio
->sh
&& ((sh_audio_t
*)ad
->audio
->sh
)->format
== 0x55) // MP3
879 hr_mp3_seek
=1; // Enable high res seeking
882 sd
= demux_open_stream(ss
, sub_demuxer_type
? sub_demuxer_type
: sfmt
,
883 sub_demuxer_force
, -2, -2, dvdsub_id
, sub_stream
);
885 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,MSGTR_OpeningSubtitlesDemuxerFailed
,sub_stream
);
891 return new_demuxers_demuxer(vd
,ad
,sd
);
893 return new_demuxers_demuxer(vd
,ad
,vd
);
895 return new_demuxers_demuxer(vd
,vd
,sd
);
901 int demux_seek(demuxer_t
*demuxer
,float rel_seek_secs
,float audio_delay
,int flags
){
902 demux_stream_t
*d_audio
=demuxer
->audio
;
903 demux_stream_t
*d_video
=demuxer
->video
;
904 sh_audio_t
*sh_audio
=d_audio
->sh
;
905 sh_video_t
*sh_video
=d_video
->sh
;
909 if(!demuxer
->seekable
){
910 if(demuxer
->file_format
==DEMUXER_TYPE_AVI
)
911 mp_msg(MSGT_SEEK
,MSGL_WARN
,MSGTR_CantSeekRawAVI
);
913 else if (demuxer
->file_format
==DEMUXER_TYPE_TV
)
914 mp_msg(MSGT_SEEK
,MSGL_WARN
,MSGTR_TVInputNotSeekable
);
917 mp_msg(MSGT_SEEK
,MSGL_WARN
,MSGTR_CantSeekFile
);
921 // clear demux buffers:
922 if(sh_audio
){ ds_free_packs(d_audio
);sh_audio
->a_buffer_len
=0;}
923 ds_free_packs(d_video
);
925 demuxer
->stream
->eof
=0; // clear eof flag
926 demuxer
->video
->eof
=0;
927 demuxer
->audio
->eof
=0;
930 if(sh_audio
) sh_audio
->timer
=sh_video
->timer
;
932 if(sh_audio
) sh_audio
->delay
=0;
933 if(sh_video
) sh_video
->timer
=0; // !!!!!!
936 if(flags
& 1) // absolute seek
939 if(demuxer
->stream_pts
== MP_NOPTS_VALUE
)
941 pts
= demuxer
->stream_pts
;
944 if(flags
& 2) { // percent seek
945 if(stream_control(demuxer
->stream
, STREAM_CTRL_GET_TIME_LENGTH
, &tmp
) == STREAM_UNSUPORTED
)
947 pts
+= tmp
* rel_seek_secs
;
949 pts
+= rel_seek_secs
;
951 if(stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_TIME
, &pts
) != STREAM_UNSUPORTED
) {
952 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
957 if (demuxer
->desc
->seek
)
958 demuxer
->desc
->seek(demuxer
,rel_seek_secs
,audio_delay
,flags
);
960 if (sh_audio
) resync_audio_stream(sh_audio
);
965 int demux_info_add(demuxer_t
*demuxer
, const char *opt
, const char *param
)
967 char **info
= demuxer
->info
;
971 for(n
= 0; info
&& info
[2*n
] != NULL
; n
++)
973 if(!strcasecmp(opt
,info
[2*n
]))
975 mp_msg(MSGT_DEMUX
, MSGL_INFO
,MSGTR_DemuxerInfoChanged
,opt
,param
);
977 info
[2*n
+1] = strdup(param
);
982 info
= demuxer
->info
= (char**)realloc(info
,(2*(n
+2))*sizeof(char*));
983 info
[2*n
] = strdup(opt
);
984 info
[2*n
+1] = strdup(param
);
985 memset(&info
[2*(n
+1)],0,2*sizeof(char*));
990 int demux_info_print(demuxer_t
*demuxer
)
992 char **info
= demuxer
->info
;
998 mp_msg(MSGT_DEMUX
, MSGL_INFO
,MSGTR_ClipInfo
);
999 for(n
= 0; info
[2*n
] != NULL
; n
++)
1001 mp_msg(MSGT_DEMUX
, MSGL_INFO
, " %s: %s\n",info
[2*n
],info
[2*n
+1]);
1002 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_NAME%d=%s\n", n
, info
[2*n
]);
1003 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_VALUE%d=%s\n", n
, info
[2*n
+1]);
1005 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_N=%d\n", n
);
1010 char* demux_info_get(demuxer_t
*demuxer
, char *opt
) {
1012 char **info
= demuxer
->info
;
1014 for(i
= 0; info
&& info
[2*i
] != NULL
; i
++) {
1015 if(!strcasecmp(opt
,info
[2*i
]))
1022 int demux_control(demuxer_t
*demuxer
, int cmd
, void *arg
) {
1024 if (demuxer
->desc
->control
)
1025 return demuxer
->desc
->control(demuxer
,cmd
,arg
);
1027 return DEMUXER_CTRL_NOTIMPL
;
1032 double demuxer_get_time_length(demuxer_t
*demuxer
){
1033 double get_time_ans
;
1034 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1035 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1036 // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW
1037 if (demux_control(demuxer
, DEMUXER_CTRL_GET_TIME_LENGTH
,(void *)&get_time_ans
)<=0) {
1038 if (sh_video
&& sh_video
->i_bps
)
1039 get_time_ans
= (double)(demuxer
->movi_end
-demuxer
->movi_start
)/sh_video
->i_bps
;
1040 else if (sh_audio
&& sh_audio
->i_bps
)
1041 get_time_ans
= (double)(demuxer
->movi_end
-demuxer
->movi_start
)/sh_audio
->i_bps
;
1045 return get_time_ans
;
1049 * \brief demuxer_get_current_time() returns the time of the current play in three possible ways:
1050 * either when the stream reader satisfies STREAM_CTRL_GET_CURRENT_TIME (e.g. dvd)
1051 * or using sh_video->pts when the former method fails
1053 * \return the current play time
1055 int demuxer_get_current_time(demuxer_t
*demuxer
){
1056 double get_time_ans
= 0;
1057 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1058 if(demuxer
->stream_pts
!= MP_NOPTS_VALUE
)
1059 get_time_ans
= demuxer
->stream_pts
;
1060 else if(sh_video
) get_time_ans
= sh_video
->pts
;
1061 return (int) get_time_ans
;
1064 int demuxer_get_percent_pos(demuxer_t
*demuxer
){
1066 int res
= demux_control(demuxer
, DEMUXER_CTRL_GET_PERCENT_POS
, &ans
);
1067 int len
= (demuxer
->movi_end
- demuxer
->movi_start
) / 100;
1070 ans
= (demuxer
->filepos
- demuxer
->movi_start
) / len
;
1074 if (ans
< 0) ans
= 0;
1075 if (ans
> 100) ans
= 100;
1079 int demuxer_switch_audio(demuxer_t
*demuxer
, int index
){
1080 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_AUDIO
, &index
);
1081 if (res
== DEMUXER_CTRL_NOTIMPL
)
1082 index
= demuxer
->audio
->id
;
1086 int demuxer_switch_video(demuxer_t
*demuxer
, int index
){
1087 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_VIDEO
, &index
);
1088 if (res
== DEMUXER_CTRL_NOTIMPL
)
1089 index
= demuxer
->video
->id
;
1093 int demuxer_add_chapter(demuxer_t
* demuxer
, const char* name
, uint64_t start
, uint64_t end
){
1094 if (demuxer
->chapters
== NULL
)
1095 demuxer
->chapters
= malloc (32*sizeof(*demuxer
->chapters
));
1096 else if (!(demuxer
->num_chapters
% 32))
1097 demuxer
->chapters
= realloc (demuxer
->chapters
, (demuxer
->num_chapters
+ 32) * sizeof(*demuxer
->chapters
));
1099 demuxer
->chapters
[demuxer
->num_chapters
].start
= start
;
1100 demuxer
->chapters
[demuxer
->num_chapters
].end
= end
;
1101 demuxer
->chapters
[demuxer
->num_chapters
].name
= strdup(name
);
1103 return demuxer
->num_chapters
++;
1107 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1108 * either using the demuxer->chapters structure set by the demuxer
1109 * or asking help to the stream layer (e.g. dvd)
1110 * \param chapter - chapter number wished - 0-based
1111 * \param mode 0: relative to current main pts, 1: absolute
1112 * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1113 * \param num_chapters number of chapters present (set by this function is param is not null)
1114 * \param chapter_name name of chapter found (set by this function is param is not null)
1115 * \return -1 on error, current chapter if successful
1118 int demuxer_seek_chapter(demuxer_t
*demuxer
, int chapter
, int mode
, float *seek_pts
, int *num_chapters
, char **chapter_name
) {
1121 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1122 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1124 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1126 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_CURRENT_CHAPTER
, ¤t
);
1127 if(ris
== STREAM_UNSUPORTED
) return -1;
1131 if(demuxer
->video
->sh
)
1132 ds_free_packs(demuxer
->video
);
1134 if(demuxer
->audio
->sh
)
1135 ds_free_packs(demuxer
->audio
);
1137 if(demuxer
->sub
->id
>= 0)
1138 ds_free_packs(demuxer
->sub
);
1140 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_CHAPTER
, &chapter
);
1141 if(ris
!= STREAM_UNSUPORTED
)
1142 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1144 ds_fill_buffer(demuxer
->video
);
1145 resync_video_stream(sh_video
);
1149 ds_fill_buffer(demuxer
->audio
);
1150 resync_audio_stream(sh_audio
);
1153 //exit status may be ok, but main() doesn't have to seek itself (because e.g. dvds depend on sectors, not on pts)
1157 if(stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
, num_chapters
) == STREAM_UNSUPORTED
)
1162 char *tmp
= malloc(16);
1163 *chapter_name
= NULL
;
1164 if(num_chapters
&& *num_chapters
&& tmp
) {
1165 sprintf(tmp
, " of %3d", *num_chapters
);
1166 *chapter_name
= tmp
;
1170 return (ris
!= STREAM_UNSUPORTED
? chapter
: -1);
1171 } else { //chapters structure is set in the demuxer
1172 total
= demuxer
->num_chapters
;
1174 if (mode
==1) { //absolute seeking
1176 } else { //relative seeking
1178 now
= (sh_video
? sh_video
->pts
: (sh_audio
? sh_audio
->pts
: 0.)) * 1000 + .5;
1180 for (current
= total
- 1; current
>= 0; --current
) {
1181 demux_chapter_t
* chapter
= demuxer
->chapters
+ current
;
1182 if (chapter
->start
<= now
)
1188 if (current
>= total
)
1190 if (current
< 0) current
= 0;
1192 *seek_pts
= demuxer
->chapters
[current
].start
/ 1000.0;
1195 *num_chapters
= demuxer
->num_chapters
;
1198 if(demuxer
->chapters
[current
].name
)
1199 *chapter_name
= strdup(demuxer
->chapters
[current
].name
);
1200 else *chapter_name
= NULL
;