4 * This file is part of MPlayer.
6 * MPlayer is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * MPlayer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
34 #include "libvo/fastmemcpy.h"
36 #include "stream/stream.h"
41 #include "libaf/af_format.h"
42 #include "libmpcodecs/dec_teletext.h"
45 #include "libass/ass.h"
46 #include "libass/ass_mp.h"
49 #ifdef CONFIG_LIBAVCODEC
50 #include "libavcodec/avcodec.h"
51 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE
52 #error MP_INPUT_BUFFER_PADDING_SIZE is too small!
56 // This is quite experimental, in particular it will mess up the pts values
57 // in the queue - on the other hand it might fix some issues like generating
58 // broken files with mencoder and stream copy.
59 // Better leave it disabled for now, if we find no use for it this code should
60 // just be removed again.
61 #define PARSE_ON_ADD 0
63 static void clear_parser(sh_common_t
*sh
);
64 void resync_video_stream(sh_video_t
*sh_video
);
65 void resync_audio_stream(sh_audio_t
*sh_audio
);
68 extern const demuxer_desc_t demuxer_desc_rawaudio
;
69 extern const demuxer_desc_t demuxer_desc_rawvideo
;
70 extern const demuxer_desc_t demuxer_desc_tv
;
71 extern const demuxer_desc_t demuxer_desc_mf
;
72 extern const demuxer_desc_t demuxer_desc_avi
;
73 extern const demuxer_desc_t demuxer_desc_y4m
;
74 extern const demuxer_desc_t demuxer_desc_asf
;
75 extern const demuxer_desc_t demuxer_desc_real
;
76 extern const demuxer_desc_t demuxer_desc_smjpeg
;
77 extern const demuxer_desc_t demuxer_desc_matroska
;
78 extern const demuxer_desc_t demuxer_desc_realaudio
;
79 extern const demuxer_desc_t demuxer_desc_vqf
;
80 extern const demuxer_desc_t demuxer_desc_mov
;
81 extern const demuxer_desc_t demuxer_desc_vivo
;
82 extern const demuxer_desc_t demuxer_desc_fli
;
83 extern const demuxer_desc_t demuxer_desc_film
;
84 extern const demuxer_desc_t demuxer_desc_roq
;
85 extern const demuxer_desc_t demuxer_desc_gif
;
86 extern const demuxer_desc_t demuxer_desc_ogg
;
87 extern const demuxer_desc_t demuxer_desc_avs
;
88 extern const demuxer_desc_t demuxer_desc_pva
;
89 extern const demuxer_desc_t demuxer_desc_nsv
;
90 extern const demuxer_desc_t demuxer_desc_mpeg_ts
;
91 extern const demuxer_desc_t demuxer_desc_lmlm4
;
92 extern const demuxer_desc_t demuxer_desc_mpeg_ps
;
93 extern const demuxer_desc_t demuxer_desc_mpeg_pes
;
94 extern const demuxer_desc_t demuxer_desc_mpeg_es
;
95 extern const demuxer_desc_t demuxer_desc_mpeg_gxf
;
96 extern const demuxer_desc_t demuxer_desc_mpeg4_es
;
97 extern const demuxer_desc_t demuxer_desc_h264_es
;
98 extern const demuxer_desc_t demuxer_desc_rawdv
;
99 extern const demuxer_desc_t demuxer_desc_mpc
;
100 extern const demuxer_desc_t demuxer_desc_audio
;
101 extern const demuxer_desc_t demuxer_desc_xmms
;
102 extern const demuxer_desc_t demuxer_desc_mpeg_ty
;
103 extern const demuxer_desc_t demuxer_desc_rtp
;
104 extern const demuxer_desc_t demuxer_desc_rtp_nemesi
;
105 extern const demuxer_desc_t demuxer_desc_lavf
;
106 extern const demuxer_desc_t demuxer_desc_lavf_preferred
;
107 extern const demuxer_desc_t demuxer_desc_aac
;
108 extern const demuxer_desc_t demuxer_desc_nut
;
109 extern const demuxer_desc_t demuxer_desc_mng
;
111 /* Please do not add any new demuxers here. If you want to implement a new
112 * demuxer, add it to libavformat, except for wrappers around external
113 * libraries and demuxers requiring binary support. */
115 const demuxer_desc_t
*const demuxer_list
[] = {
116 &demuxer_desc_rawaudio
,
117 &demuxer_desc_rawvideo
,
122 #ifdef CONFIG_LIBAVFORMAT
123 &demuxer_desc_lavf_preferred
,
130 &demuxer_desc_smjpeg
,
131 &demuxer_desc_matroska
,
132 &demuxer_desc_realaudio
,
142 #ifdef CONFIG_OGGVORBIS
145 #ifdef CONFIG_WIN32DLL
149 &demuxer_desc_mpeg_ts
,
151 &demuxer_desc_mpeg_ps
,
152 &demuxer_desc_mpeg_pes
,
153 &demuxer_desc_mpeg_es
,
154 &demuxer_desc_mpeg_gxf
,
155 &demuxer_desc_mpeg4_es
,
156 &demuxer_desc_h264_es
,
158 &demuxer_desc_mpeg_ty
,
159 #ifdef CONFIG_LIVE555
162 #ifdef CONFIG_LIBNEMESI
163 &demuxer_desc_rtp_nemesi
,
165 #ifdef CONFIG_LIBAVFORMAT
168 #ifdef CONFIG_MUSEPACK
171 #ifdef CONFIG_LIBDV095
184 /* Please do not add any new demuxers here. If you want to implement a new
185 * demuxer, add it to libavformat, except for wrappers around external
186 * libraries and demuxers requiring binary support. */
190 void free_demuxer_stream(demux_stream_t
*ds
)
196 demux_stream_t
*new_demuxer_stream(struct demuxer_st
*demuxer
, int id
)
198 demux_stream_t
*ds
= malloc(sizeof(demux_stream_t
));
199 *ds
= (demux_stream_t
){
209 * Get demuxer description structure for a given demuxer type
211 * @param file_format type of the demuxer
212 * @return structure for the demuxer, NULL if not found
214 static const demuxer_desc_t
*get_demuxer_desc_from_type(int file_format
)
218 for (i
= 0; demuxer_list
[i
]; i
++)
219 if (file_format
== demuxer_list
[i
]->type
)
220 return demuxer_list
[i
];
226 demuxer_t
*new_demuxer(stream_t
*stream
, int type
, int a_id
, int v_id
,
227 int s_id
, char *filename
)
229 demuxer_t
*d
= malloc(sizeof(demuxer_t
));
230 memset(d
, 0, sizeof(demuxer_t
));
232 d
->stream_pts
= MP_NOPTS_VALUE
;
233 d
->reference_clock
= MP_NOPTS_VALUE
;
234 d
->movi_start
= stream
->start_pos
;
235 d
->movi_end
= stream
->end_pos
;
239 d
->audio
= new_demuxer_stream(d
, a_id
);
240 d
->video
= new_demuxer_stream(d
, v_id
);
241 d
->sub
= new_demuxer_stream(d
, s_id
);
244 if (!(d
->desc
= get_demuxer_desc_from_type(type
)))
245 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
246 "BUG! Invalid demuxer type in new_demuxer(), "
247 "big troubles ahead.");
248 if (filename
) // Filename hack for avs_check_file
249 d
->filename
= strdup(filename
);
250 stream_reset(stream
);
251 stream_seek(stream
, stream
->start_pos
);
255 extern int dvdsub_id
;
257 sh_sub_t
*new_sh_sub_sid(demuxer_t
*demuxer
, int id
, int sid
)
259 if (id
> MAX_S_STREAMS
- 1 || id
< 0) {
260 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
261 "Requested sub stream id overflow (%d > %d)\n", id
,
265 if (demuxer
->s_streams
[id
])
266 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, "Sub stream %i redefined\n", id
);
268 sh_sub_t
*sh
= calloc(1, sizeof(sh_sub_t
));
269 demuxer
->s_streams
[id
] = sh
;
271 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SUBTITLE_ID=%d\n", sid
);
273 if (sid
== dvdsub_id
) {
274 demuxer
->sub
->id
= id
;
275 demuxer
->sub
->sh
= demuxer
->s_streams
[id
];
277 return demuxer
->s_streams
[id
];
280 void free_sh_sub(sh_sub_t
*sh
)
282 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_sub at %p\n", sh
);
286 ass_free_track(sh
->ass_track
);
289 #ifdef CONFIG_LIBAVCODEC
290 clear_parser((sh_common_t
*)sh
);
295 sh_audio_t
*new_sh_audio_aid(demuxer_t
*demuxer
, int id
, int aid
)
297 if (id
> MAX_A_STREAMS
- 1 || id
< 0) {
298 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
299 "Requested audio stream id overflow (%d > %d)\n", id
,
303 if (demuxer
->a_streams
[id
])
304 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, MSGTR_AudioStreamRedefined
, id
);
306 sh_audio_t
*sh
= calloc(1, sizeof(sh_audio_t
));
307 mp_msg(MSGT_DEMUXER
, MSGL_V
, MSGTR_FoundAudioStream
, id
);
308 demuxer
->a_streams
[id
] = sh
;
310 sh
->ds
= demuxer
->audio
;
313 sh
->sample_format
= AF_FORMAT_S16_NE
;
314 sh
->audio_out_minsize
= 8192; /* default size, maybe not enough for Win32/ACM */
315 sh
->pts
= MP_NOPTS_VALUE
;
316 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AUDIO_ID=%d\n", aid
);
318 return demuxer
->a_streams
[id
];
321 void free_sh_audio(demuxer_t
*demuxer
, int id
)
323 sh_audio_t
*sh
= demuxer
->a_streams
[id
];
324 demuxer
->a_streams
[id
] = NULL
;
325 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_audio at %p\n", sh
);
329 #ifdef CONFIG_LIBAVCODEC
330 clear_parser((sh_common_t
*)sh
);
335 sh_video_t
*new_sh_video_vid(demuxer_t
*demuxer
, int id
, int vid
)
337 if (id
> MAX_V_STREAMS
- 1 || id
< 0) {
338 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
339 "Requested video stream id overflow (%d > %d)\n", id
,
343 if (demuxer
->v_streams
[id
])
344 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, MSGTR_VideoStreamRedefined
, id
);
346 sh_video_t
*sh
= calloc(1, sizeof(sh_video_t
));
347 mp_msg(MSGT_DEMUXER
, MSGL_V
, MSGTR_FoundVideoStream
, id
);
348 demuxer
->v_streams
[id
] = sh
;
350 sh
->ds
= demuxer
->video
;
351 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VIDEO_ID=%d\n", vid
);
353 return demuxer
->v_streams
[id
];
356 void free_sh_video(sh_video_t
*sh
)
358 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_video at %p\n", sh
);
360 #ifdef CONFIG_LIBAVCODEC
361 clear_parser((sh_common_t
*)sh
);
366 void free_demuxer(demuxer_t
*demuxer
)
369 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing demuxer at %p\n",
371 if (demuxer
->desc
->close
)
372 demuxer
->desc
->close(demuxer
);
373 // Very ugly hack to make it behave like old implementation
374 if (demuxer
->desc
->type
== DEMUXER_TYPE_DEMUXERS
)
375 goto skip_streamfree
;
377 for (i
= 0; i
< MAX_A_STREAMS
; i
++)
378 if (demuxer
->a_streams
[i
])
379 free_sh_audio(demuxer
, i
);
380 for (i
= 0; i
< MAX_V_STREAMS
; i
++)
381 if (demuxer
->v_streams
[i
])
382 free_sh_video(demuxer
->v_streams
[i
]);
383 for (i
= 0; i
< MAX_S_STREAMS
; i
++)
384 if (demuxer
->s_streams
[i
])
385 free_sh_sub(demuxer
->s_streams
[i
]);
387 free_demuxer_stream(demuxer
->audio
);
388 free_demuxer_stream(demuxer
->video
);
389 free_demuxer_stream(demuxer
->sub
);
392 for (i
= 0; demuxer
->info
[i
] != NULL
; i
++)
393 free(demuxer
->info
[i
]);
396 free(demuxer
->filename
);
397 if (demuxer
->chapters
) {
398 for (i
= 0; i
< demuxer
->num_chapters
; i
++)
399 free(demuxer
->chapters
[i
].name
);
400 free(demuxer
->chapters
);
402 if (demuxer
->attachments
) {
403 for (i
= 0; i
< demuxer
->num_attachments
; i
++) {
404 free(demuxer
->attachments
[i
].name
);
405 free(demuxer
->attachments
[i
].type
);
406 free(demuxer
->attachments
[i
].data
);
408 free(demuxer
->attachments
);
410 if (demuxer
->teletext
)
411 teletext_control(demuxer
->teletext
, TV_VBI_CONTROL_STOP
, NULL
);
416 static void ds_add_packet_internal(demux_stream_t
*ds
, demux_packet_t
*dp
)
418 // append packet to DS stream:
420 ds
->bytes
+= dp
->len
;
422 // next packet in stream
426 // first packet in stream
427 ds
->first
= ds
->last
= dp
;
429 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
430 "DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n",
431 (ds
== ds
->demuxer
->audio
) ? "d_audio" : "d_video", dp
->len
,
432 dp
->pts
, (unsigned int) dp
->pos
, ds
->demuxer
->audio
->packs
,
433 ds
->demuxer
->video
->packs
);
436 #ifdef CONFIG_LIBAVCODEC
437 static void allocate_parser(AVCodecContext
**avctx
, AVCodecParserContext
**parser
, unsigned format
)
439 enum CodecID codec_id
= CODEC_ID_NONE
;
440 extern int avcodec_initialized
;
441 if (!avcodec_initialized
) {
443 avcodec_register_all();
444 avcodec_initialized
= 1;
450 case MKTAG('d', 'n', 'e', 't'):
451 case MKTAG('s', 'a', 'c', '3'):
452 codec_id
= CODEC_ID_AC3
;
454 case MKTAG('E', 'A', 'C', '3'):
455 codec_id
= CODEC_ID_EAC3
;
459 codec_id
= CODEC_ID_DTS
;
463 case MKTAG('.', 'm', 'p', '3'):
464 case MKTAG('M', 'P', 'E', ' '):
465 case MKTAG('L', 'A', 'M', 'E'):
466 codec_id
= CODEC_ID_MP3
;
469 case MKTAG('.', 'm', 'p', '2'):
470 case MKTAG('.', 'm', 'p', '1'):
471 codec_id
= CODEC_ID_MP2
;
474 if (codec_id
!= CODEC_ID_NONE
) {
475 *avctx
= avcodec_alloc_context();
478 *parser
= av_parser_init(codec_id
);
484 static void get_parser(sh_common_t
*sh
, AVCodecContext
**avctx
, AVCodecParserContext
**parser
)
489 if (!sh
|| !sh
->needs_parsing
)
493 *parser
= sh
->parser
;
497 allocate_parser(avctx
, parser
, sh
->format
);
499 sh
->parser
= *parser
;
502 int ds_parse(demux_stream_t
*ds
, uint8_t **buffer
, int *len
, double pts
, off_t pos
)
504 AVCodecContext
*avctx
;
505 AVCodecParserContext
*parser
;
506 get_parser(ds
->sh
, &avctx
, &parser
);
509 return av_parser_parse2(parser
, avctx
, buffer
, len
, *buffer
, *len
, pts
, pts
, pos
);
512 static void clear_parser(sh_common_t
*sh
)
514 av_parser_close(sh
->parser
);
516 av_freep(&sh
->avctx
);
519 void ds_clear_parser(demux_stream_t
*ds
)
523 clear_parser(ds
->sh
);
527 void ds_add_packet(demux_stream_t
*ds
, demux_packet_t
*dp
)
529 #if PARSE_ON_ADD && defined(CONFIG_LIBAVCODEC)
533 uint8_t *parsed_start
= dp
->buffer
+ pos
;
534 int parsed_len
= len
;
535 int consumed
= ds_parse(ds
->sh
, &parsed_start
, &parsed_len
, dp
->pts
, dp
->pos
);
538 if (parsed_start
== dp
->buffer
&& parsed_len
== dp
->len
) {
539 ds_add_packet_internal(ds
, dp
);
540 } else if (parsed_len
) {
541 demux_packet_t
*dp2
= new_demux_packet(parsed_len
);
543 dp2
->pts
= dp
->pts
; // should be parser->pts but that works badly
544 memcpy(dp2
->buffer
, parsed_start
, parsed_len
);
545 ds_add_packet_internal(ds
, dp2
);
549 ds_add_packet_internal(ds
, dp
);
553 void ds_read_packet(demux_stream_t
*ds
, stream_t
*stream
, int len
,
554 double pts
, off_t pos
, int flags
)
556 demux_packet_t
*dp
= new_demux_packet(len
);
557 len
= stream_read(stream
, dp
->buffer
, len
);
558 resize_demux_packet(dp
, len
);
562 // append packet to DS stream:
563 ds_add_packet(ds
, dp
);
567 // 0 = EOF or no stream found or invalid type
568 // 1 = successfully read a packet
570 int demux_fill_buffer(demuxer_t
*demux
, demux_stream_t
*ds
)
572 // Note: parameter 'ds' can be NULL!
573 return demux
->desc
->fill_buffer(demux
, ds
);
579 #define MAX_ACUMULATED_PACKETS 64
580 int ds_fill_buffer(demux_stream_t
*ds
)
582 demuxer_t
*demux
= ds
->demuxer
;
584 free_demux_packet(ds
->current
);
586 if (mp_msg_test(MSGT_DEMUXER
, MSGL_DBG3
)) {
587 if (ds
== demux
->audio
)
588 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
589 "ds_fill_buffer(d_audio) called\n");
590 else if (ds
== demux
->video
)
591 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
592 "ds_fill_buffer(d_video) called\n");
593 else if (ds
== demux
->sub
)
594 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
, "ds_fill_buffer(d_sub) called\n");
596 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
597 "ds_fill_buffer(unknown 0x%X) called\n", (unsigned int) ds
);
601 demux_packet_t
*p
= ds
->first
;
603 if (demux
->reference_clock
!= MP_NOPTS_VALUE
) {
604 if ( p
->pts
!= MP_NOPTS_VALUE
605 && p
->pts
> demux
->reference_clock
606 && ds
->packs
< MAX_ACUMULATED_PACKETS
) {
607 if (demux_fill_buffer(demux
, ds
))
613 ds
->buffer
= p
->buffer
;
615 ds
->buffer_size
= p
->len
;
617 ds
->dpos
+= p
->len
; // !!!
619 if (p
->pts
!= MP_NOPTS_VALUE
) {
623 ds
->pts_bytes
+= p
->len
; // !!!
624 if (p
->stream_pts
!= MP_NOPTS_VALUE
)
625 demux
->stream_pts
= p
->stream_pts
;
626 ds
->flags
= p
->flags
;
636 if (demux
->audio
->packs
>= MAX_PACKS
637 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
638 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyAudioInBuffer
,
639 demux
->audio
->packs
, demux
->audio
->bytes
);
640 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
643 if (demux
->video
->packs
>= MAX_PACKS
644 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
645 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyVideoInBuffer
,
646 demux
->video
->packs
, demux
->video
->bytes
);
647 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
650 if (!demux_fill_buffer(demux
, ds
)) {
651 #if PARSE_ON_ADD && defined(CONFIG_LIBAVCODEC)
652 uint8_t *parsed_start
= NULL
;
654 ds_parse(ds
->sh
, &parsed_start
, &parsed_len
, MP_NOPTS_VALUE
, 0);
656 demux_packet_t
*dp2
= new_demux_packet(parsed_len
);
657 dp2
->pts
= MP_NOPTS_VALUE
;
658 memcpy(dp2
->buffer
, parsed_start
, parsed_len
);
659 ds_add_packet_internal(ds
, dp2
);
663 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
664 "ds_fill_buffer()->demux_fill_buffer() failed\n");
668 ds
->buffer_pos
= ds
->buffer_size
= 0;
670 mp_msg(MSGT_DEMUXER
, MSGL_V
,
671 "ds_fill_buffer: EOF reached (stream: %s) \n",
672 ds
== demux
->audio
? "audio" : "video");
677 int demux_read_data(demux_stream_t
*ds
, unsigned char *mem
, int len
)
682 x
= ds
->buffer_size
- ds
->buffer_pos
;
684 if (!ds_fill_buffer(ds
))
690 fast_memcpy(mem
+ bytes
, &ds
->buffer
[ds
->buffer_pos
], x
);
700 * \brief read data until the given 3-byte pattern is encountered, up to maxlen
701 * \param mem memory to read data into, may be NULL to discard data
702 * \param maxlen maximum number of bytes to read
703 * \param read number of bytes actually read
704 * \param pattern pattern to search for (lowest 8 bits are ignored)
705 * \return whether pattern was found
707 int demux_pattern_3(demux_stream_t
*ds
, unsigned char *mem
, int maxlen
,
708 int *read
, uint32_t pattern
)
710 register uint32_t head
= 0xffffff00;
711 register uint32_t pat
= pattern
& 0xffffff00;
714 register unsigned char *ds_buf
= &ds
->buffer
[ds
->buffer_size
];
715 int len
= ds
->buffer_size
- ds
->buffer_pos
;
716 register long pos
= -len
;
717 if (unlikely(pos
>= 0)) { // buffer is empty
724 } while (++pos
&& head
!= pat
);
726 if (total_len
+ len
> maxlen
)
727 len
= maxlen
- total_len
;
728 len
= demux_read_data(ds
, mem
? &mem
[total_len
] : NULL
, len
);
730 } while ((head
!= pat
|| total_len
< 3) && total_len
< maxlen
&& !ds
->eof
);
733 return total_len
>= 3 && head
== pat
;
736 void ds_free_packs(demux_stream_t
*ds
)
738 demux_packet_t
*dp
= ds
->first
;
740 demux_packet_t
*dn
= dp
->next
;
741 free_demux_packet(dp
);
744 if (ds
->asf_packet
) {
745 // free unfinished .asf fragments:
746 free(ds
->asf_packet
->buffer
);
747 free(ds
->asf_packet
);
748 ds
->asf_packet
= NULL
;
750 ds
->first
= ds
->last
= NULL
;
751 ds
->packs
= 0; // !!!!!
754 free_demux_packet(ds
->current
);
757 ds
->buffer_pos
= ds
->buffer_size
;
762 int ds_get_packet(demux_stream_t
*ds
, unsigned char **start
)
765 if (ds
->buffer_pos
>= ds
->buffer_size
) {
766 if (!ds_fill_buffer(ds
)) {
772 len
= ds
->buffer_size
- ds
->buffer_pos
;
773 *start
= &ds
->buffer
[ds
->buffer_pos
];
774 ds
->buffer_pos
+= len
;
778 int ds_get_packet_pts(demux_stream_t
*ds
, unsigned char **start
, double *pts
)
781 *pts
= MP_NOPTS_VALUE
;
782 len
= ds_get_packet(ds
, start
);
785 // Return pts unless this read starts from the middle of a packet
786 if (len
== ds
->buffer_pos
)
787 *pts
= ds
->current
->pts
;
791 int ds_get_packet_sub(demux_stream_t
*ds
, unsigned char **start
)
794 if (ds
->buffer_pos
>= ds
->buffer_size
) {
798 if (!ds_fill_buffer(ds
))
801 len
= ds
->buffer_size
- ds
->buffer_pos
;
802 *start
= &ds
->buffer
[ds
->buffer_pos
];
803 ds
->buffer_pos
+= len
;
807 double ds_get_next_pts(demux_stream_t
*ds
)
809 demuxer_t
*demux
= ds
->demuxer
;
811 if (demux
->audio
->packs
>= MAX_PACKS
812 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
813 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyAudioInBuffer
,
814 demux
->audio
->packs
, demux
->audio
->bytes
);
815 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
816 return MP_NOPTS_VALUE
;
818 if (demux
->video
->packs
>= MAX_PACKS
819 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
820 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_TooManyVideoInBuffer
,
821 demux
->video
->packs
, demux
->video
->bytes
);
822 mp_msg(MSGT_DEMUXER
, MSGL_HINT
, MSGTR_MaybeNI
);
823 return MP_NOPTS_VALUE
;
825 if (!demux_fill_buffer(demux
, ds
))
826 return MP_NOPTS_VALUE
;
828 return ds
->first
->pts
;
831 // ====================================================================
833 void demuxer_help(void)
837 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "Available demuxers:\n");
838 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " demuxer: type info: (comment)\n");
839 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_DEMUXERS\n");
840 for (i
= 0; demuxer_list
[i
]; i
++) {
841 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Don't display special demuxers
843 if (demuxer_list
[i
]->comment
&& strlen(demuxer_list
[i
]->comment
))
844 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s (%s)\n",
845 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
,
846 demuxer_list
[i
]->info
, demuxer_list
[i
]->comment
);
848 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s\n",
849 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
,
850 demuxer_list
[i
]->info
);
856 * Get demuxer type for a given demuxer name
858 * @param demuxer_name string with demuxer name of demuxer number
859 * @param force will be set if demuxer should be forced.
861 * @return DEMUXER_TYPE_xxx, -1 if error or not found
863 int get_demuxer_type_from_name(char *demuxer_name
, int *force
)
869 if (!demuxer_name
|| !demuxer_name
[0])
870 return DEMUXER_TYPE_UNKNOWN
;
872 *force
= demuxer_name
[0] == '+';
873 if (demuxer_name
[0] == '+')
874 demuxer_name
= &demuxer_name
[1];
875 for (i
= 0; demuxer_list
[i
]; i
++) {
876 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Can't select special demuxers from commandline
878 if (strcmp(demuxer_name
, demuxer_list
[i
]->name
) == 0)
879 return demuxer_list
[i
]->type
;
882 // No match found, try to parse name as an integer (demuxer number)
883 type_int
= strtol(demuxer_name
, &endptr
, 0);
884 if (*endptr
) // Conversion failed
886 if ((type_int
> 0) && (type_int
<= DEMUXER_TYPE_MAX
))
887 return (int) type_int
;
892 int extension_parsing
= 1; // 0=off 1=mixed (used only for unstable formats)
895 int user_correct_pts
= -1;
898 NOTE : Several demuxers may be opened at the same time so
899 demuxers should NEVER rely on an external var to enable them
900 self. If a demuxer can't do any auto-detection it should only use
901 file_format. The user can explicitly set file_format with the -demuxer
902 option so there is really no need for another extra var.
903 For convenience an option can be added to set file_format directly
904 to the right type (ex: rawaudio,rawvideo).
905 Also the stream can override the file_format so a demuxer which rely
906 on a special stream type can set file_format at the stream level
910 static demuxer_t
*demux_open_stream(stream_t
*stream
, int file_format
,
911 int force
, int audio_id
, int video_id
,
912 int dvdsub_id
, char *filename
)
914 demuxer_t
*demuxer
= NULL
;
916 sh_video_t
*sh_video
= NULL
;
918 const demuxer_desc_t
*demuxer_desc
;
922 // If somebody requested a demuxer check it
924 if ((demuxer_desc
= get_demuxer_desc_from_type(file_format
))) {
925 demuxer
= new_demuxer(stream
, demuxer_desc
->type
, audio_id
,
926 video_id
, dvdsub_id
, filename
);
927 if (demuxer_desc
->check_file
)
928 fformat
= demuxer_desc
->check_file(demuxer
);
929 if (force
|| !demuxer_desc
->check_file
)
930 fformat
= demuxer_desc
->type
;
932 if (fformat
== demuxer_desc
->type
) {
933 demuxer_t
*demux2
= demuxer
;
934 // Move messages to demuxer detection code?
935 mp_msg(MSGT_DEMUXER
, MSGL_INFO
,
936 MSGTR_Detected_XXX_FileFormat
,
937 demuxer_desc
->shortdesc
);
938 file_format
= fformat
;
939 if (!demuxer
->desc
->open
940 || (demux2
= demuxer
->desc
->open(demuxer
))) {
945 // Format changed after check, recurse
946 free_demuxer(demuxer
);
947 return demux_open_stream(stream
, fformat
, force
, audio_id
,
948 video_id
, dvdsub_id
, filename
);
951 // Check failed for forced demuxer, quit
952 free_demuxer(demuxer
);
956 // Test demuxers with safe file checks
957 for (i
= 0; (demuxer_desc
= demuxer_list
[i
]); i
++) {
958 if (demuxer_desc
->safe_check
) {
959 demuxer
= new_demuxer(stream
, demuxer_desc
->type
, audio_id
,
960 video_id
, dvdsub_id
, filename
);
961 if ((fformat
= demuxer_desc
->check_file(demuxer
)) != 0) {
962 if (fformat
== demuxer_desc
->type
) {
963 demuxer_t
*demux2
= demuxer
;
964 mp_msg(MSGT_DEMUXER
, MSGL_INFO
,
965 MSGTR_Detected_XXX_FileFormat
,
966 demuxer_desc
->shortdesc
);
967 file_format
= fformat
;
968 if (!demuxer
->desc
->open
969 || (demux2
= demuxer
->desc
->open(demuxer
))) {
974 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
975 return demuxer
; // handled in mplayer.c
976 // Format changed after check, recurse
977 free_demuxer(demuxer
);
978 demuxer
= demux_open_stream(stream
, fformat
, force
,
980 dvdsub_id
, filename
);
982 return demuxer
; // done!
983 file_format
= DEMUXER_TYPE_UNKNOWN
;
986 free_demuxer(demuxer
);
991 // If no forced demuxer perform file extension based detection
992 // Ok. We're over the stable detectable fileformats, the next ones are
993 // a bit fuzzy. So by default (extension_parsing==1) try extension-based
995 if (file_format
== DEMUXER_TYPE_UNKNOWN
&& filename
996 && extension_parsing
== 1) {
997 file_format
= demuxer_type_by_filename(filename
);
998 if (file_format
!= DEMUXER_TYPE_UNKNOWN
) {
999 // we like recursion :)
1000 demuxer
= demux_open_stream(stream
, file_format
, force
, audio_id
,
1001 video_id
, dvdsub_id
, filename
);
1003 return demuxer
; // done!
1004 file_format
= DEMUXER_TYPE_UNKNOWN
; // continue fuzzy guessing...
1005 mp_msg(MSGT_DEMUXER
, MSGL_V
,
1006 "demuxer: continue fuzzy content-based format guessing...\n");
1009 // Try detection for all other demuxers
1010 for (i
= 0; (demuxer_desc
= demuxer_list
[i
]); i
++) {
1011 if (!demuxer_desc
->safe_check
&& demuxer_desc
->check_file
) {
1012 demuxer
= new_demuxer(stream
, demuxer_desc
->type
, audio_id
,
1013 video_id
, dvdsub_id
, filename
);
1014 if ((fformat
= demuxer_desc
->check_file(demuxer
)) != 0) {
1015 if (fformat
== demuxer_desc
->type
) {
1016 demuxer_t
*demux2
= demuxer
;
1017 mp_msg(MSGT_DEMUXER
, MSGL_INFO
,
1018 MSGTR_Detected_XXX_FileFormat
,
1019 demuxer_desc
->shortdesc
);
1020 file_format
= fformat
;
1021 if (!demuxer
->desc
->open
1022 || (demux2
= demuxer
->desc
->open(demuxer
))) {
1027 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
1028 return demuxer
; // handled in mplayer.c
1029 // Format changed after check, recurse
1030 free_demuxer(demuxer
);
1031 demuxer
= demux_open_stream(stream
, fformat
, force
,
1033 dvdsub_id
, filename
);
1035 return demuxer
; // done!
1036 file_format
= DEMUXER_TYPE_UNKNOWN
;
1039 free_demuxer(demuxer
);
1045 //====== File format recognized, set up these for compatibility: =========
1048 demuxer
->file_format
= file_format
;
1050 if ((sh_video
= demuxer
->video
->sh
) && sh_video
->bih
) {
1051 int biComp
= le2me_32(sh_video
->bih
->biCompression
);
1052 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
1053 "VIDEO: [%.4s] %dx%d %dbpp %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n",
1054 (char *) &biComp
, sh_video
->bih
->biWidth
,
1055 sh_video
->bih
->biHeight
, sh_video
->bih
->biBitCount
,
1056 sh_video
->fps
, sh_video
->i_bps
* 0.008f
,
1057 sh_video
->i_bps
/ 1024.0f
);
1060 if (ass_enabled
&& ass_library
) {
1061 for (i
= 0; i
< MAX_S_STREAMS
; ++i
) {
1062 sh_sub_t
*sh
= demuxer
->s_streams
[i
];
1063 if (sh
&& sh
->type
== 'a') {
1064 sh
->ass_track
= ass_new_track(ass_library
);
1065 if (sh
->ass_track
&& sh
->extradata
)
1066 ass_process_codec_private(sh
->ass_track
, sh
->extradata
,
1068 } else if (sh
&& sh
->type
!= 'v')
1069 sh
->ass_track
= ass_default_track(ass_library
);
1076 char *audio_stream
= NULL
;
1077 char *sub_stream
= NULL
;
1078 int audio_stream_cache
= 0;
1080 char *demuxer_name
= NULL
; // parameter from -demuxer
1081 char *audio_demuxer_name
= NULL
; // parameter from -audio-demuxer
1082 char *sub_demuxer_name
= NULL
; // parameter from -sub-demuxer
1084 extern int hr_mp3_seek
;
1086 extern float stream_cache_min_percent
;
1087 extern float stream_cache_seek_min_percent
;
1089 demuxer_t
*demux_open(stream_t
*vs
, int file_format
, int audio_id
,
1090 int video_id
, int dvdsub_id
, char *filename
)
1092 stream_t
*as
= NULL
, *ss
= NULL
;
1093 demuxer_t
*vd
, *ad
= NULL
, *sd
= NULL
;
1095 int afmt
= DEMUXER_TYPE_UNKNOWN
, sfmt
= DEMUXER_TYPE_UNKNOWN
;
1097 int audio_demuxer_type
= 0, sub_demuxer_type
= 0;
1098 int demuxer_force
= 0, audio_demuxer_force
= 0, sub_demuxer_force
= 0;
1101 get_demuxer_type_from_name(demuxer_name
, &demuxer_force
)) < 0) {
1102 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-demuxer %s does not exist.\n",
1105 if ((audio_demuxer_type
=
1106 get_demuxer_type_from_name(audio_demuxer_name
,
1107 &audio_demuxer_force
)) < 0) {
1108 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-audio-demuxer %s does not exist.\n",
1109 audio_demuxer_name
);
1111 if ((sub_demuxer_type
=
1112 get_demuxer_type_from_name(sub_demuxer_name
,
1113 &sub_demuxer_force
)) < 0) {
1114 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-sub-demuxer %s does not exist.\n",
1119 as
= open_stream(audio_stream
, 0, &afmt
);
1121 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_CannotOpenAudioStream
,
1125 if (audio_stream_cache
) {
1126 if (!stream_enable_cache
1127 (as
, audio_stream_cache
* 1024,
1128 audio_stream_cache
* 1024 * (stream_cache_min_percent
/
1130 audio_stream_cache
* 1024 * (stream_cache_seek_min_percent
/
1133 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
1134 "Can't enable audio stream cache\n");
1140 ss
= open_stream(sub_stream
, 0, &sfmt
);
1142 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, MSGTR_CannotOpenSubtitlesStream
,
1148 vd
= demux_open_stream(vs
, demuxer_type
? demuxer_type
: file_format
,
1149 demuxer_force
, audio_stream
? -2 : audio_id
,
1150 video_id
, sub_stream
? -2 : dvdsub_id
, filename
);
1159 ad
= demux_open_stream(as
,
1160 audio_demuxer_type
? audio_demuxer_type
: afmt
,
1161 audio_demuxer_force
, audio_id
, -2, -2,
1164 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, MSGTR_OpeningAudioDemuxerFailed
,
1167 } else if (ad
->audio
->sh
1168 && ((sh_audio_t
*) ad
->audio
->sh
)->format
== 0x55) // MP3
1169 hr_mp3_seek
= 1; // Enable high res seeking
1172 sd
= demux_open_stream(ss
, sub_demuxer_type
? sub_demuxer_type
: sfmt
,
1173 sub_demuxer_force
, -2, -2, dvdsub_id
,
1176 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
1177 MSGTR_OpeningSubtitlesDemuxerFailed
, sub_stream
);
1183 res
= new_demuxers_demuxer(vd
, ad
, sd
);
1185 res
= new_demuxers_demuxer(vd
, ad
, vd
);
1187 res
= new_demuxers_demuxer(vd
, vd
, sd
);
1191 correct_pts
= user_correct_pts
;
1192 if (correct_pts
< 0)
1193 correct_pts
= demux_control(res
, DEMUXER_CTRL_CORRECT_PTS
, NULL
)
1198 static void demux_resync(demuxer_t
*demuxer
)
1200 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1201 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1202 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1204 ds_fill_buffer(demuxer
->video
);
1205 resync_video_stream(sh_video
);
1208 ds_fill_buffer(demuxer
->audio
);
1209 resync_audio_stream(sh_audio
);
1213 void demux_flush(demuxer_t
*demuxer
)
1216 ds_clear_parser(demuxer
->video
);
1217 ds_clear_parser(demuxer
->audio
);
1218 ds_clear_parser(demuxer
->sub
);
1220 ds_free_packs(demuxer
->video
);
1221 ds_free_packs(demuxer
->audio
);
1222 ds_free_packs(demuxer
->sub
);
1225 int demux_seek(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
,
1231 if (!demuxer
->seekable
) {
1232 if (demuxer
->file_format
== DEMUXER_TYPE_AVI
)
1233 mp_msg(MSGT_SEEK
, MSGL_WARN
, MSGTR_CantSeekRawAVI
);
1235 else if (demuxer
->file_format
== DEMUXER_TYPE_TV
)
1236 mp_msg(MSGT_SEEK
, MSGL_WARN
, MSGTR_TVInputNotSeekable
);
1239 mp_msg(MSGT_SEEK
, MSGL_WARN
, MSGTR_CantSeekFile
);
1243 demux_flush(demuxer
);
1245 demuxer
->stream
->eof
= 0;
1246 demuxer
->video
->eof
= 0;
1247 demuxer
->audio
->eof
= 0;
1249 if (flags
& SEEK_ABSOLUTE
)
1252 if (demuxer
->stream_pts
== MP_NOPTS_VALUE
)
1254 pts
= demuxer
->stream_pts
;
1257 if (flags
& SEEK_FACTOR
) {
1258 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_TIME_LENGTH
, &tmp
)
1259 == STREAM_UNSUPPORTED
)
1261 pts
+= tmp
* rel_seek_secs
;
1263 pts
+= rel_seek_secs
;
1265 if (stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_TIME
, &pts
) !=
1266 STREAM_UNSUPPORTED
) {
1267 demux_resync(demuxer
);
1272 if (demuxer
->desc
->seek
)
1273 demuxer
->desc
->seek(demuxer
, rel_seek_secs
, audio_delay
, flags
);
1275 demux_resync(demuxer
);
1280 int demux_info_add(demuxer_t
*demuxer
, const char *opt
, const char *param
)
1282 char **info
= demuxer
->info
;
1286 for (n
= 0; info
&& info
[2 * n
] != NULL
; n
++) {
1287 if (!strcasecmp(opt
, info
[2 * n
])) {
1288 if (!strcmp(param
, info
[2 * n
+ 1])) {
1289 mp_msg(MSGT_DEMUX
, MSGL_V
, "Demuxer info %s set to unchanged value %s\n", opt
, param
);
1292 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_DemuxerInfoChanged
, opt
,
1294 free(info
[2 * n
+ 1]);
1295 info
[2 * n
+ 1] = strdup(param
);
1300 info
= demuxer
->info
= (char **) realloc(info
,
1301 (2 * (n
+ 2)) * sizeof(char *));
1302 info
[2 * n
] = strdup(opt
);
1303 info
[2 * n
+ 1] = strdup(param
);
1304 memset(&info
[2 * (n
+ 1)], 0, 2 * sizeof(char *));
1309 int demux_info_print(demuxer_t
*demuxer
)
1311 char **info
= demuxer
->info
;
1317 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_ClipInfo
);
1318 for (n
= 0; info
[2 * n
] != NULL
; n
++) {
1319 mp_msg(MSGT_DEMUX
, MSGL_INFO
, " %s: %s\n", info
[2 * n
],
1321 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_NAME%d=%s\n", n
,
1323 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_VALUE%d=%s\n", n
,
1326 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_N=%d\n", n
);
1331 char *demux_info_get(demuxer_t
*demuxer
, const char *opt
)
1334 char **info
= demuxer
->info
;
1336 for (i
= 0; info
&& info
[2 * i
] != NULL
; i
++) {
1337 if (!strcasecmp(opt
, info
[2 * i
]))
1338 return info
[2 * i
+ 1];
1344 int demux_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
1347 if (demuxer
->desc
->control
)
1348 return demuxer
->desc
->control(demuxer
, cmd
, arg
);
1350 return DEMUXER_CTRL_NOTIMPL
;
1355 double demuxer_get_time_length(demuxer_t
*demuxer
)
1357 double get_time_ans
;
1358 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1359 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1360 // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW
1362 (demuxer
, DEMUXER_CTRL_GET_TIME_LENGTH
, (void *) &get_time_ans
) <= 0) {
1363 if (sh_video
&& sh_video
->i_bps
&& sh_audio
&& sh_audio
->i_bps
)
1364 get_time_ans
= (double) (demuxer
->movi_end
-
1365 demuxer
->movi_start
) / (sh_video
->i_bps
+
1367 else if (sh_video
&& sh_video
->i_bps
)
1368 get_time_ans
= (double) (demuxer
->movi_end
-
1369 demuxer
->movi_start
) / sh_video
->i_bps
;
1370 else if (sh_audio
&& sh_audio
->i_bps
)
1371 get_time_ans
= (double) (demuxer
->movi_end
-
1372 demuxer
->movi_start
) / sh_audio
->i_bps
;
1376 return get_time_ans
;
1380 * \brief demuxer_get_current_time() returns the time of the current play in three possible ways:
1381 * either when the stream reader satisfies STREAM_CTRL_GET_CURRENT_TIME (e.g. dvd)
1382 * or using sh_video->pts when the former method fails
1384 * \return the current play time
1386 int demuxer_get_current_time(demuxer_t
*demuxer
)
1388 double get_time_ans
= 0;
1389 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1390 if (demuxer
->stream_pts
!= MP_NOPTS_VALUE
)
1391 get_time_ans
= demuxer
->stream_pts
;
1393 get_time_ans
= sh_video
->pts
;
1394 return (int) get_time_ans
;
1397 int demuxer_get_percent_pos(demuxer_t
*demuxer
)
1400 int res
= demux_control(demuxer
, DEMUXER_CTRL_GET_PERCENT_POS
, &ans
);
1401 int len
= (demuxer
->movi_end
- demuxer
->movi_start
) / 100;
1403 off_t pos
= demuxer
->filepos
> 0 ? demuxer
->filepos
: stream_tell(demuxer
->stream
);
1405 ans
= (pos
- demuxer
->movi_start
) / len
;
1416 int demuxer_switch_audio(demuxer_t
*demuxer
, int index
)
1418 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_AUDIO
, &index
);
1419 if (res
== DEMUXER_CTRL_NOTIMPL
)
1420 index
= demuxer
->audio
->id
;
1421 if (demuxer
->audio
->id
>= 0)
1422 demuxer
->audio
->sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
1424 demuxer
->audio
->sh
= NULL
;
1428 int demuxer_switch_video(demuxer_t
*demuxer
, int index
)
1430 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_VIDEO
, &index
);
1431 if (res
== DEMUXER_CTRL_NOTIMPL
)
1432 index
= demuxer
->video
->id
;
1433 if (demuxer
->video
->id
>= 0)
1434 demuxer
->video
->sh
= demuxer
->v_streams
[demuxer
->video
->id
];
1436 demuxer
->video
->sh
= NULL
;
1440 int demuxer_add_attachment(demuxer_t
*demuxer
, const char *name
,
1441 const char *type
, const void *data
, size_t size
)
1443 if (!(demuxer
->num_attachments
& 31))
1444 demuxer
->attachments
= realloc(demuxer
->attachments
,
1445 (demuxer
->num_attachments
+ 32) * sizeof(demux_attachment_t
));
1447 demuxer
->attachments
[demuxer
->num_attachments
].name
= strdup(name
);
1448 demuxer
->attachments
[demuxer
->num_attachments
].type
= strdup(type
);
1449 demuxer
->attachments
[demuxer
->num_attachments
].data
= malloc(size
);
1450 memcpy(demuxer
->attachments
[demuxer
->num_attachments
].data
, data
, size
);
1451 demuxer
->attachments
[demuxer
->num_attachments
].data_size
= size
;
1453 return demuxer
->num_attachments
++;
1456 int demuxer_add_chapter(demuxer_t
*demuxer
, const char *name
, uint64_t start
,
1459 if (demuxer
->chapters
== NULL
)
1460 demuxer
->chapters
= malloc(32 * sizeof(*demuxer
->chapters
));
1461 else if (!(demuxer
->num_chapters
% 32))
1462 demuxer
->chapters
= realloc(demuxer
->chapters
,
1463 (demuxer
->num_chapters
+ 32) *
1464 sizeof(*demuxer
->chapters
));
1466 demuxer
->chapters
[demuxer
->num_chapters
].start
= start
;
1467 demuxer
->chapters
[demuxer
->num_chapters
].end
= end
;
1468 demuxer
->chapters
[demuxer
->num_chapters
].name
= strdup(name
? name
: MSGTR_Unknown
);
1470 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_ID=%d\n", demuxer
->num_chapters
);
1471 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_%d_START=%"PRIu64
"\n", demuxer
->num_chapters
, start
);
1473 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_%d_END=%"PRIu64
"\n", demuxer
->num_chapters
, end
);
1475 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_%d_NAME=%s\n", demuxer
->num_chapters
, name
);
1477 return demuxer
->num_chapters
++;
1481 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1482 * either using the demuxer->chapters structure set by the demuxer
1483 * or asking help to the stream layer (e.g. dvd)
1484 * \param chapter - chapter number wished - 0-based
1485 * \param mode 0: relative to current main pts, 1: absolute
1486 * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1487 * \param num_chapters number of chapters present (set by this function is param is not null)
1488 * \param chapter_name name of chapter found (set by this function is param is not null)
1489 * \return -1 on error, current chapter if successful
1492 int demuxer_seek_chapter(demuxer_t
*demuxer
, int chapter
, int mode
,
1493 float *seek_pts
, int *num_chapters
,
1494 char **chapter_name
)
1499 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1501 ris
= stream_control(demuxer
->stream
,
1502 STREAM_CTRL_GET_CURRENT_CHAPTER
, ¤t
);
1503 if (ris
== STREAM_UNSUPPORTED
)
1508 demux_flush(demuxer
);
1510 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_CHAPTER
,
1513 demux_resync(demuxer
);
1515 // exit status may be ok, but main() doesn't have to seek itself
1516 // (because e.g. dvds depend on sectors, not on pts)
1520 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1521 num_chapters
) == STREAM_UNSUPPORTED
)
1526 *chapter_name
= NULL
;
1527 if (num_chapters
&& *num_chapters
) {
1528 char *tmp
= malloc(16);
1530 sprintf(tmp
, " of %3d", *num_chapters
);
1531 *chapter_name
= tmp
;
1536 return ris
!= STREAM_UNSUPPORTED
? chapter
: -1;
1537 } else { // chapters structure is set in the demuxer
1538 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1539 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1541 total
= demuxer
->num_chapters
;
1543 if (mode
== 1) //absolute seeking
1545 else { //relative seeking
1547 now
= (sh_video
? sh_video
->pts
: (sh_audio
? sh_audio
->pts
: 0.))
1550 for (current
= total
- 1; current
>= 0; --current
) {
1551 demux_chapter_t
*chapter
= demuxer
->chapters
+ current
;
1552 if (chapter
->start
<= now
)
1558 if (current
>= total
)
1563 *seek_pts
= demuxer
->chapters
[current
].start
/ 1000.0;
1566 *num_chapters
= demuxer
->num_chapters
;
1569 if (demuxer
->chapters
[current
].name
)
1570 *chapter_name
= strdup(demuxer
->chapters
[current
].name
);
1572 *chapter_name
= NULL
;
1579 int demuxer_get_current_chapter(demuxer_t
*demuxer
)
1582 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1583 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_CURRENT_CHAPTER
,
1584 &chapter
) == STREAM_UNSUPPORTED
)
1587 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1588 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1590 now
= (sh_video
? sh_video
->pts
: (sh_audio
? sh_audio
->pts
: 0))
1592 for (chapter
= demuxer
->num_chapters
- 1; chapter
>= 0; --chapter
) {
1593 if (demuxer
->chapters
[chapter
].start
<= now
)
1600 char *demuxer_chapter_name(demuxer_t
*demuxer
, int chapter
)
1602 if (demuxer
->num_chapters
&& demuxer
->chapters
) {
1603 if (chapter
>= 0 && chapter
< demuxer
->num_chapters
1604 && demuxer
->chapters
[chapter
].name
)
1605 return strdup(demuxer
->chapters
[chapter
].name
);
1610 char *demuxer_chapter_display_name(demuxer_t
*demuxer
, int chapter
)
1612 char *chapter_name
= demuxer_chapter_name(demuxer
, chapter
);
1614 char *tmp
= malloc(strlen(chapter_name
) + 14);
1615 snprintf(tmp
, 63, "(%d) %s", chapter
+ 1, chapter_name
);
1619 int chapter_num
= demuxer_chapter_count(demuxer
);
1621 if (chapter_num
<= 0)
1622 sprintf(tmp
, "(%d)", chapter
+ 1);
1624 sprintf(tmp
, "(%d) of %d", chapter
+ 1, chapter_num
);
1629 float demuxer_chapter_time(demuxer_t
*demuxer
, int chapter
, float *end
)
1631 if (demuxer
->num_chapters
&& demuxer
->chapters
&& chapter
>= 0
1632 && chapter
< demuxer
->num_chapters
) {
1634 *end
= demuxer
->chapters
[chapter
].end
/ 1000.0;
1635 return demuxer
->chapters
[chapter
].start
/ 1000.0;
1640 int demuxer_chapter_count(demuxer_t
*demuxer
)
1642 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1643 int num_chapters
= 0;
1644 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1645 &num_chapters
) == STREAM_UNSUPPORTED
)
1647 return num_chapters
;
1649 return demuxer
->num_chapters
;
1652 int demuxer_angles_count(demuxer_t
*demuxer
)
1654 int ris
, angles
= -1;
1656 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_ANGLES
, &angles
);
1657 if (ris
== STREAM_UNSUPPORTED
)
1662 int demuxer_get_current_angle(demuxer_t
*demuxer
)
1664 int ris
, curr_angle
= -1;
1665 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_ANGLE
, &curr_angle
);
1666 if (ris
== STREAM_UNSUPPORTED
)
1672 int demuxer_set_angle(demuxer_t
*demuxer
, int angle
)
1674 int ris
, angles
= -1;
1676 angles
= demuxer_angles_count(demuxer
);
1677 if ((angles
< 1) || (angle
> angles
))
1680 demux_flush(demuxer
);
1682 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SET_ANGLE
, &angle
);
1683 if (ris
== STREAM_UNSUPPORTED
)
1686 demux_resync(demuxer
);
1691 int demuxer_audio_track_by_lang(demuxer_t
*d
, char *lang
)
1694 lang
+= strspn(lang
, ",");
1695 while ((len
= strcspn(lang
, ",")) > 0) {
1696 for (i
= 0; i
< MAX_A_STREAMS
; ++i
) {
1697 sh_audio_t
*sh
= d
->a_streams
[i
];
1698 if (sh
&& sh
->lang
&& strncmp(sh
->lang
, lang
, len
) == 0)
1702 lang
+= strspn(lang
, ",");
1707 int demuxer_sub_track_by_lang(demuxer_t
*d
, char *lang
)
1710 lang
+= strspn(lang
, ",");
1711 while ((len
= strcspn(lang
, ",")) > 0) {
1712 for (i
= 0; i
< MAX_S_STREAMS
; ++i
) {
1713 sh_sub_t
*sh
= d
->s_streams
[i
];
1714 if (sh
&& sh
->lang
&& strncmp(sh
->lang
, lang
, len
) == 0)
1718 lang
+= strspn(lang
, ",");
1723 int demuxer_default_audio_track(demuxer_t
*d
)
1726 for (i
= 0; i
< MAX_A_STREAMS
; ++i
) {
1727 sh_audio_t
*sh
= d
->a_streams
[i
];
1728 if (sh
&& sh
->default_track
)
1731 for (i
= 0; i
< MAX_A_STREAMS
; ++i
) {
1732 sh_audio_t
*sh
= d
->a_streams
[i
];
1739 int demuxer_default_sub_track(demuxer_t
*d
)
1742 for (i
= 0; i
< MAX_S_STREAMS
; ++i
) {
1743 sh_sub_t
*sh
= d
->s_streams
[i
];
1744 if (sh
&& sh
->default_track
)