1 //=================== DEMUXER v2.5 =========================
16 #include "libvo/fastmemcpy.h"
18 #include "stream/stream.h"
23 #include "libaf/af_format.h"
26 #include "libass/ass.h"
27 #include "libass/ass_mp.h"
30 #ifdef CONFIG_LIBAVCODEC
31 #include "libavcodec/avcodec.h"
32 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE
33 #error MP_INPUT_BUFFER_PADDING_SIZE is too small!
37 void resync_video_stream(sh_video_t
*sh_video
);
38 void resync_audio_stream(sh_audio_t
*sh_audio
);
41 extern const demuxer_desc_t demuxer_desc_rawaudio
;
42 extern const demuxer_desc_t demuxer_desc_rawvideo
;
43 extern const demuxer_desc_t demuxer_desc_tv
;
44 extern const demuxer_desc_t demuxer_desc_mf
;
45 extern const demuxer_desc_t demuxer_desc_avi
;
46 extern const demuxer_desc_t demuxer_desc_y4m
;
47 extern const demuxer_desc_t demuxer_desc_asf
;
48 extern const demuxer_desc_t demuxer_desc_real
;
49 extern const demuxer_desc_t demuxer_desc_smjpeg
;
50 extern const demuxer_desc_t demuxer_desc_matroska
;
51 extern const demuxer_desc_t demuxer_desc_realaudio
;
52 extern const demuxer_desc_t demuxer_desc_vqf
;
53 extern const demuxer_desc_t demuxer_desc_mov
;
54 extern const demuxer_desc_t demuxer_desc_vivo
;
55 extern const demuxer_desc_t demuxer_desc_fli
;
56 extern const demuxer_desc_t demuxer_desc_film
;
57 extern const demuxer_desc_t demuxer_desc_roq
;
58 extern const demuxer_desc_t demuxer_desc_gif
;
59 extern const demuxer_desc_t demuxer_desc_ogg
;
60 extern const demuxer_desc_t demuxer_desc_avs
;
61 extern const demuxer_desc_t demuxer_desc_pva
;
62 extern const demuxer_desc_t demuxer_desc_nsv
;
63 extern const demuxer_desc_t demuxer_desc_mpeg_ts
;
64 extern const demuxer_desc_t demuxer_desc_lmlm4
;
65 extern const demuxer_desc_t demuxer_desc_mpeg_ps
;
66 extern const demuxer_desc_t demuxer_desc_mpeg_pes
;
67 extern const demuxer_desc_t demuxer_desc_mpeg_es
;
68 extern const demuxer_desc_t demuxer_desc_mpeg_gxf
;
69 extern const demuxer_desc_t demuxer_desc_mpeg4_es
;
70 extern const demuxer_desc_t demuxer_desc_h264_es
;
71 extern const demuxer_desc_t demuxer_desc_rawdv
;
72 extern const demuxer_desc_t demuxer_desc_mpc
;
73 extern const demuxer_desc_t demuxer_desc_audio
;
74 extern const demuxer_desc_t demuxer_desc_xmms
;
75 extern const demuxer_desc_t demuxer_desc_mpeg_ty
;
76 extern const demuxer_desc_t demuxer_desc_rtp
;
77 extern const demuxer_desc_t demuxer_desc_rtp_nemesi
;
78 extern const demuxer_desc_t demuxer_desc_lavf
;
79 extern const demuxer_desc_t demuxer_desc_lavf_preferred
;
80 extern const demuxer_desc_t demuxer_desc_aac
;
81 extern const demuxer_desc_t demuxer_desc_nut
;
82 extern const demuxer_desc_t demuxer_desc_mng
;
84 /* Please do not add any new demuxers here. If you want to implement a new
85 * demuxer, add it to libavformat, except for wrappers around external
86 * libraries and demuxers requiring binary support. */
88 const demuxer_desc_t
*const demuxer_list
[] = {
89 &demuxer_desc_rawaudio
,
90 &demuxer_desc_rawvideo
,
95 #ifdef CONFIG_LIBAVFORMAT
96 &demuxer_desc_lavf_preferred
,
103 &demuxer_desc_smjpeg
,
104 &demuxer_desc_matroska
,
105 &demuxer_desc_realaudio
,
115 #ifdef CONFIG_OGGVORBIS
118 #ifdef CONFIG_WIN32DLL
122 &demuxer_desc_mpeg_ts
,
124 &demuxer_desc_mpeg_ps
,
125 &demuxer_desc_mpeg_pes
,
126 &demuxer_desc_mpeg_es
,
127 &demuxer_desc_mpeg_gxf
,
128 &demuxer_desc_mpeg4_es
,
129 &demuxer_desc_h264_es
,
131 &demuxer_desc_mpeg_ty
,
132 #ifdef CONFIG_LIVE555
135 #ifdef CONFIG_LIBNEMESI
136 &demuxer_desc_rtp_nemesi
,
138 #ifdef CONFIG_LIBAVFORMAT
141 #ifdef CONFIG_MUSEPACK
144 #ifdef CONFIG_LIBDV095
157 /* Please do not add any new demuxers here. If you want to implement a new
158 * demuxer, add it to libavformat, except for wrappers around external
159 * libraries and demuxers requiring binary support. */
163 void free_demuxer_stream(demux_stream_t
*ds
)
169 demux_stream_t
*new_demuxer_stream(struct demuxer_st
*demuxer
, int id
)
171 demux_stream_t
*ds
= malloc(sizeof(demux_stream_t
));
172 ds
->buffer_pos
= ds
->buffer_size
= 0;
183 ds
->first
= ds
->last
= ds
->current
= NULL
;
185 ds
->demuxer
= demuxer
;
188 ds
->asf_packet
= NULL
;
190 ds
->ss_mul
= ds
->ss_div
= 0;
198 * Get demuxer description structure for a given demuxer type
200 * @param file_format type of the demuxer
201 * @return structure for the demuxer, NULL if not found
203 static const demuxer_desc_t
*get_demuxer_desc_from_type(int file_format
)
207 for (i
= 0; demuxer_list
[i
]; i
++)
208 if (file_format
== demuxer_list
[i
]->type
)
209 return demuxer_list
[i
];
215 demuxer_t
*new_demuxer(stream_t
*stream
, int type
, int a_id
, int v_id
,
216 int s_id
, char *filename
)
218 demuxer_t
*d
= malloc(sizeof(demuxer_t
));
219 memset(d
, 0, sizeof(demuxer_t
));
221 d
->stream_pts
= MP_NOPTS_VALUE
;
222 d
->reference_clock
= MP_NOPTS_VALUE
;
223 d
->movi_start
= stream
->start_pos
;
224 d
->movi_end
= stream
->end_pos
;
228 d
->audio
= new_demuxer_stream(d
, a_id
);
229 d
->video
= new_demuxer_stream(d
, v_id
);
230 d
->sub
= new_demuxer_stream(d
, s_id
);
233 if (!(d
->desc
= get_demuxer_desc_from_type(type
)))
234 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
235 "BUG! Invalid demuxer type in new_demuxer(), "
236 "big troubles ahead.");
237 if (filename
) // Filename hack for avs_check_file
238 d
->filename
= strdup(filename
);
239 stream_reset(stream
);
240 stream_seek(stream
, stream
->start_pos
);
244 extern int dvdsub_id
;
246 sh_sub_t
*new_sh_sub_sid(demuxer_t
*demuxer
, int id
, int sid
)
248 if (id
> MAX_S_STREAMS
- 1 || id
< 0) {
249 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
250 "Requested sub stream id overflow (%d > %d)\n", id
,
254 if (demuxer
->s_streams
[id
])
255 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, "Sub stream %i redefined\n", id
);
257 sh_sub_t
*sh
= calloc(1, sizeof(sh_sub_t
));
258 demuxer
->s_streams
[id
] = sh
;
260 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SUBTITLE_ID=%d\n", sid
);
262 return demuxer
->s_streams
[id
];
265 void free_sh_sub(sh_sub_t
*sh
)
267 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_sub at %p\n", sh
);
271 ass_free_track(sh
->ass_track
);
277 sh_audio_t
*new_sh_audio_aid(demuxer_t
*demuxer
, int id
, int aid
)
279 if (id
> MAX_A_STREAMS
- 1 || id
< 0) {
280 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
281 "Requested audio stream id overflow (%d > %d)\n", id
,
285 if (demuxer
->a_streams
[id
])
286 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, MSGTR_AudioStreamRedefined
, id
);
288 sh_audio_t
*sh
= calloc(1, sizeof(sh_audio_t
));
289 mp_msg(MSGT_DEMUXER
, MSGL_V
, MSGTR_FoundAudioStream
, id
);
290 demuxer
->a_streams
[id
] = sh
;
292 sh
->ds
= demuxer
->audio
;
295 sh
->sample_format
= AF_FORMAT_S16_NE
;
296 sh
->audio_out_minsize
= 8192; /* default size, maybe not enough for Win32/ACM */
297 sh
->pts
= MP_NOPTS_VALUE
;
298 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AUDIO_ID=%d\n", aid
);
300 return demuxer
->a_streams
[id
];
303 void free_sh_audio(demuxer_t
*demuxer
, int id
)
305 sh_audio_t
*sh
= demuxer
->a_streams
[id
];
306 demuxer
->a_streams
[id
] = NULL
;
307 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_audio at %p\n", sh
);
314 sh_video_t
*new_sh_video_vid(demuxer_t
*demuxer
, int id
, int vid
)
316 if (id
> MAX_V_STREAMS
- 1 || id
< 0) {
317 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
318 "Requested video stream id overflow (%d > %d)\n", id
,
322 if (demuxer
->v_streams
[id
])
323 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, MSGTR_VideoStreamRedefined
, id
);
325 sh_video_t
*sh
= calloc(1, sizeof(sh_video_t
));
326 mp_msg(MSGT_DEMUXER
, MSGL_V
, MSGTR_FoundVideoStream
, id
);
327 demuxer
->v_streams
[id
] = sh
;
329 sh
->ds
= demuxer
->video
;
330 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VIDEO_ID=%d\n", vid
);
332 return demuxer
->v_streams
[id
];
335 void free_sh_video(sh_video_t
*sh
)
337 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_video at %p\n", sh
);
342 void free_demuxer(demuxer_t
*demuxer
)
345 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing demuxer at %p\n",
347 if (demuxer
->desc
->close
)
348 demuxer
->desc
->close(demuxer
);
349 // Very ugly hack to make it behave like old implementation
350 if (demuxer
->desc
->type
== DEMUXER_TYPE_DEMUXERS
)
351 goto skip_streamfree
;
353 for (i
= 0; i
< MAX_A_STREAMS
; i
++)
354 if (demuxer
->a_streams
[i
])
355 free_sh_audio(demuxer
, i
);
356 for (i
= 0; i
< MAX_V_STREAMS
; i
++)
357 if (demuxer
->v_streams
[i
])
358 free_sh_video(demuxer
->v_streams
[i
]);
359 for (i
= 0; i
< MAX_S_STREAMS
; i
++)
360 if (demuxer
->s_streams
[i
])
361 free_sh_sub(demuxer
->s_streams
[i
]);
363 free_demuxer_stream(demuxer
->audio
);
364 free_demuxer_stream(demuxer
->video
);
365 free_demuxer_stream(demuxer
->sub
);
368 for (i
= 0; demuxer
->info
[i
] != NULL
; i
++)
369 free(demuxer
->info
[i
]);
372 free(demuxer
->filename
);
373 if (demuxer
->chapters
) {
374 for (i
= 0; i
< demuxer
->num_chapters
; i
++)
375 free(demuxer
->chapters
[i
].name
);
376 free(demuxer
->chapters
);
378 if (demuxer
->attachments
) {
379 for (i
= 0; i
< demuxer
->num_attachments
; i
++) {
380 free(demuxer
->attachments
[i
].name
);
381 free(demuxer
->attachments
[i
].type
);
382 free(demuxer
->attachments
[i
].data
);
384 free(demuxer
->attachments
);
390 void ds_add_packet(demux_stream_t
*ds
, demux_packet_t
*dp
)
392 // append packet to DS stream:
394 ds
->bytes
+= dp
->len
;
396 // next packet in stream
400 // first packet in stream
401 ds
->first
= ds
->last
= dp
;
403 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
404 "DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n",
405 (ds
== ds
->demuxer
->audio
) ? "d_audio" : "d_video", dp
->len
,
406 dp
->pts
, (unsigned int) dp
->pos
, ds
->demuxer
->audio
->packs
,
407 ds
->demuxer
->video
->packs
);
410 void ds_read_packet(demux_stream_t
*ds
, stream_t
*stream
, int len
,
411 double pts
, off_t pos
, int flags
)
413 demux_packet_t
*dp
= new_demux_packet(len
);
414 len
= stream_read(stream
, dp
->buffer
, len
);
415 resize_demux_packet(dp
, len
);
419 // append packet to DS stream:
420 ds_add_packet(ds
, dp
);
424 // 0 = EOF or no stream found or invalid type
425 // 1 = successfully read a packet
427 int demux_fill_buffer(demuxer_t
*demux
, demux_stream_t
*ds
)
429 // Note: parameter 'ds' can be NULL!
430 return demux
->desc
->fill_buffer(demux
, ds
);
436 #define MAX_ACUMULATED_PACKETS 64
437 int ds_fill_buffer(demux_stream_t
*ds
)
439 demuxer_t
*demux
= ds
->demuxer
;
441 free_demux_packet(ds
->current
);
443 if (mp_msg_test(MSGT_DEMUXER
, MSGL_DBG3
)) {
444 if (ds
== demux
->audio
)
445 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
446 "ds_fill_buffer(d_audio) called\n");
447 else if (ds
== demux
->video
)
448 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
449 "ds_fill_buffer(d_video) called\n");
450 else if (ds
== demux
->sub
)
451 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
, "ds_fill_buffer(d_sub) called\n");
453 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
454 "ds_fill_buffer(unknown 0x%X) called\n", (unsigned int) ds
);
458 demux_packet_t
*p
= ds
->first
;
460 if (demux
->reference_clock
!= MP_NOPTS_VALUE
) {
461 if ( p
->pts
!= MP_NOPTS_VALUE
462 && p
->pts
> demux
->reference_clock
463 && ds
->packs
< MAX_ACUMULATED_PACKETS
) {
464 if (demux_fill_buffer(demux
, ds
))
470 ds
->buffer
= p
->buffer
;
472 ds
->buffer_size
= p
->len
;
474 ds
->dpos
+= p
->len
; // !!!
476 if (p
->pts
!= MP_NOPTS_VALUE
) {
480 ds
->pts_bytes
+= p
->len
; // !!!
481 if (p
->stream_pts
!= MP_NOPTS_VALUE
)
482 demux
->stream_pts
= p
->stream_pts
;
483 ds
->flags
= p
->flags
;
493 if (demux
->audio
->packs
>= MAX_PACKS
494 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
495 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyAudioInBuffer
,
496 demux
->audio
->packs
, demux
->audio
->bytes
);
497 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
500 if (demux
->video
->packs
>= MAX_PACKS
501 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
502 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyVideoInBuffer
,
503 demux
->video
->packs
, demux
->video
->bytes
);
504 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
507 if (!demux_fill_buffer(demux
, ds
)) {
508 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
509 "ds_fill_buffer()->demux_fill_buffer() failed\n");
513 ds
->buffer_pos
= ds
->buffer_size
= 0;
515 mp_msg(MSGT_DEMUXER
, MSGL_V
,
516 "ds_fill_buffer: EOF reached (stream: %s) \n",
517 ds
== demux
->audio
? "audio" : "video");
522 int demux_read_data(demux_stream_t
*ds
, unsigned char *mem
, int len
)
527 x
= ds
->buffer_size
- ds
->buffer_pos
;
529 if (!ds_fill_buffer(ds
))
535 fast_memcpy(mem
+ bytes
, &ds
->buffer
[ds
->buffer_pos
], x
);
545 * \brief read data until the given 3-byte pattern is encountered, up to maxlen
546 * \param mem memory to read data into, may be NULL to discard data
547 * \param maxlen maximum number of bytes to read
548 * \param read number of bytes actually read
549 * \param pattern pattern to search for (lowest 8 bits are ignored)
550 * \return whether pattern was found
552 int demux_pattern_3(demux_stream_t
*ds
, unsigned char *mem
, int maxlen
,
553 int *read
, uint32_t pattern
)
555 register uint32_t head
= 0xffffff00;
556 register uint32_t pat
= pattern
& 0xffffff00;
559 register unsigned char *ds_buf
= &ds
->buffer
[ds
->buffer_size
];
560 int len
= ds
->buffer_size
- ds
->buffer_pos
;
561 register long pos
= -len
;
562 if (unlikely(pos
>= 0)) { // buffer is empty
569 } while (++pos
&& head
!= pat
);
571 if (total_len
+ len
> maxlen
)
572 len
= maxlen
- total_len
;
573 len
= demux_read_data(ds
, mem
? &mem
[total_len
] : NULL
, len
);
575 } while ((head
!= pat
|| total_len
< 3) && total_len
< maxlen
&& !ds
->eof
);
578 return total_len
>= 3 && head
== pat
;
581 void ds_free_packs(demux_stream_t
*ds
)
583 demux_packet_t
*dp
= ds
->first
;
585 demux_packet_t
*dn
= dp
->next
;
586 free_demux_packet(dp
);
589 if (ds
->asf_packet
) {
590 // free unfinished .asf fragments:
591 free(ds
->asf_packet
->buffer
);
592 free(ds
->asf_packet
);
593 ds
->asf_packet
= NULL
;
595 ds
->first
= ds
->last
= NULL
;
596 ds
->packs
= 0; // !!!!!
599 free_demux_packet(ds
->current
);
602 ds
->buffer_pos
= ds
->buffer_size
;
607 int ds_get_packet(demux_stream_t
*ds
, unsigned char **start
)
610 if (ds
->buffer_pos
>= ds
->buffer_size
) {
611 if (!ds_fill_buffer(ds
)) {
617 len
= ds
->buffer_size
- ds
->buffer_pos
;
618 *start
= &ds
->buffer
[ds
->buffer_pos
];
619 ds
->buffer_pos
+= len
;
623 int ds_get_packet_pts(demux_stream_t
*ds
, unsigned char **start
, double *pts
)
626 *pts
= MP_NOPTS_VALUE
;
627 if (ds
->buffer_pos
>= ds
->buffer_size
) {
628 if (!ds_fill_buffer(ds
)) {
634 // Return pts unless this read starts from the middle of a packet
636 *pts
= ds
->current
->pts
;
637 len
= ds
->buffer_size
- ds
->buffer_pos
;
638 *start
= &ds
->buffer
[ds
->buffer_pos
];
639 ds
->buffer_pos
+= len
;
643 int ds_get_packet_sub(demux_stream_t
*ds
, unsigned char **start
)
646 if (ds
->buffer_pos
>= ds
->buffer_size
) {
650 if (!ds_fill_buffer(ds
))
653 len
= ds
->buffer_size
- ds
->buffer_pos
;
654 *start
= &ds
->buffer
[ds
->buffer_pos
];
655 ds
->buffer_pos
+= len
;
659 double ds_get_next_pts(demux_stream_t
*ds
)
661 demuxer_t
*demux
= ds
->demuxer
;
663 if (demux
->audio
->packs
>= MAX_PACKS
664 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
665 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyAudioInBuffer
,
666 demux
->audio
->packs
, demux
->audio
->bytes
);
667 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
668 return MP_NOPTS_VALUE
;
670 if (demux
->video
->packs
>= MAX_PACKS
671 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
672 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyVideoInBuffer
,
673 demux
->video
->packs
, demux
->video
->bytes
);
674 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
675 return MP_NOPTS_VALUE
;
677 if (!demux_fill_buffer(demux
, ds
))
678 return MP_NOPTS_VALUE
;
680 return ds
->first
->pts
;
683 // ====================================================================
685 void demuxer_help(void)
689 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "Available demuxers:\n");
690 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " demuxer: type info: (comment)\n");
691 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_DEMUXERS\n");
692 for (i
= 0; demuxer_list
[i
]; i
++) {
693 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Don't display special demuxers
695 if (demuxer_list
[i
]->comment
&& strlen(demuxer_list
[i
]->comment
))
696 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s (%s)\n",
697 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
,
698 demuxer_list
[i
]->info
, demuxer_list
[i
]->comment
);
700 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s\n",
701 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
,
702 demuxer_list
[i
]->info
);
708 * Get demuxer type for a given demuxer name
710 * @param demuxer_name string with demuxer name of demuxer number
711 * @param force will be set if demuxer should be forced.
713 * @return DEMUXER_TYPE_xxx, -1 if error or not found
715 int get_demuxer_type_from_name(char *demuxer_name
, int *force
)
721 if (!demuxer_name
|| !demuxer_name
[0])
722 return DEMUXER_TYPE_UNKNOWN
;
724 *force
= demuxer_name
[0] == '+';
725 if (demuxer_name
[0] == '+')
726 demuxer_name
= &demuxer_name
[1];
727 for (i
= 0; demuxer_list
[i
]; i
++) {
728 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Can't select special demuxers from commandline
730 if (strcmp(demuxer_name
, demuxer_list
[i
]->name
) == 0)
731 return demuxer_list
[i
]->type
;
734 // No match found, try to parse name as an integer (demuxer number)
735 type_int
= strtol(demuxer_name
, &endptr
, 0);
736 if (*endptr
) // Conversion failed
738 if ((type_int
> 0) && (type_int
<= DEMUXER_TYPE_MAX
))
739 return (int) type_int
;
744 int extension_parsing
= 1; // 0=off 1=mixed (used only for unstable formats)
747 int user_correct_pts
= -1;
750 NOTE : Several demuxers may be opened at the same time so
751 demuxers should NEVER rely on an external var to enable them
752 self. If a demuxer can't do any auto-detection it should only use
753 file_format. The user can explicitly set file_format with the -demuxer
754 option so there is really no need for another extra var.
755 For convenience an option can be added to set file_format directly
756 to the right type (ex: rawaudio,rawvideo).
757 Also the stream can override the file_format so a demuxer which rely
758 on a special stream type can set file_format at the stream level
762 static demuxer_t
*demux_open_stream(stream_t
*stream
, int file_format
,
763 int force
, int audio_id
, int video_id
,
764 int dvdsub_id
, char *filename
)
766 demuxer_t
*demuxer
= NULL
;
768 sh_video_t
*sh_video
= NULL
;
770 const demuxer_desc_t
*demuxer_desc
;
774 // If somebody requested a demuxer check it
776 if ((demuxer_desc
= get_demuxer_desc_from_type(file_format
))) {
777 demuxer
= new_demuxer(stream
, demuxer_desc
->type
, audio_id
,
778 video_id
, dvdsub_id
, filename
);
779 if (demuxer_desc
->check_file
)
780 fformat
= demuxer_desc
->check_file(demuxer
);
781 if (force
|| !demuxer_desc
->check_file
)
782 fformat
= demuxer_desc
->type
;
784 if (fformat
== demuxer_desc
->type
) {
785 demuxer_t
*demux2
= demuxer
;
786 // Move messages to demuxer detection code?
787 mp_msg(MSGT_DEMUXER
, MSGL_INFO
,
788 MSGTR_Detected_XXX_FileFormat
,
789 demuxer_desc
->shortdesc
);
790 file_format
= fformat
;
791 if (!demuxer
->desc
->open
792 || (demux2
= demuxer
->desc
->open(demuxer
))) {
797 // Format changed after check, recurse
798 free_demuxer(demuxer
);
799 return demux_open_stream(stream
, fformat
, force
, audio_id
,
800 video_id
, dvdsub_id
, filename
);
803 // Check failed for forced demuxer, quit
804 free_demuxer(demuxer
);
808 // Test demuxers with safe file checks
809 for (i
= 0; (demuxer_desc
= demuxer_list
[i
]); i
++) {
810 if (demuxer_desc
->safe_check
) {
811 demuxer
= new_demuxer(stream
, demuxer_desc
->type
, audio_id
,
812 video_id
, dvdsub_id
, filename
);
813 if ((fformat
= demuxer_desc
->check_file(demuxer
)) != 0) {
814 if (fformat
== demuxer_desc
->type
) {
815 demuxer_t
*demux2
= demuxer
;
816 mp_msg(MSGT_DEMUXER
, MSGL_INFO
,
817 MSGTR_Detected_XXX_FileFormat
,
818 demuxer_desc
->shortdesc
);
819 file_format
= fformat
;
820 if (!demuxer
->desc
->open
821 || (demux2
= demuxer
->desc
->open(demuxer
))) {
826 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
827 return demuxer
; // handled in mplayer.c
828 // Format changed after check, recurse
829 free_demuxer(demuxer
);
830 demuxer
= demux_open_stream(stream
, fformat
, force
,
832 dvdsub_id
, filename
);
834 return demuxer
; // done!
835 file_format
= DEMUXER_TYPE_UNKNOWN
;
838 free_demuxer(demuxer
);
843 // If no forced demuxer perform file extension based detection
844 // Ok. We're over the stable detectable fileformats, the next ones are
845 // a bit fuzzy. So by default (extension_parsing==1) try extension-based
847 if (file_format
== DEMUXER_TYPE_UNKNOWN
&& filename
848 && extension_parsing
== 1) {
849 file_format
= demuxer_type_by_filename(filename
);
850 if (file_format
!= DEMUXER_TYPE_UNKNOWN
) {
851 // we like recursion :)
852 demuxer
= demux_open_stream(stream
, file_format
, force
, audio_id
,
853 video_id
, dvdsub_id
, filename
);
855 return demuxer
; // done!
856 file_format
= DEMUXER_TYPE_UNKNOWN
; // continue fuzzy guessing...
857 mp_msg(MSGT_DEMUXER
, MSGL_V
,
858 "demuxer: continue fuzzy content-based format guessing...\n");
861 // Try detection for all other demuxers
862 for (i
= 0; (demuxer_desc
= demuxer_list
[i
]); i
++) {
863 if (!demuxer_desc
->safe_check
&& demuxer_desc
->check_file
) {
864 demuxer
= new_demuxer(stream
, demuxer_desc
->type
, audio_id
,
865 video_id
, dvdsub_id
, filename
);
866 if ((fformat
= demuxer_desc
->check_file(demuxer
)) != 0) {
867 if (fformat
== demuxer_desc
->type
) {
868 demuxer_t
*demux2
= demuxer
;
869 mp_msg(MSGT_DEMUXER
, MSGL_INFO
,
870 MSGTR_Detected_XXX_FileFormat
,
871 demuxer_desc
->shortdesc
);
872 file_format
= fformat
;
873 if (!demuxer
->desc
->open
874 || (demux2
= demuxer
->desc
->open(demuxer
))) {
879 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
880 return demuxer
; // handled in mplayer.c
881 // Format changed after check, recurse
882 free_demuxer(demuxer
);
883 demuxer
= demux_open_stream(stream
, fformat
, force
,
885 dvdsub_id
, filename
);
887 return demuxer
; // done!
888 file_format
= DEMUXER_TYPE_UNKNOWN
;
891 free_demuxer(demuxer
);
897 //====== File format recognized, set up these for compatibility: =========
900 demuxer
->file_format
= file_format
;
902 if ((sh_video
= demuxer
->video
->sh
) && sh_video
->bih
) {
903 int biComp
= le2me_32(sh_video
->bih
->biCompression
);
904 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
905 "VIDEO: [%.4s] %dx%d %dbpp %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n",
906 (char *) &biComp
, sh_video
->bih
->biWidth
,
907 sh_video
->bih
->biHeight
, sh_video
->bih
->biBitCount
,
908 sh_video
->fps
, sh_video
->i_bps
* 0.008f
,
909 sh_video
->i_bps
/ 1024.0f
);
912 if (ass_enabled
&& ass_library
) {
913 for (i
= 0; i
< MAX_S_STREAMS
; ++i
) {
914 sh_sub_t
*sh
= demuxer
->s_streams
[i
];
915 if (sh
&& sh
->type
== 'a') {
916 sh
->ass_track
= ass_new_track(ass_library
);
917 if (sh
->ass_track
&& sh
->extradata
)
918 ass_process_codec_private(sh
->ass_track
, sh
->extradata
,
920 } else if (sh
&& sh
->type
!= 'v')
921 sh
->ass_track
= ass_default_track(ass_library
);
928 char *audio_stream
= NULL
;
929 char *sub_stream
= NULL
;
930 int audio_stream_cache
= 0;
932 char *demuxer_name
= NULL
; // parameter from -demuxer
933 char *audio_demuxer_name
= NULL
; // parameter from -audio-demuxer
934 char *sub_demuxer_name
= NULL
; // parameter from -sub-demuxer
936 extern int hr_mp3_seek
;
938 extern float stream_cache_min_percent
;
939 extern float stream_cache_seek_min_percent
;
941 demuxer_t
*demux_open(stream_t
*vs
, int file_format
, int audio_id
,
942 int video_id
, int dvdsub_id
, char *filename
)
944 stream_t
*as
= NULL
, *ss
= NULL
;
945 demuxer_t
*vd
, *ad
= NULL
, *sd
= NULL
;
947 int afmt
= DEMUXER_TYPE_UNKNOWN
, sfmt
= DEMUXER_TYPE_UNKNOWN
;
949 int audio_demuxer_type
= 0, sub_demuxer_type
= 0;
950 int demuxer_force
= 0, audio_demuxer_force
= 0, sub_demuxer_force
= 0;
953 get_demuxer_type_from_name(demuxer_name
, &demuxer_force
)) < 0) {
954 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-demuxer %s does not exist.\n",
957 if ((audio_demuxer_type
=
958 get_demuxer_type_from_name(audio_demuxer_name
,
959 &audio_demuxer_force
)) < 0) {
960 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-audio-demuxer %s does not exist.\n",
963 if ((sub_demuxer_type
=
964 get_demuxer_type_from_name(sub_demuxer_name
,
965 &sub_demuxer_force
)) < 0) {
966 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-sub-demuxer %s does not exist.\n",
971 as
= open_stream(audio_stream
, 0, &afmt
);
973 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_CannotOpenAudioStream
,
977 if (audio_stream_cache
) {
978 if (!stream_enable_cache
979 (as
, audio_stream_cache
* 1024,
980 audio_stream_cache
* 1024 * (stream_cache_min_percent
/
982 audio_stream_cache
* 1024 * (stream_cache_seek_min_percent
/
985 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
986 "Can't enable audio stream cache\n");
992 ss
= open_stream(sub_stream
, 0, &sfmt
);
994 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_CannotOpenSubtitlesStream
,
1000 vd
= demux_open_stream(vs
, demuxer_type
? demuxer_type
: file_format
,
1001 demuxer_force
, audio_stream
? -2 : audio_id
,
1002 video_id
, sub_stream
? -2 : dvdsub_id
, filename
);
1011 ad
= demux_open_stream(as
,
1012 audio_demuxer_type
? audio_demuxer_type
: afmt
,
1013 audio_demuxer_force
, audio_id
, -2, -2,
1016 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, MSGTR_OpeningAudioDemuxerFailed
,
1019 } else if (ad
->audio
->sh
1020 && ((sh_audio_t
*) ad
->audio
->sh
)->format
== 0x55) // MP3
1021 hr_mp3_seek
= 1; // Enable high res seeking
1024 sd
= demux_open_stream(ss
, sub_demuxer_type
? sub_demuxer_type
: sfmt
,
1025 sub_demuxer_force
, -2, -2, dvdsub_id
,
1028 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
1029 MSGTR_OpeningSubtitlesDemuxerFailed
, sub_stream
);
1035 res
= new_demuxers_demuxer(vd
, ad
, sd
);
1037 res
= new_demuxers_demuxer(vd
, ad
, vd
);
1039 res
= new_demuxers_demuxer(vd
, vd
, sd
);
1043 correct_pts
= user_correct_pts
;
1044 if (correct_pts
< 0)
1045 correct_pts
= demux_control(res
, DEMUXER_CTRL_CORRECT_PTS
, NULL
)
1051 void demux_flush(demuxer_t
*demuxer
)
1053 ds_free_packs(demuxer
->video
);
1054 ds_free_packs(demuxer
->audio
);
1055 ds_free_packs(demuxer
->sub
);
1058 int demux_seek(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
,
1061 demux_stream_t
*d_audio
= demuxer
->audio
;
1062 demux_stream_t
*d_video
= demuxer
->video
;
1063 sh_audio_t
*sh_audio
= d_audio
->sh
;
1064 sh_video_t
*sh_video
= d_video
->sh
;
1068 if (!demuxer
->seekable
) {
1069 if (demuxer
->file_format
== DEMUXER_TYPE_AVI
)
1070 mp_msg(MSGT_SEEK
, MSGL_WARN
, MSGTR_CantSeekRawAVI
);
1072 else if (demuxer
->file_format
== DEMUXER_TYPE_TV
)
1073 mp_msg(MSGT_SEEK
, MSGL_WARN
, MSGTR_TVInputNotSeekable
);
1076 mp_msg(MSGT_SEEK
, MSGL_WARN
, MSGTR_CantSeekFile
);
1080 demux_flush(demuxer
);
1081 // clear demux buffers:
1083 sh_audio
->a_buffer_len
= 0;
1085 demuxer
->stream
->eof
= 0;
1086 demuxer
->video
->eof
= 0;
1087 demuxer
->audio
->eof
= 0;
1090 sh_video
->timer
= 0; // !!!!!!
1092 if (flags
& SEEK_ABSOLUTE
)
1095 if (demuxer
->stream_pts
== MP_NOPTS_VALUE
)
1097 pts
= demuxer
->stream_pts
;
1100 if (flags
& SEEK_FACTOR
) {
1101 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_TIME_LENGTH
, &tmp
)
1102 == STREAM_UNSUPPORTED
)
1104 pts
+= tmp
* rel_seek_secs
;
1106 pts
+= rel_seek_secs
;
1108 if (stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_TIME
, &pts
) !=
1109 STREAM_UNSUPPORTED
) {
1110 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1115 if (demuxer
->desc
->seek
)
1116 demuxer
->desc
->seek(demuxer
, rel_seek_secs
, audio_delay
, flags
);
1119 resync_audio_stream(sh_audio
);
1124 int demux_info_add(demuxer_t
*demuxer
, const char *opt
, const char *param
)
1126 char **info
= demuxer
->info
;
1130 for (n
= 0; info
&& info
[2 * n
] != NULL
; n
++) {
1131 if (!strcasecmp(opt
, info
[2 * n
])) {
1132 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_DemuxerInfoChanged
, opt
,
1134 free(info
[2 * n
+ 1]);
1135 info
[2 * n
+ 1] = strdup(param
);
1140 info
= demuxer
->info
= (char **) realloc(info
,
1141 (2 * (n
+ 2)) * sizeof(char *));
1142 info
[2 * n
] = strdup(opt
);
1143 info
[2 * n
+ 1] = strdup(param
);
1144 memset(&info
[2 * (n
+ 1)], 0, 2 * sizeof(char *));
1149 int demux_info_print(demuxer_t
*demuxer
)
1151 char **info
= demuxer
->info
;
1157 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_ClipInfo
);
1158 for (n
= 0; info
[2 * n
] != NULL
; n
++) {
1159 mp_msg(MSGT_DEMUX
, MSGL_INFO
, " %s: %s\n", info
[2 * n
],
1161 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_NAME%d=%s\n", n
,
1163 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_VALUE%d=%s\n", n
,
1166 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_N=%d\n", n
);
1171 char *demux_info_get(demuxer_t
*demuxer
, const char *opt
)
1174 char **info
= demuxer
->info
;
1176 for (i
= 0; info
&& info
[2 * i
] != NULL
; i
++) {
1177 if (!strcasecmp(opt
, info
[2 * i
]))
1178 return info
[2 * i
+ 1];
1184 int demux_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
1187 if (demuxer
->desc
->control
)
1188 return demuxer
->desc
->control(demuxer
, cmd
, arg
);
1190 return DEMUXER_CTRL_NOTIMPL
;
1195 double demuxer_get_time_length(demuxer_t
*demuxer
)
1197 double get_time_ans
;
1198 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1199 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1200 // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW
1202 (demuxer
, DEMUXER_CTRL_GET_TIME_LENGTH
, (void *) &get_time_ans
) <= 0) {
1203 if (sh_video
&& sh_video
->i_bps
&& sh_audio
&& sh_audio
->i_bps
)
1204 get_time_ans
= (double) (demuxer
->movi_end
-
1205 demuxer
->movi_start
) / (sh_video
->i_bps
+
1207 else if (sh_video
&& sh_video
->i_bps
)
1208 get_time_ans
= (double) (demuxer
->movi_end
-
1209 demuxer
->movi_start
) / sh_video
->i_bps
;
1210 else if (sh_audio
&& sh_audio
->i_bps
)
1211 get_time_ans
= (double) (demuxer
->movi_end
-
1212 demuxer
->movi_start
) / sh_audio
->i_bps
;
1216 return get_time_ans
;
1220 * \brief demuxer_get_current_time() returns the time of the current play in three possible ways:
1221 * either when the stream reader satisfies STREAM_CTRL_GET_CURRENT_TIME (e.g. dvd)
1222 * or using sh_video->pts when the former method fails
1224 * \return the current play time
1226 int demuxer_get_current_time(demuxer_t
*demuxer
)
1228 double get_time_ans
= 0;
1229 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1230 if (demuxer
->stream_pts
!= MP_NOPTS_VALUE
)
1231 get_time_ans
= demuxer
->stream_pts
;
1233 get_time_ans
= sh_video
->pts
;
1234 return (int) get_time_ans
;
1237 int demuxer_get_percent_pos(demuxer_t
*demuxer
)
1240 int res
= demux_control(demuxer
, DEMUXER_CTRL_GET_PERCENT_POS
, &ans
);
1241 int len
= (demuxer
->movi_end
- demuxer
->movi_start
) / 100;
1244 ans
= (demuxer
->filepos
- demuxer
->movi_start
) / len
;
1255 int demuxer_switch_audio(demuxer_t
*demuxer
, int index
)
1257 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_AUDIO
, &index
);
1258 if (res
== DEMUXER_CTRL_NOTIMPL
)
1259 index
= demuxer
->audio
->id
;
1260 if (demuxer
->audio
->id
>= 0)
1261 demuxer
->audio
->sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
1263 demuxer
->audio
->sh
= NULL
;
1267 int demuxer_switch_video(demuxer_t
*demuxer
, int index
)
1269 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_VIDEO
, &index
);
1270 if (res
== DEMUXER_CTRL_NOTIMPL
)
1271 index
= demuxer
->video
->id
;
1272 if (demuxer
->video
->id
>= 0)
1273 demuxer
->video
->sh
= demuxer
->v_streams
[demuxer
->video
->id
];
1275 demuxer
->video
->sh
= NULL
;
1279 int demuxer_add_attachment(demuxer_t
*demuxer
, const char *name
,
1280 const char *type
, const void *data
, size_t size
)
1282 if (!(demuxer
->num_attachments
& 31))
1283 demuxer
->attachments
= realloc(demuxer
->attachments
,
1284 (demuxer
->num_attachments
+ 32) * sizeof(demux_attachment_t
));
1286 demuxer
->attachments
[demuxer
->num_attachments
].name
= strdup(name
);
1287 demuxer
->attachments
[demuxer
->num_attachments
].type
= strdup(type
);
1288 demuxer
->attachments
[demuxer
->num_attachments
].data
= malloc(size
);
1289 memcpy(demuxer
->attachments
[demuxer
->num_attachments
].data
, data
, size
);
1290 demuxer
->attachments
[demuxer
->num_attachments
].data_size
= size
;
1292 return demuxer
->num_attachments
++;
1295 int demuxer_add_chapter(demuxer_t
*demuxer
, const char *name
, uint64_t start
,
1298 if (demuxer
->chapters
== NULL
)
1299 demuxer
->chapters
= malloc(32 * sizeof(*demuxer
->chapters
));
1300 else if (!(demuxer
->num_chapters
% 32))
1301 demuxer
->chapters
= realloc(demuxer
->chapters
,
1302 (demuxer
->num_chapters
+ 32) *
1303 sizeof(*demuxer
->chapters
));
1305 demuxer
->chapters
[demuxer
->num_chapters
].start
= start
;
1306 demuxer
->chapters
[demuxer
->num_chapters
].end
= end
;
1307 demuxer
->chapters
[demuxer
->num_chapters
].name
= strdup(name
? name
: MSGTR_Unknown
);
1309 return demuxer
->num_chapters
++;
1313 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1314 * either using the demuxer->chapters structure set by the demuxer
1315 * or asking help to the stream layer (e.g. dvd)
1316 * \param chapter - chapter number wished - 0-based
1317 * \param mode 0: relative to current main pts, 1: absolute
1318 * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1319 * \param num_chapters number of chapters present (set by this function is param is not null)
1320 * \param chapter_name name of chapter found (set by this function is param is not null)
1321 * \return -1 on error, current chapter if successful
1324 int demuxer_seek_chapter(demuxer_t
*demuxer
, int chapter
, int mode
,
1325 float *seek_pts
, int *num_chapters
,
1326 char **chapter_name
)
1330 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1331 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1333 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1335 ris
= stream_control(demuxer
->stream
,
1336 STREAM_CTRL_GET_CURRENT_CHAPTER
, ¤t
);
1337 if (ris
== STREAM_UNSUPPORTED
)
1342 demux_flush(demuxer
);
1344 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_CHAPTER
,
1346 if (ris
!= STREAM_UNSUPPORTED
)
1347 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1349 ds_fill_buffer(demuxer
->video
);
1350 resync_video_stream(sh_video
);
1354 ds_fill_buffer(demuxer
->audio
);
1355 resync_audio_stream(sh_audio
);
1357 // exit status may be ok, but main() doesn't have to seek itself
1358 // (because e.g. dvds depend on sectors, not on pts)
1362 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1363 num_chapters
) == STREAM_UNSUPPORTED
)
1368 *chapter_name
= NULL
;
1369 if (num_chapters
&& *num_chapters
) {
1370 char *tmp
= malloc(16);
1372 sprintf(tmp
, " of %3d", *num_chapters
);
1373 *chapter_name
= tmp
;
1378 return ris
!= STREAM_UNSUPPORTED
? chapter
: -1;
1379 } else { // chapters structure is set in the demuxer
1380 total
= demuxer
->num_chapters
;
1382 if (mode
== 1) //absolute seeking
1384 else { //relative seeking
1386 now
= (sh_video
? sh_video
->pts
: (sh_audio
? sh_audio
->pts
: 0.))
1389 for (current
= total
- 1; current
>= 0; --current
) {
1390 demux_chapter_t
*chapter
= demuxer
->chapters
+ current
;
1391 if (chapter
->start
<= now
)
1397 if (current
>= total
)
1402 *seek_pts
= demuxer
->chapters
[current
].start
/ 1000.0;
1405 *num_chapters
= demuxer
->num_chapters
;
1408 if (demuxer
->chapters
[current
].name
)
1409 *chapter_name
= strdup(demuxer
->chapters
[current
].name
);
1411 *chapter_name
= NULL
;
1418 int demuxer_get_current_chapter(demuxer_t
*demuxer
)
1421 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1422 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_CURRENT_CHAPTER
,
1423 &chapter
) == STREAM_UNSUPPORTED
)
1426 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1427 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1429 now
= (sh_video
? sh_video
->pts
: (sh_audio
? sh_audio
->pts
: 0))
1431 for (chapter
= demuxer
->num_chapters
- 1; chapter
>= 0; --chapter
) {
1432 if (demuxer
->chapters
[chapter
].start
<= now
)
1439 char *demuxer_chapter_name(demuxer_t
*demuxer
, int chapter
)
1441 if (demuxer
->num_chapters
&& demuxer
->chapters
) {
1442 if (chapter
>= 0 && chapter
< demuxer
->num_chapters
1443 && demuxer
->chapters
[chapter
].name
)
1444 return strdup(demuxer
->chapters
[chapter
].name
);
1449 char *demuxer_chapter_display_name(demuxer_t
*demuxer
, int chapter
)
1451 char *chapter_name
= demuxer_chapter_name(demuxer
, chapter
);
1453 char *tmp
= malloc(strlen(chapter_name
) + 14);
1454 snprintf(tmp
, 63, "(%d) %s", chapter
+ 1, chapter_name
);
1458 int chapter_num
= demuxer_chapter_count(demuxer
);
1460 if (chapter_num
<= 0)
1461 sprintf(tmp
, "(%d)", chapter
+ 1);
1463 sprintf(tmp
, "(%d) of %d", chapter
+ 1, chapter_num
);
1468 float demuxer_chapter_time(demuxer_t
*demuxer
, int chapter
, float *end
)
1470 if (demuxer
->num_chapters
&& demuxer
->chapters
&& chapter
>= 0
1471 && chapter
< demuxer
->num_chapters
) {
1473 *end
= demuxer
->chapters
[chapter
].end
/ 1000.0;
1474 return demuxer
->chapters
[chapter
].start
/ 1000.0;
1479 int demuxer_chapter_count(demuxer_t
*demuxer
)
1481 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1482 int num_chapters
= 0;
1483 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1484 &num_chapters
) == STREAM_UNSUPPORTED
)
1486 return num_chapters
;
1488 return demuxer
->num_chapters
;
1491 int demuxer_angles_count(demuxer_t
*demuxer
)
1493 int ris
, angles
= -1;
1495 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_ANGLES
, &angles
);
1496 if (ris
== STREAM_UNSUPPORTED
)
1501 int demuxer_get_current_angle(demuxer_t
*demuxer
)
1503 int ris
, curr_angle
= -1;
1504 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_ANGLE
, &curr_angle
);
1505 if (ris
== STREAM_UNSUPPORTED
)
1511 int demuxer_set_angle(demuxer_t
*demuxer
, int angle
)
1513 int ris
, angles
= -1;
1514 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1515 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1517 angles
= demuxer_angles_count(demuxer
);
1518 if ((angles
< 1) || (angle
> angles
))
1521 demux_flush(demuxer
);
1523 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SET_ANGLE
, &angle
);
1524 if (ris
== STREAM_UNSUPPORTED
)
1527 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1529 ds_fill_buffer(demuxer
->video
);
1530 resync_video_stream(sh_video
);
1534 ds_fill_buffer(demuxer
->audio
);
1535 resync_audio_stream(sh_audio
);
1541 int demuxer_audio_track_by_lang(demuxer_t
*d
, char *lang
)
1544 lang
+= strspn(lang
, ",");
1545 while ((len
= strcspn(lang
, ",")) > 0) {
1546 for (i
= 0; i
< MAX_A_STREAMS
; ++i
) {
1547 sh_audio_t
*sh
= d
->a_streams
[i
];
1548 if (sh
&& sh
->lang
&& strncmp(sh
->lang
, lang
, len
) == 0)
1552 lang
+= strspn(lang
, ",");
1557 int demuxer_sub_track_by_lang(demuxer_t
*d
, char *lang
)
1560 lang
+= strspn(lang
, ",");
1561 while ((len
= strcspn(lang
, ",")) > 0) {
1562 for (i
= 0; i
< MAX_S_STREAMS
; ++i
) {
1563 sh_sub_t
*sh
= d
->s_streams
[i
];
1564 if (sh
&& sh
->lang
&& strncmp(sh
->lang
, lang
, len
) == 0)
1568 lang
+= strspn(lang
, ",");
1573 int demuxer_default_audio_track(demuxer_t
*d
)
1576 for (i
= 0; i
< MAX_A_STREAMS
; ++i
) {
1577 sh_audio_t
*sh
= d
->a_streams
[i
];
1578 if (sh
&& sh
->default_track
)
1581 for (i
= 0; i
< MAX_A_STREAMS
; ++i
) {
1582 sh_audio_t
*sh
= d
->a_streams
[i
];
1589 int demuxer_default_sub_track(demuxer_t
*d
)
1592 for (i
= 0; i
< MAX_S_STREAMS
; ++i
) {
1593 sh_sub_t
*sh
= d
->s_streams
[i
];
1594 if (sh
&& sh
->default_track
)