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>
35 #include "libvo/fastmemcpy.h"
37 #include "stream/stream.h"
42 #include "libaf/af_format.h"
43 #include "libmpcodecs/dec_teletext.h"
44 #include "libmpcodecs/vd_ffmpeg.h"
49 #include "libavcodec/avcodec.h"
50 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE
51 #error MP_INPUT_BUFFER_PADDING_SIZE is too small!
55 // This is quite experimental, in particular it will mess up the pts values
56 // in the queue - on the other hand it might fix some issues like generating
57 // broken files with mencoder and stream copy.
58 // Better leave it disabled for now, if we find no use for it this code should
59 // just be removed again.
60 #define PARSE_ON_ADD 0
62 static void clear_parser(sh_common_t
*sh
);
65 extern const demuxer_desc_t demuxer_desc_rawaudio
;
66 extern const demuxer_desc_t demuxer_desc_rawvideo
;
67 extern const demuxer_desc_t demuxer_desc_tv
;
68 extern const demuxer_desc_t demuxer_desc_mf
;
69 extern const demuxer_desc_t demuxer_desc_avi
;
70 extern const demuxer_desc_t demuxer_desc_y4m
;
71 extern const demuxer_desc_t demuxer_desc_asf
;
72 extern const demuxer_desc_t demuxer_desc_real
;
73 extern const demuxer_desc_t demuxer_desc_smjpeg
;
74 extern const demuxer_desc_t demuxer_desc_matroska
;
75 extern const demuxer_desc_t demuxer_desc_realaudio
;
76 extern const demuxer_desc_t demuxer_desc_vqf
;
77 extern const demuxer_desc_t demuxer_desc_mov
;
78 extern const demuxer_desc_t demuxer_desc_vivo
;
79 extern const demuxer_desc_t demuxer_desc_fli
;
80 extern const demuxer_desc_t demuxer_desc_film
;
81 extern const demuxer_desc_t demuxer_desc_roq
;
82 extern const demuxer_desc_t demuxer_desc_gif
;
83 extern const demuxer_desc_t demuxer_desc_ogg
;
84 extern const demuxer_desc_t demuxer_desc_avs
;
85 extern const demuxer_desc_t demuxer_desc_pva
;
86 extern const demuxer_desc_t demuxer_desc_nsv
;
87 extern const demuxer_desc_t demuxer_desc_mpeg_ts
;
88 extern const demuxer_desc_t demuxer_desc_lmlm4
;
89 extern const demuxer_desc_t demuxer_desc_mpeg_ps
;
90 extern const demuxer_desc_t demuxer_desc_mpeg_pes
;
91 extern const demuxer_desc_t demuxer_desc_mpeg_es
;
92 extern const demuxer_desc_t demuxer_desc_mpeg_gxf
;
93 extern const demuxer_desc_t demuxer_desc_mpeg4_es
;
94 extern const demuxer_desc_t demuxer_desc_h264_es
;
95 extern const demuxer_desc_t demuxer_desc_rawdv
;
96 extern const demuxer_desc_t demuxer_desc_mpc
;
97 extern const demuxer_desc_t demuxer_desc_audio
;
98 extern const demuxer_desc_t demuxer_desc_xmms
;
99 extern const demuxer_desc_t demuxer_desc_mpeg_ty
;
100 extern const demuxer_desc_t demuxer_desc_rtp
;
101 extern const demuxer_desc_t demuxer_desc_rtp_nemesi
;
102 extern const demuxer_desc_t demuxer_desc_lavf
;
103 extern const demuxer_desc_t demuxer_desc_lavf_preferred
;
104 extern const demuxer_desc_t demuxer_desc_aac
;
105 extern const demuxer_desc_t demuxer_desc_nut
;
106 extern const demuxer_desc_t demuxer_desc_mng
;
108 /* Please do not add any new demuxers here. If you want to implement a new
109 * demuxer, add it to libavformat, except for wrappers around external
110 * libraries and demuxers requiring binary support. */
112 const demuxer_desc_t
*const demuxer_list
[] = {
113 &demuxer_desc_rawaudio
,
114 &demuxer_desc_rawvideo
,
120 &demuxer_desc_lavf_preferred
,
127 &demuxer_desc_smjpeg
,
128 &demuxer_desc_matroska
,
129 &demuxer_desc_realaudio
,
139 #ifdef CONFIG_OGGVORBIS
142 #ifdef CONFIG_WIN32DLL
146 &demuxer_desc_mpeg_ts
,
148 &demuxer_desc_mpeg_ps
,
149 &demuxer_desc_mpeg_pes
,
150 &demuxer_desc_mpeg_es
,
151 &demuxer_desc_mpeg_gxf
,
152 &demuxer_desc_mpeg4_es
,
153 &demuxer_desc_h264_es
,
155 &demuxer_desc_mpeg_ty
,
156 #ifdef CONFIG_LIVE555
159 #ifdef CONFIG_LIBNEMESI
160 &demuxer_desc_rtp_nemesi
,
165 #ifdef CONFIG_MUSEPACK
168 #ifdef CONFIG_LIBDV095
181 /* Please do not add any new demuxers here. If you want to implement a new
182 * demuxer, add it to libavformat, except for wrappers around external
183 * libraries and demuxers requiring binary support. */
187 void free_demuxer_stream(demux_stream_t
*ds
)
193 demux_stream_t
*new_demuxer_stream(struct demuxer
*demuxer
, int id
)
195 demux_stream_t
*ds
= malloc(sizeof(demux_stream_t
));
196 *ds
= (demux_stream_t
){
206 * Get demuxer description structure for a given demuxer type
208 * @param file_format type of the demuxer
209 * @return structure for the demuxer, NULL if not found
211 static const demuxer_desc_t
*get_demuxer_desc_from_type(int file_format
)
215 for (i
= 0; demuxer_list
[i
]; i
++)
216 if (file_format
== demuxer_list
[i
]->type
)
217 return demuxer_list
[i
];
223 demuxer_t
*new_demuxer(struct MPOpts
*opts
, stream_t
*stream
, int type
,
224 int a_id
, int v_id
, int s_id
, char *filename
)
226 struct demuxer
*d
= talloc_zero(NULL
, struct demuxer
);
228 d
->stream_pts
= MP_NOPTS_VALUE
;
229 d
->reference_clock
= MP_NOPTS_VALUE
;
230 d
->movi_start
= stream
->start_pos
;
231 d
->movi_end
= stream
->end_pos
;
235 d
->audio
= new_demuxer_stream(d
, a_id
);
236 d
->video
= new_demuxer_stream(d
, v_id
);
237 d
->sub
= new_demuxer_stream(d
, s_id
);
241 if (!(d
->desc
= get_demuxer_desc_from_type(type
)))
242 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
243 "BUG! Invalid demuxer type in new_demuxer(), "
244 "big troubles ahead.");
245 if (filename
) // Filename hack for avs_check_file
246 d
->filename
= strdup(filename
);
247 stream_seek(stream
, stream
->start_pos
);
251 const char *sh_sub_type2str(int type
)
254 case 't': return "text";
255 case 'm': return "movtext";
256 case 'a': return "ass";
257 case 'v': return "vobsub";
258 case 'x': return "xsub";
259 case 'b': return "dvb";
260 case 'd': return "dvb-teletext";
261 case 'p': return "hdmv pgs";
266 sh_sub_t
*new_sh_sub_sid(demuxer_t
*demuxer
, int id
, int sid
)
268 if (id
> MAX_S_STREAMS
- 1 || id
< 0) {
269 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
270 "Requested sub stream id overflow (%d > %d)\n", id
,
274 if (demuxer
->s_streams
[id
])
275 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, "Sub stream %i redefined\n", id
);
277 sh_sub_t
*sh
= calloc(1, sizeof(sh_sub_t
));
278 demuxer
->s_streams
[id
] = sh
;
280 sh
->opts
= demuxer
->opts
;
281 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SUBTITLE_ID=%d\n", sid
);
283 if (sid
== demuxer
->opts
->sub_id
) {
284 demuxer
->sub
->id
= id
;
285 demuxer
->sub
->sh
= demuxer
->s_streams
[id
];
287 return demuxer
->s_streams
[id
];
290 struct sh_sub
*new_sh_sub_sid_lang(struct demuxer
*demuxer
, int id
, int sid
,
293 struct sh_sub
*sh
= new_sh_sub_sid(demuxer
, id
, sid
);
294 if (lang
&& lang
[0] && strcmp(lang
, "und")) {
295 sh
->lang
= strdup(lang
);
296 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
, lang
);
301 static void free_sh_sub(sh_sub_t
*sh
)
303 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_sub at %p\n", sh
);
307 ass_free_track(sh
->ass_track
);
311 clear_parser((sh_common_t
*)sh
);
316 sh_audio_t
*new_sh_audio_aid(demuxer_t
*demuxer
, int id
, int aid
)
318 if (id
> MAX_A_STREAMS
- 1 || id
< 0) {
319 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
320 "Requested audio stream id overflow (%d > %d)\n", id
,
324 if (demuxer
->a_streams
[id
]) {
325 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
, "WARNING: Audio stream header %d redefined.\n", id
);
327 mp_tmsg(MSGT_DEMUXER
, MSGL_V
, "==> Found audio stream: %d\n", id
);
328 sh_audio_t
*sh
= calloc(1, sizeof(sh_audio_t
));
329 demuxer
->a_streams
[id
] = sh
;
331 sh
->ds
= demuxer
->audio
;
334 sh
->sample_format
= AF_FORMAT_S16_NE
;
335 sh
->opts
= demuxer
->opts
;
336 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AUDIO_ID=%d\n", aid
);
338 return demuxer
->a_streams
[id
];
341 void free_sh_audio(demuxer_t
*demuxer
, int id
)
343 sh_audio_t
*sh
= demuxer
->a_streams
[id
];
344 demuxer
->a_streams
[id
] = NULL
;
345 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_audio at %p\n", sh
);
350 clear_parser((sh_common_t
*)sh
);
355 sh_video_t
*new_sh_video_vid(demuxer_t
*demuxer
, int id
, int vid
)
357 if (id
> MAX_V_STREAMS
- 1 || id
< 0) {
358 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
359 "Requested video stream id overflow (%d > %d)\n", id
,
363 if (demuxer
->v_streams
[id
])
364 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
, "WARNING: Video stream header %d redefined.\n", id
);
366 mp_tmsg(MSGT_DEMUXER
, MSGL_V
, "==> Found video stream: %d\n", id
);
367 sh_video_t
*sh
= calloc(1, sizeof *sh
);
368 demuxer
->v_streams
[id
] = sh
;
370 sh
->ds
= demuxer
->video
;
371 sh
->opts
= demuxer
->opts
;
372 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VIDEO_ID=%d\n", vid
);
374 return demuxer
->v_streams
[id
];
377 void free_sh_video(sh_video_t
*sh
)
379 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_video at %p\n", sh
);
382 clear_parser((sh_common_t
*)sh
);
387 void free_demuxer(demuxer_t
*demuxer
)
390 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing %s demuxer at %p\n",
391 demuxer
->desc
->shortdesc
, demuxer
);
392 if (demuxer
->desc
->close
)
393 demuxer
->desc
->close(demuxer
);
394 // Very ugly hack to make it behave like old implementation
395 if (demuxer
->desc
->type
== DEMUXER_TYPE_DEMUXERS
)
396 goto skip_streamfree
;
398 for (i
= 0; i
< MAX_A_STREAMS
; i
++)
399 if (demuxer
->a_streams
[i
])
400 free_sh_audio(demuxer
, i
);
401 for (i
= 0; i
< MAX_V_STREAMS
; i
++)
402 if (demuxer
->v_streams
[i
])
403 free_sh_video(demuxer
->v_streams
[i
]);
404 for (i
= 0; i
< MAX_S_STREAMS
; i
++)
405 if (demuxer
->s_streams
[i
])
406 free_sh_sub(demuxer
->s_streams
[i
]);
408 free_demuxer_stream(demuxer
->audio
);
409 free_demuxer_stream(demuxer
->video
);
410 free_demuxer_stream(demuxer
->sub
);
412 free(demuxer
->filename
);
413 if (demuxer
->teletext
)
414 teletext_control(demuxer
->teletext
, TV_VBI_CONTROL_STOP
, NULL
);
415 talloc_free(demuxer
);
419 static void ds_add_packet_internal(demux_stream_t
*ds
, demux_packet_t
*dp
)
421 // append packet to DS stream:
423 ds
->bytes
+= dp
->len
;
425 // next packet in stream
429 // first packet in stream
430 ds
->first
= ds
->last
= dp
;
432 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
433 "DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n",
434 (ds
== ds
->demuxer
->audio
) ? "d_audio" : "d_video", dp
->len
,
435 dp
->pts
, (unsigned int) dp
->pos
, ds
->demuxer
->audio
->packs
,
436 ds
->demuxer
->video
->packs
);
440 static void allocate_parser(AVCodecContext
**avctx
, AVCodecParserContext
**parser
, unsigned format
)
442 enum CodecID codec_id
= CODEC_ID_NONE
;
447 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 94, 0)
448 case MKTAG('M', 'P', '4', 'L'):
449 codec_id
= CODEC_ID_AAC_LATM
;
456 case MKTAG('d', 'n', 'e', 't'):
457 case MKTAG('s', 'a', 'c', '3'):
458 codec_id
= CODEC_ID_AC3
;
460 case MKTAG('E', 'A', 'C', '3'):
461 codec_id
= CODEC_ID_EAC3
;
465 codec_id
= CODEC_ID_DTS
;
467 case MKTAG('M', 'L', 'P', ' '):
468 codec_id
= CODEC_ID_MLP
;
473 case MKTAG('.', 'm', 'p', '3'):
474 case MKTAG('M', 'P', '3', ' '):
475 case MKTAG('L', 'A', 'M', 'E'):
476 codec_id
= CODEC_ID_MP3
;
480 case MKTAG('.', 'm', 'p', '2'):
481 case MKTAG('.', 'm', 'p', '1'):
482 codec_id
= CODEC_ID_MP2
;
484 case MKTAG('T', 'R', 'H', 'D'):
485 codec_id
= CODEC_ID_TRUEHD
;
488 if (codec_id
!= CODEC_ID_NONE
) {
489 *avctx
= avcodec_alloc_context();
492 *parser
= av_parser_init(codec_id
);
498 static void get_parser(sh_common_t
*sh
, AVCodecContext
**avctx
, AVCodecParserContext
**parser
)
503 if (!sh
|| !sh
->needs_parsing
)
507 *parser
= sh
->parser
;
511 allocate_parser(avctx
, parser
, sh
->format
);
513 sh
->parser
= *parser
;
516 int ds_parse(demux_stream_t
*ds
, uint8_t **buffer
, int *len
, double pts
, off_t pos
)
518 AVCodecContext
*avctx
;
519 AVCodecParserContext
*parser
;
520 get_parser(ds
->sh
, &avctx
, &parser
);
523 return av_parser_parse2(parser
, avctx
, buffer
, len
, *buffer
, *len
, pts
, pts
, pos
);
526 static void clear_parser(sh_common_t
*sh
)
528 av_parser_close(sh
->parser
);
530 av_freep(&sh
->avctx
);
533 void ds_clear_parser(demux_stream_t
*ds
)
537 clear_parser(ds
->sh
);
541 void ds_add_packet(demux_stream_t
*ds
, demux_packet_t
*dp
)
543 #if PARSE_ON_ADD && defined(CONFIG_FFMPEG)
547 uint8_t *parsed_start
= dp
->buffer
+ pos
;
548 int parsed_len
= len
;
549 int consumed
= ds_parse(ds
->sh
, &parsed_start
, &parsed_len
, dp
->pts
, dp
->pos
);
552 if (parsed_start
== dp
->buffer
&& parsed_len
== dp
->len
) {
553 ds_add_packet_internal(ds
, dp
);
554 } else if (parsed_len
) {
555 demux_packet_t
*dp2
= new_demux_packet(parsed_len
);
557 dp2
->pts
= dp
->pts
; // should be parser->pts but that works badly
558 memcpy(dp2
->buffer
, parsed_start
, parsed_len
);
559 ds_add_packet_internal(ds
, dp2
);
563 ds_add_packet_internal(ds
, dp
);
567 void ds_read_packet(demux_stream_t
*ds
, stream_t
*stream
, int len
,
568 double pts
, off_t pos
, int flags
)
570 demux_packet_t
*dp
= new_demux_packet(len
);
571 len
= stream_read(stream
, dp
->buffer
, len
);
572 resize_demux_packet(dp
, len
);
576 // append packet to DS stream:
577 ds_add_packet(ds
, dp
);
581 // 0 = EOF or no stream found or invalid type
582 // 1 = successfully read a packet
584 int demux_fill_buffer(demuxer_t
*demux
, demux_stream_t
*ds
)
586 // Note: parameter 'ds' can be NULL!
587 return demux
->desc
->fill_buffer(demux
, ds
);
593 #define MAX_ACUMULATED_PACKETS 64
594 int ds_fill_buffer(demux_stream_t
*ds
)
596 demuxer_t
*demux
= ds
->demuxer
;
598 free_demux_packet(ds
->current
);
600 if (mp_msg_test(MSGT_DEMUXER
, MSGL_DBG3
)) {
601 if (ds
== demux
->audio
)
602 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
603 "ds_fill_buffer(d_audio) called\n");
604 else if (ds
== demux
->video
)
605 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
606 "ds_fill_buffer(d_video) called\n");
607 else if (ds
== demux
->sub
)
608 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
, "ds_fill_buffer(d_sub) called\n");
610 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
,
611 "ds_fill_buffer(unknown 0x%X) called\n", (unsigned int) ds
);
615 demux_packet_t
*p
= ds
->first
;
617 if (demux
->reference_clock
!= MP_NOPTS_VALUE
) {
618 if ( p
->pts
!= MP_NOPTS_VALUE
619 && p
->pts
> demux
->reference_clock
620 && ds
->packs
< MAX_ACUMULATED_PACKETS
) {
621 if (demux_fill_buffer(demux
, ds
))
627 ds
->buffer
= p
->buffer
;
629 ds
->buffer_size
= p
->len
;
631 ds
->dpos
+= p
->len
; // !!!
633 if (p
->pts
!= MP_NOPTS_VALUE
) {
637 ds
->pts_bytes
+= p
->len
; // !!!
638 if (p
->stream_pts
!= MP_NOPTS_VALUE
)
639 demux
->stream_pts
= p
->stream_pts
;
640 ds
->flags
= p
->flags
;
648 /* The code below can set ds->eof to 1 when another stream runs
649 * out of buffer space. That makes sense because in that situation
650 * the calling code should not count on being able to demux more
651 * packets from this stream.
652 * If however the situation improves and we're called again
653 * despite the eof flag then it's better to clear it to avoid
659 #define MaybeNI _("Maybe you are playing a non-interleaved stream/file or the codec failed?\n" \
660 "For AVI files, try to force non-interleaved mode with the -ni option.\n")
662 if (demux
->audio
->packs
>= MAX_PACKS
663 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
664 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many audio packets in the buffer: (%d in %d bytes).\n",
665 demux
->audio
->packs
, demux
->audio
->bytes
);
666 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
669 if (demux
->video
->packs
>= MAX_PACKS
670 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
671 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many video packets in the buffer: (%d in %d bytes).\n",
672 demux
->video
->packs
, demux
->video
->bytes
);
673 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
676 if (!demux_fill_buffer(demux
, ds
)) {
677 #if PARSE_ON_ADD && defined(CONFIG_FFMPEG)
678 uint8_t *parsed_start
= NULL
;
680 ds_parse(ds
->sh
, &parsed_start
, &parsed_len
, MP_NOPTS_VALUE
, 0);
682 demux_packet_t
*dp2
= new_demux_packet(parsed_len
);
683 dp2
->pts
= MP_NOPTS_VALUE
;
684 memcpy(dp2
->buffer
, parsed_start
, parsed_len
);
685 ds_add_packet_internal(ds
, dp2
);
689 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
690 "ds_fill_buffer()->demux_fill_buffer() failed\n");
694 ds
->buffer_pos
= ds
->buffer_size
= 0;
696 mp_msg(MSGT_DEMUXER
, MSGL_V
,
697 "ds_fill_buffer: EOF reached (stream: %s) \n",
698 ds
== demux
->audio
? "audio" : "video");
703 int demux_read_data(demux_stream_t
*ds
, unsigned char *mem
, int len
)
708 x
= ds
->buffer_size
- ds
->buffer_pos
;
710 if (!ds_fill_buffer(ds
))
716 fast_memcpy(mem
+ bytes
, &ds
->buffer
[ds
->buffer_pos
], x
);
726 * \brief read data until the given 3-byte pattern is encountered, up to maxlen
727 * \param mem memory to read data into, may be NULL to discard data
728 * \param maxlen maximum number of bytes to read
729 * \param read number of bytes actually read
730 * \param pattern pattern to search for (lowest 8 bits are ignored)
731 * \return whether pattern was found
733 int demux_pattern_3(demux_stream_t
*ds
, unsigned char *mem
, int maxlen
,
734 int *read
, uint32_t pattern
)
736 register uint32_t head
= 0xffffff00;
737 register uint32_t pat
= pattern
& 0xffffff00;
740 register unsigned char *ds_buf
= &ds
->buffer
[ds
->buffer_size
];
741 int len
= ds
->buffer_size
- ds
->buffer_pos
;
742 register long pos
= -len
;
743 if (unlikely(pos
>= 0)) { // buffer is empty
750 } while (++pos
&& head
!= pat
);
752 if (total_len
+ len
> maxlen
)
753 len
= maxlen
- total_len
;
754 len
= demux_read_data(ds
, mem
? &mem
[total_len
] : NULL
, len
);
756 } while ((head
!= pat
|| total_len
< 3) && total_len
< maxlen
&& !ds
->eof
);
759 return total_len
>= 3 && head
== pat
;
762 void ds_free_packs(demux_stream_t
*ds
)
764 demux_packet_t
*dp
= ds
->first
;
766 demux_packet_t
*dn
= dp
->next
;
767 free_demux_packet(dp
);
770 if (ds
->asf_packet
) {
771 // free unfinished .asf fragments:
772 free(ds
->asf_packet
->buffer
);
773 free(ds
->asf_packet
);
774 ds
->asf_packet
= NULL
;
776 ds
->first
= ds
->last
= NULL
;
777 ds
->packs
= 0; // !!!!!
780 free_demux_packet(ds
->current
);
783 ds
->buffer_pos
= ds
->buffer_size
;
788 int ds_get_packet(demux_stream_t
*ds
, unsigned char **start
)
791 if (ds
->buffer_pos
>= ds
->buffer_size
) {
792 if (!ds_fill_buffer(ds
)) {
798 len
= ds
->buffer_size
- ds
->buffer_pos
;
799 *start
= &ds
->buffer
[ds
->buffer_pos
];
800 ds
->buffer_pos
+= len
;
804 int ds_get_packet_pts(demux_stream_t
*ds
, unsigned char **start
, double *pts
)
807 *pts
= MP_NOPTS_VALUE
;
808 len
= ds_get_packet(ds
, start
);
811 // Return pts unless this read starts from the middle of a packet
812 if (len
== ds
->buffer_pos
)
813 *pts
= ds
->current
->pts
;
817 int ds_get_packet_sub(demux_stream_t
*ds
, unsigned char **start
)
820 if (ds
->buffer_pos
>= ds
->buffer_size
) {
824 if (!ds_fill_buffer(ds
))
827 len
= ds
->buffer_size
- ds
->buffer_pos
;
828 *start
= &ds
->buffer
[ds
->buffer_pos
];
829 ds
->buffer_pos
+= len
;
833 double ds_get_next_pts(demux_stream_t
*ds
)
835 demuxer_t
*demux
= ds
->demuxer
;
836 // if we have not read from the "current" packet, consider it
837 // as the next, otherwise we never get the pts for the first packet.
838 while (!ds
->first
&& (!ds
->current
|| ds
->buffer_pos
)) {
839 if (demux
->audio
->packs
>= MAX_PACKS
840 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
841 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many audio packets in the buffer: (%d in %d bytes).\n",
842 demux
->audio
->packs
, demux
->audio
->bytes
);
843 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
844 return MP_NOPTS_VALUE
;
846 if (demux
->video
->packs
>= MAX_PACKS
847 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
848 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many video packets in the buffer: (%d in %d bytes).\n",
849 demux
->video
->packs
, demux
->video
->bytes
);
850 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
851 return MP_NOPTS_VALUE
;
853 if (!demux_fill_buffer(demux
, ds
))
854 return MP_NOPTS_VALUE
;
856 // take pts from "current" if we never read from it.
857 if (ds
->current
&& !ds
->buffer_pos
)
858 return ds
->current
->pts
;
859 return ds
->first
->pts
;
862 // ====================================================================
864 void demuxer_help(void)
868 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "Available demuxers:\n");
869 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " demuxer: type info: (comment)\n");
870 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_DEMUXERS\n");
871 for (i
= 0; demuxer_list
[i
]; i
++) {
872 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Don't display special demuxers
874 if (demuxer_list
[i
]->comment
&& strlen(demuxer_list
[i
]->comment
))
875 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s (%s)\n",
876 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
,
877 demuxer_list
[i
]->info
, demuxer_list
[i
]->comment
);
879 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %2d %s\n",
880 demuxer_list
[i
]->name
, demuxer_list
[i
]->type
,
881 demuxer_list
[i
]->info
);
887 * Get demuxer type for a given demuxer name
889 * @param demuxer_name string with demuxer name of demuxer number
890 * @param force will be set if demuxer should be forced.
892 * @return DEMUXER_TYPE_xxx, -1 if error or not found
894 int get_demuxer_type_from_name(char *demuxer_name
, int *force
)
900 if (!demuxer_name
|| !demuxer_name
[0])
901 return DEMUXER_TYPE_UNKNOWN
;
903 *force
= demuxer_name
[0] == '+';
904 if (demuxer_name
[0] == '+')
905 demuxer_name
= &demuxer_name
[1];
906 for (i
= 0; demuxer_list
[i
]; i
++) {
907 if (demuxer_list
[i
]->type
> DEMUXER_TYPE_MAX
) // Can't select special demuxers from commandline
909 if (strcmp(demuxer_name
, demuxer_list
[i
]->name
) == 0)
910 return demuxer_list
[i
]->type
;
913 // No match found, try to parse name as an integer (demuxer number)
914 type_int
= strtol(demuxer_name
, &endptr
, 0);
915 if (*endptr
) // Conversion failed
917 if ((type_int
> 0) && (type_int
<= DEMUXER_TYPE_MAX
))
918 return (int) type_int
;
923 static struct demuxer
*open_given_type(struct MPOpts
*opts
,
924 const struct demuxer_desc
*desc
,
925 struct stream
*stream
, bool force
,
926 int audio_id
, int video_id
, int sub_id
,
929 struct demuxer
*demuxer
;
931 demuxer
= new_demuxer(opts
, stream
, desc
->type
, audio_id
,
932 video_id
, sub_id
, filename
);
933 if (desc
->check_file
)
934 fformat
= desc
->check_file(demuxer
);
936 fformat
= desc
->type
;
938 fformat
= desc
->type
;
941 if (fformat
== desc
->type
) {
942 if (demuxer
->filetype
)
943 mp_tmsg(MSGT_DEMUXER
, MSGL_INFO
, "Detected file format: %s (%s)\n",
944 demuxer
->filetype
, desc
->shortdesc
);
946 mp_tmsg(MSGT_DEMUXER
, MSGL_INFO
, "Detected file format: %s\n",
948 if (demuxer
->desc
->open
) {
949 struct demuxer
*demux2
= demuxer
->desc
->open(demuxer
);
951 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "Opening as detected format "
952 "\"%s\" failed.\n", desc
->shortdesc
);
955 /* At least demux_mov can return a demux_demuxers instance
956 * from open() instead of the original fed in. */
959 demuxer
->file_format
= fformat
;
962 // demux_mov can return playlist instead of mov
963 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
964 return demuxer
; // handled in mplayer.c
965 /* Internal MPEG PS demuxer check can return other MPEG subtypes
966 * which don't have their own checks; recurse to try opening as
967 * the returned type instead. */
968 free_demuxer(demuxer
);
969 desc
= get_demuxer_desc_from_type(fformat
);
971 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
972 "BUG: recursion to nonexistent file format\n");
975 return open_given_type(opts
, desc
, stream
, false, audio_id
,
976 video_id
, sub_id
, filename
);
979 free_demuxer(demuxer
);
983 static struct demuxer
*demux_open_stream(struct MPOpts
*opts
,
984 struct stream
*stream
,
985 int file_format
, bool force
,
986 int audio_id
, int video_id
, int sub_id
,
989 struct demuxer
*demuxer
= NULL
;
990 const struct demuxer_desc
*desc
;
992 // If somebody requested a demuxer check it
994 desc
= get_demuxer_desc_from_type(file_format
);
996 // should only happen with obsolete -demuxer 99 numeric format
998 demuxer
= open_given_type(opts
, desc
, stream
, force
, audio_id
,
999 video_id
, sub_id
, filename
);
1005 // Test demuxers with safe file checks
1006 for (int i
= 0; (desc
= demuxer_list
[i
]); i
++) {
1007 if (desc
->safe_check
) {
1008 demuxer
= open_given_type(opts
, desc
, stream
, false, audio_id
,
1009 video_id
, sub_id
, filename
);
1015 // Ok. We're over the stable detectable fileformats, the next ones are
1016 // a bit fuzzy. So by default (extension_parsing==1) try extension-based
1018 if (filename
&& opts
->extension_parsing
== 1) {
1019 desc
= get_demuxer_desc_from_type(demuxer_type_by_filename(filename
));
1021 demuxer
= open_given_type(opts
, desc
, stream
, false, audio_id
,
1022 video_id
, sub_id
, filename
);
1027 // Finally try detection for demuxers with unsafe checks
1028 for (int i
= 0; (desc
= demuxer_list
[i
]); i
++) {
1029 if (!desc
->safe_check
&& desc
->check_file
) {
1030 demuxer
= open_given_type(opts
, desc
, stream
, false, audio_id
,
1031 video_id
, sub_id
, filename
);
1041 if (demuxer
->type
== DEMUXER_TYPE_PLAYLIST
)
1044 struct sh_video
*sh_video
= demuxer
->video
->sh
;
1045 if (sh_video
&& sh_video
->bih
) {
1046 int biComp
= le2me_32(sh_video
->bih
->biCompression
);
1047 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
1048 "VIDEO: [%.4s] %dx%d %dbpp %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n",
1049 (char *) &biComp
, sh_video
->bih
->biWidth
,
1050 sh_video
->bih
->biHeight
, sh_video
->bih
->biBitCount
,
1051 sh_video
->fps
, sh_video
->i_bps
* 0.008f
,
1052 sh_video
->i_bps
/ 1024.0f
);
1055 if (opts
->ass_enabled
&& ass_library
) {
1056 for (int i
= 0; i
< MAX_S_STREAMS
; ++i
) {
1057 sh_sub_t
*sh
= demuxer
->s_streams
[i
];
1058 if (sh
&& sh
->type
== 'a') {
1059 sh
->ass_track
= ass_new_track(ass_library
);
1060 if (sh
->ass_track
&& sh
->extradata
)
1061 ass_process_codec_private(sh
->ass_track
, sh
->extradata
,
1063 } else if (sh
&& sh
->type
!= 'v')
1064 sh
->ass_track
= ass_default_track(ass_library
);
1071 extern int hr_mp3_seek
;
1073 extern float stream_cache_min_percent
;
1074 extern float stream_cache_seek_min_percent
;
1076 demuxer_t
*demux_open(struct MPOpts
*opts
, stream_t
*vs
, int file_format
,
1077 int audio_id
, int video_id
, int dvdsub_id
,
1080 stream_t
*as
= NULL
, *ss
= NULL
;
1081 demuxer_t
*vd
, *ad
= NULL
, *sd
= NULL
;
1083 int afmt
= DEMUXER_TYPE_UNKNOWN
, sfmt
= DEMUXER_TYPE_UNKNOWN
;
1085 int audio_demuxer_type
= 0, sub_demuxer_type
= 0;
1086 int demuxer_force
= 0, audio_demuxer_force
= 0, sub_demuxer_force
= 0;
1089 get_demuxer_type_from_name(opts
->demuxer_name
, &demuxer_force
)) < 0) {
1090 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-demuxer %s does not exist.\n",
1091 opts
->demuxer_name
);
1094 if ((audio_demuxer_type
=
1095 get_demuxer_type_from_name(opts
->audio_demuxer_name
,
1096 &audio_demuxer_force
)) < 0) {
1097 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-audio-demuxer %s does not exist.\n",
1098 opts
->audio_demuxer_name
);
1099 if (opts
->audio_stream
)
1102 if ((sub_demuxer_type
=
1103 get_demuxer_type_from_name(opts
->sub_demuxer_name
,
1104 &sub_demuxer_force
)) < 0) {
1105 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-sub-demuxer %s does not exist.\n",
1106 opts
->sub_demuxer_name
);
1107 if (opts
->sub_stream
)
1111 if (opts
->audio_stream
) {
1112 as
= open_stream(opts
->audio_stream
, 0, &afmt
);
1114 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "Cannot open audio stream: %s\n",
1115 opts
->audio_stream
);
1118 if (opts
->audio_stream_cache
) {
1119 if (!stream_enable_cache
1120 (as
, opts
->audio_stream_cache
* 1024,
1121 opts
->audio_stream_cache
* 1024 *
1122 (stream_cache_min_percent
/ 100.0),
1123 opts
->audio_stream_cache
* 1024 *
1124 (stream_cache_seek_min_percent
/ 100.0))) {
1126 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
1127 "Can't enable audio stream cache\n");
1132 if (opts
->sub_stream
) {
1133 ss
= open_stream(opts
->sub_stream
, 0, &sfmt
);
1135 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "Cannot open subtitle stream: %s\n",
1141 vd
= demux_open_stream(opts
, vs
, demuxer_type
? demuxer_type
: file_format
,
1142 demuxer_force
, opts
->audio_stream
? -2 : audio_id
,
1143 video_id
, opts
->sub_stream
? -2 : dvdsub_id
, filename
);
1152 ad
= demux_open_stream(opts
, as
,
1153 audio_demuxer_type
? audio_demuxer_type
: afmt
,
1154 audio_demuxer_force
, audio_id
, -2, -2,
1155 opts
->audio_stream
);
1157 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
, "Failed to open audio demuxer: %s\n",
1158 opts
->audio_stream
);
1160 } else if (ad
->audio
->sh
1161 && ((sh_audio_t
*) ad
->audio
->sh
)->format
== 0x55) // MP3
1162 hr_mp3_seek
= 1; // Enable high res seeking
1165 sd
= demux_open_stream(opts
, ss
,
1166 sub_demuxer_type
? sub_demuxer_type
: sfmt
,
1167 sub_demuxer_force
, -2, -2, dvdsub_id
,
1170 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
,
1171 "Failed to open subtitle demuxer: %s\n", opts
->sub_stream
);
1177 res
= new_demuxers_demuxer(vd
, ad
, sd
);
1179 res
= new_demuxers_demuxer(vd
, ad
, vd
);
1181 res
= new_demuxers_demuxer(vd
, vd
, sd
);
1185 opts
->correct_pts
= opts
->user_correct_pts
;
1186 if (opts
->correct_pts
< 0)
1188 demux_control(vd
? vd
: res
, DEMUXER_CTRL_CORRECT_PTS
,
1189 NULL
) == DEMUXER_CTRL_OK
;
1194 void demux_flush(demuxer_t
*demuxer
)
1197 ds_clear_parser(demuxer
->video
);
1198 ds_clear_parser(demuxer
->audio
);
1199 ds_clear_parser(demuxer
->sub
);
1201 ds_free_packs(demuxer
->video
);
1202 ds_free_packs(demuxer
->audio
);
1203 ds_free_packs(demuxer
->sub
);
1206 int demux_seek(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
,
1209 if (!demuxer
->seekable
) {
1210 if (demuxer
->file_format
== DEMUXER_TYPE_AVI
)
1211 mp_tmsg(MSGT_SEEK
, MSGL_WARN
, "Cannot seek in raw AVI streams. (Index required, try with the -idx switch.)\n");
1213 else if (demuxer
->file_format
== DEMUXER_TYPE_TV
)
1214 mp_tmsg(MSGT_SEEK
, MSGL_WARN
, "TV input is not seekable! (Seeking will probably be for changing channels ;)\n");
1217 mp_tmsg(MSGT_SEEK
, MSGL_WARN
, "Cannot seek in this file.\n");
1220 // clear demux buffers:
1221 demux_flush(demuxer
);
1222 demuxer
->video
->eof
= 0;
1223 demuxer
->audio
->eof
= 0;
1224 demuxer
->sub
->eof
= 0;
1226 /* HACK: assume any demuxer used with these streams can cope with
1227 * the stream layer suddenly seeking to a different position under it
1228 * (nothing actually implements DEMUXER_CTRL_RESYNC now).
1230 struct stream
*stream
= demuxer
->stream
;
1231 if (stream
->type
== STREAMTYPE_DVD
|| stream
->type
== STREAMTYPE_DVDNAV
) {
1234 if (flags
& SEEK_ABSOLUTE
)
1237 if (demuxer
->stream_pts
== MP_NOPTS_VALUE
)
1239 pts
= demuxer
->stream_pts
;
1242 if (flags
& SEEK_FACTOR
) {
1244 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_TIME_LENGTH
,
1245 &tmp
) == STREAM_UNSUPPORTED
)
1247 pts
+= tmp
* rel_seek_secs
;
1249 pts
+= rel_seek_secs
;
1251 if (stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_TIME
, &pts
)
1252 != STREAM_UNSUPPORTED
) {
1253 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1259 if (demuxer
->desc
->seek
)
1260 demuxer
->desc
->seek(demuxer
, rel_seek_secs
, audio_delay
, flags
);
1265 int demux_info_add(demuxer_t
*demuxer
, const char *opt
, const char *param
)
1267 return demux_info_add_bstr(demuxer
, BSTR(opt
), BSTR(param
));
1270 int demux_info_add_bstr(demuxer_t
*demuxer
, struct bstr opt
, struct bstr param
)
1272 char **info
= demuxer
->info
;
1276 for (n
= 0; info
&& info
[2 * n
] != NULL
; n
++) {
1277 if (!bstrcasecmp(opt
, BSTR(info
[2*n
]))) {
1278 if (!bstrcmp(param
, BSTR(info
[2*n
+ 1]))) {
1279 mp_msg(MSGT_DEMUX
, MSGL_V
, "Demuxer info %.*s set to unchanged value %.*s\n",
1280 BSTR_P(opt
), BSTR_P(param
));
1283 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "Demuxer info %.*s changed to %.*s\n",
1284 BSTR_P(opt
), BSTR_P(param
));
1285 talloc_free(info
[2*n
+ 1]);
1286 info
[2*n
+ 1] = talloc_strndup(demuxer
->info
, param
.start
, param
.len
);
1291 info
= demuxer
->info
= talloc_realloc(demuxer
, info
, char *, 2 * (n
+ 2));
1292 info
[2*n
] = talloc_strndup(demuxer
->info
, opt
.start
, opt
.len
);
1293 info
[2*n
+ 1] = talloc_strndup(demuxer
->info
, param
.start
, param
.len
);
1294 memset(&info
[2 * (n
+ 1)], 0, 2 * sizeof(char *));
1299 int demux_info_print(demuxer_t
*demuxer
)
1301 char **info
= demuxer
->info
;
1307 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "Clip info:\n");
1308 for (n
= 0; info
[2 * n
] != NULL
; n
++) {
1309 mp_msg(MSGT_DEMUX
, MSGL_INFO
, " %s: %s\n", info
[2 * n
],
1311 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_NAME%d=%s\n", n
,
1313 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_VALUE%d=%s\n", n
,
1316 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_N=%d\n", n
);
1321 char *demux_info_get(demuxer_t
*demuxer
, const char *opt
)
1324 char **info
= demuxer
->info
;
1326 for (i
= 0; info
&& info
[2 * i
] != NULL
; i
++) {
1327 if (!strcasecmp(opt
, info
[2 * i
]))
1328 return info
[2 * i
+ 1];
1334 int demux_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
1337 if (demuxer
->desc
->control
)
1338 return demuxer
->desc
->control(demuxer
, cmd
, arg
);
1340 return DEMUXER_CTRL_NOTIMPL
;
1343 int demuxer_switch_audio(demuxer_t
*demuxer
, int index
)
1345 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_AUDIO
, &index
);
1346 if (res
== DEMUXER_CTRL_NOTIMPL
) {
1347 struct sh_audio
*sh_audio
= demuxer
->audio
->sh
;
1348 return sh_audio
? sh_audio
->aid
: -2;
1350 if (demuxer
->audio
->id
>= 0) {
1351 struct sh_audio
*sh_audio
= demuxer
->a_streams
[demuxer
->audio
->id
];
1352 demuxer
->audio
->sh
= sh_audio
;
1353 index
= sh_audio
->aid
; // internal MPEG demuxers don't set it right
1356 demuxer
->audio
->sh
= NULL
;
1360 int demuxer_switch_video(demuxer_t
*demuxer
, int index
)
1362 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_VIDEO
, &index
);
1363 if (res
== DEMUXER_CTRL_NOTIMPL
)
1364 index
= demuxer
->video
->id
;
1365 if (demuxer
->video
->id
>= 0)
1366 demuxer
->video
->sh
= demuxer
->v_streams
[demuxer
->video
->id
];
1368 demuxer
->video
->sh
= NULL
;
1372 int demuxer_add_attachment(demuxer_t
*demuxer
, struct bstr name
,
1373 struct bstr type
, struct bstr data
)
1375 if (!(demuxer
->num_attachments
% 32))
1376 demuxer
->attachments
= talloc_realloc(demuxer
, demuxer
->attachments
,
1377 struct demux_attachment
,
1378 demuxer
->num_attachments
+ 32);
1380 struct demux_attachment
*att
=
1381 demuxer
->attachments
+ demuxer
->num_attachments
;
1382 att
->name
= talloc_strndup(demuxer
->attachments
, name
.start
, name
.len
);
1383 att
->type
= talloc_strndup(demuxer
->attachments
, type
.start
, type
.len
);
1384 att
->data
= talloc_size(demuxer
->attachments
, data
.len
);
1385 memcpy(att
->data
, data
.start
, data
.len
);
1386 att
->data_size
= data
.len
;
1388 return demuxer
->num_attachments
++;
1391 int demuxer_add_chapter(demuxer_t
*demuxer
, struct bstr name
,
1392 uint64_t start
, uint64_t end
)
1394 if (!(demuxer
->num_chapters
% 32))
1395 demuxer
->chapters
= talloc_realloc(demuxer
, demuxer
->chapters
,
1396 struct demux_chapter
,
1397 demuxer
->num_chapters
+ 32);
1399 demuxer
->chapters
[demuxer
->num_chapters
].start
= start
;
1400 demuxer
->chapters
[demuxer
->num_chapters
].end
= end
;
1401 demuxer
->chapters
[demuxer
->num_chapters
].name
= name
.len
?
1402 talloc_strndup(demuxer
->chapters
, name
.start
, name
.len
) :
1403 talloc_strdup(demuxer
->chapters
, mp_gtext("unknown"));
1405 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_ID=%d\n", demuxer
->num_chapters
);
1406 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_%d_START=%"PRIu64
"\n", demuxer
->num_chapters
, start
);
1408 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_%d_END=%"PRIu64
"\n", demuxer
->num_chapters
, end
);
1410 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CHAPTER_%d_NAME=%.*s\n", demuxer
->num_chapters
, BSTR_P(name
));
1412 return demuxer
->num_chapters
++;
1416 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1417 * either using the demuxer->chapters structure set by the demuxer
1418 * or asking help to the stream layer (e.g. dvd)
1419 * \param chapter - chapter number wished - 0-based
1420 * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1421 * \param chapter_name name of chapter found (set by this function is param is not null)
1422 * \return -1 on error, current chapter if successful
1425 int demuxer_seek_chapter(demuxer_t
*demuxer
, int chapter
, double *seek_pts
,
1426 char **chapter_name
)
1430 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1431 demux_flush(demuxer
);
1433 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_CHAPTER
,
1435 if (ris
!= STREAM_UNSUPPORTED
)
1436 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1438 // exit status may be ok, but main() doesn't have to seek itself
1439 // (because e.g. dvds depend on sectors, not on pts)
1443 *chapter_name
= NULL
;
1445 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1446 &num_chapters
) == STREAM_UNSUPPORTED
)
1449 *chapter_name
= talloc_size(NULL
, 16);
1450 sprintf(*chapter_name
, " of %3d", num_chapters
);
1454 return ris
!= STREAM_UNSUPPORTED
? chapter
: -1;
1455 } else { // chapters structure is set in the demuxer
1456 if (chapter
>= demuxer
->num_chapters
)
1461 *seek_pts
= demuxer
->chapters
[chapter
].start
/ 1000.0;
1464 *chapter_name
= talloc_strdup(NULL
, demuxer
->chapters
[chapter
].name
);
1470 int demuxer_get_current_chapter(demuxer_t
*demuxer
)
1473 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1474 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_CURRENT_CHAPTER
,
1475 &chapter
) == STREAM_UNSUPPORTED
)
1478 sh_video_t
*sh_video
= demuxer
->video
->sh
;
1479 sh_audio_t
*sh_audio
= demuxer
->audio
->sh
;
1481 now
= (sh_video
? sh_video
->pts
: (sh_audio
? sh_audio
->pts
: 0))
1483 for (chapter
= demuxer
->num_chapters
- 1; chapter
>= 0; --chapter
) {
1484 if (demuxer
->chapters
[chapter
].start
<= now
)
1491 char *demuxer_chapter_name(demuxer_t
*demuxer
, int chapter
)
1493 if (demuxer
->num_chapters
&& demuxer
->chapters
) {
1494 if (chapter
>= 0 && chapter
< demuxer
->num_chapters
1495 && demuxer
->chapters
[chapter
].name
)
1496 return strdup(demuxer
->chapters
[chapter
].name
);
1501 char *demuxer_chapter_display_name(demuxer_t
*demuxer
, int chapter
)
1503 char *chapter_name
= demuxer_chapter_name(demuxer
, chapter
);
1505 char *tmp
= malloc(strlen(chapter_name
) + 14);
1506 snprintf(tmp
, 63, "(%d) %s", chapter
+ 1, chapter_name
);
1510 int chapter_num
= demuxer_chapter_count(demuxer
);
1512 if (chapter_num
<= 0)
1513 sprintf(tmp
, "(%d)", chapter
+ 1);
1515 sprintf(tmp
, "(%d) of %d", chapter
+ 1, chapter_num
);
1520 float demuxer_chapter_time(demuxer_t
*demuxer
, int chapter
, float *end
)
1522 if (demuxer
->num_chapters
&& demuxer
->chapters
&& chapter
>= 0
1523 && chapter
< demuxer
->num_chapters
) {
1525 *end
= demuxer
->chapters
[chapter
].end
/ 1000.0;
1526 return demuxer
->chapters
[chapter
].start
/ 1000.0;
1531 int demuxer_chapter_count(demuxer_t
*demuxer
)
1533 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1534 int num_chapters
= 0;
1535 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1536 &num_chapters
) == STREAM_UNSUPPORTED
)
1538 return num_chapters
;
1540 return demuxer
->num_chapters
;
1543 int demuxer_angles_count(demuxer_t
*demuxer
)
1545 int ris
, angles
= -1;
1547 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_ANGLES
, &angles
);
1548 if (ris
== STREAM_UNSUPPORTED
)
1553 int demuxer_get_current_angle(demuxer_t
*demuxer
)
1555 int ris
, curr_angle
= -1;
1556 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_ANGLE
, &curr_angle
);
1557 if (ris
== STREAM_UNSUPPORTED
)
1563 int demuxer_set_angle(demuxer_t
*demuxer
, int angle
)
1565 int ris
, angles
= -1;
1567 angles
= demuxer_angles_count(demuxer
);
1568 if ((angles
< 1) || (angle
> angles
))
1571 demux_flush(demuxer
);
1573 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SET_ANGLE
, &angle
);
1574 if (ris
== STREAM_UNSUPPORTED
)
1577 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1582 int demuxer_audio_track_by_lang_and_default(struct demuxer
*d
, char *lang
)
1587 lang
+= strspn(lang
, ",");
1588 int len
= strcspn(lang
, ",");
1590 for (int i
= 0; i
< MAX_A_STREAMS
; i
++) {
1591 struct sh_audio
*sh
= d
->a_streams
[i
];
1592 if (sh
&& (!len
|| sh
->lang
&& strlen(sh
->lang
) == len
&&
1593 !memcmp(lang
, sh
->lang
, len
))) {
1594 if (sh
->default_track
)
1608 int demuxer_sub_track_by_lang_and_default(struct demuxer
*d
, char *lang
)
1613 lang
+= strspn(lang
, ",");
1614 int len
= strcspn(lang
, ",");
1616 for (int i
= 0; i
< MAX_A_STREAMS
; i
++) {
1617 struct sh_audio
*sh
= d
->a_streams
[i
];
1618 if (sh
&& (!len
|| sh
->lang
&& strlen(sh
->lang
) == len
&&
1619 !memcmp(lang
, sh
->lang
, len
))) {
1620 if (sh
->default_track
)