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.
27 #include <sys/types.h>
36 #include "libvo/fastmemcpy.h"
38 #include "stream/stream.h"
43 #include "libaf/af_format.h"
44 #include "libmpcodecs/dec_teletext.h"
46 #include "libavcodec/avcodec.h"
47 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE
48 #error MP_INPUT_BUFFER_PADDING_SIZE is too small!
51 static void clear_parser(sh_common_t
*sh
);
54 extern const struct demuxer_desc demuxer_desc_edl
;
55 extern const demuxer_desc_t demuxer_desc_rawaudio
;
56 extern const demuxer_desc_t demuxer_desc_rawvideo
;
57 extern const demuxer_desc_t demuxer_desc_tv
;
58 extern const demuxer_desc_t demuxer_desc_mf
;
59 extern const demuxer_desc_t demuxer_desc_avi
;
60 extern const demuxer_desc_t demuxer_desc_y4m
;
61 extern const demuxer_desc_t demuxer_desc_asf
;
62 extern const demuxer_desc_t demuxer_desc_real
;
63 extern const demuxer_desc_t demuxer_desc_smjpeg
;
64 extern const demuxer_desc_t demuxer_desc_matroska
;
65 extern const demuxer_desc_t demuxer_desc_realaudio
;
66 extern const demuxer_desc_t demuxer_desc_vqf
;
67 extern const demuxer_desc_t demuxer_desc_mov
;
68 extern const demuxer_desc_t demuxer_desc_vivo
;
69 extern const demuxer_desc_t demuxer_desc_fli
;
70 extern const demuxer_desc_t demuxer_desc_film
;
71 extern const demuxer_desc_t demuxer_desc_roq
;
72 extern const demuxer_desc_t demuxer_desc_gif
;
73 extern const demuxer_desc_t demuxer_desc_ogg
;
74 extern const demuxer_desc_t demuxer_desc_avs
;
75 extern const demuxer_desc_t demuxer_desc_pva
;
76 extern const demuxer_desc_t demuxer_desc_nsv
;
77 extern const demuxer_desc_t demuxer_desc_mpeg_ts
;
78 extern const demuxer_desc_t demuxer_desc_lmlm4
;
79 extern const demuxer_desc_t demuxer_desc_mpeg_ps
;
80 extern const demuxer_desc_t demuxer_desc_mpeg_pes
;
81 extern const demuxer_desc_t demuxer_desc_mpeg_es
;
82 extern const demuxer_desc_t demuxer_desc_mpeg_gxf
;
83 extern const demuxer_desc_t demuxer_desc_mpeg4_es
;
84 extern const demuxer_desc_t demuxer_desc_h264_es
;
85 extern const demuxer_desc_t demuxer_desc_rawdv
;
86 extern const demuxer_desc_t demuxer_desc_mpc
;
87 extern const demuxer_desc_t demuxer_desc_audio
;
88 extern const demuxer_desc_t demuxer_desc_xmms
;
89 extern const demuxer_desc_t demuxer_desc_mpeg_ty
;
90 extern const demuxer_desc_t demuxer_desc_lavf
;
91 extern const demuxer_desc_t demuxer_desc_lavf_preferred
;
92 extern const demuxer_desc_t demuxer_desc_aac
;
93 extern const demuxer_desc_t demuxer_desc_nut
;
94 extern const demuxer_desc_t demuxer_desc_mng
;
96 /* Please do not add any new demuxers here. If you want to implement a new
97 * demuxer, add it to libavformat, except for wrappers around external
98 * libraries and demuxers requiring binary support. */
100 const demuxer_desc_t
*const demuxer_list
[] = {
102 &demuxer_desc_rawaudio
,
103 &demuxer_desc_rawvideo
,
108 &demuxer_desc_lavf_preferred
,
114 &demuxer_desc_smjpeg
,
115 &demuxer_desc_matroska
,
116 &demuxer_desc_realaudio
,
126 #ifdef CONFIG_OGGVORBIS
129 #ifdef CONFIG_WIN32DLL
133 &demuxer_desc_mpeg_ts
,
135 &demuxer_desc_mpeg_ps
,
136 &demuxer_desc_mpeg_pes
,
137 &demuxer_desc_mpeg_es
,
138 &demuxer_desc_mpeg_gxf
,
139 &demuxer_desc_mpeg4_es
,
140 &demuxer_desc_h264_es
,
142 &demuxer_desc_mpeg_ty
,
144 #ifdef CONFIG_MUSEPACK
147 #ifdef CONFIG_LIBDV095
160 /* Please do not add any new demuxers here. If you want to implement a new
161 * demuxer, add it to libavformat, except for wrappers around external
162 * libraries and demuxers requiring binary support. */
166 static struct demux_packet
*create_packet(size_t len
)
168 if (len
> 1000000000) {
169 mp_msg(MSGT_DEMUXER
, MSGL_FATAL
, "Attempt to allocate demux packet "
173 struct demux_packet
*dp
= malloc(sizeof(struct demux_packet
));
176 dp
->pts
= MP_NOPTS_VALUE
;
178 dp
->stream_pts
= MP_NOPTS_VALUE
;
180 dp
->keyframe
= false;
188 struct demux_packet
*new_demux_packet(size_t len
)
190 struct demux_packet
*dp
= create_packet(len
);
191 dp
->buffer
= malloc(len
+ MP_INPUT_BUFFER_PADDING_SIZE
);
193 mp_msg(MSGT_DEMUXER
, MSGL_FATAL
, "Memory allocation failure!\n");
196 memset(dp
->buffer
+ len
, 0, 8);
200 // data must already have suitable padding
201 struct demux_packet
*new_demux_packet_fromdata(void *data
, size_t len
)
203 struct demux_packet
*dp
= create_packet(len
);
208 void resize_demux_packet(struct demux_packet
*dp
, size_t len
)
210 if (len
> 1000000000) {
211 mp_msg(MSGT_DEMUXER
, MSGL_FATAL
, "Attempt to realloc demux packet "
215 dp
->buffer
= realloc(dp
->buffer
, len
+ MP_INPUT_BUFFER_PADDING_SIZE
);
217 mp_msg(MSGT_DEMUXER
, MSGL_FATAL
, "Memory allocation failure!\n");
220 memset(dp
->buffer
+ len
, 0, 8);
224 struct demux_packet
*clone_demux_packet(struct demux_packet
*pack
)
226 struct demux_packet
*dp
= malloc(sizeof(struct demux_packet
));
228 pack
= pack
->master
; // find the master
229 memcpy(dp
, pack
, sizeof(struct demux_packet
));
237 void free_demux_packet(struct demux_packet
*dp
)
239 if (dp
->master
== NULL
) { //dp is a master packet
241 if (dp
->refcount
== 0) {
243 talloc_free(dp
->avpacket
);
251 free_demux_packet(dp
->master
);
255 static void free_demuxer_stream(struct demux_stream
*ds
)
261 static struct demux_stream
*new_demuxer_stream(struct demuxer
*demuxer
, int id
)
263 demux_stream_t
*ds
= malloc(sizeof(demux_stream_t
));
264 *ds
= (demux_stream_t
){
274 * Get demuxer description structure for a given demuxer type
276 * @param file_format type of the demuxer
277 * @return structure for the demuxer, NULL if not found
279 static const demuxer_desc_t
*get_demuxer_desc_from_type(int file_format
)
283 for (i
= 0; demuxer_list
[i
]; i
++)
284 if (file_format
== demuxer_list
[i
]->type
)
285 return demuxer_list
[i
];
291 demuxer_t
*new_demuxer(struct MPOpts
*opts
, stream_t
*stream
, int type
,
292 int a_id
, int v_id
, int s_id
, char *filename
)
294 struct demuxer
*d
= talloc_zero(NULL
, struct demuxer
);
296 d
->stream_pts
= MP_NOPTS_VALUE
;
297 d
->reference_clock
= MP_NOPTS_VALUE
;
298 d
->movi_start
= stream
->start_pos
;
299 d
->movi_end
= stream
->end_pos
;
303 d
->audio
= new_demuxer_stream(d
, a_id
);
304 d
->video
= new_demuxer_stream(d
, v_id
);
305 d
->sub
= new_demuxer_stream(d
, s_id
);
309 if (!(d
->desc
= get_demuxer_desc_from_type(type
)))
310 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
311 "BUG! Invalid demuxer type in new_demuxer(), "
312 "big troubles ahead.");
313 if (filename
) // Filename hack for avs_check_file
314 d
->filename
= strdup(filename
);
315 stream_seek(stream
, stream
->start_pos
);
319 const char *sh_sub_type2str(int type
)
322 case 't': return "text";
323 case 'm': return "movtext";
324 case 'a': return "ass";
325 case 'v': return "vobsub";
326 case 'x': return "xsub";
327 case 'b': return "dvb";
328 case 'd': return "dvb-teletext";
329 case 'p': return "hdmv pgs";
334 sh_sub_t
*new_sh_sub_sid(demuxer_t
*demuxer
, int id
, int sid
)
336 if (id
> MAX_S_STREAMS
- 1 || id
< 0) {
337 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
338 "Requested sub stream id overflow (%d > %d)\n", id
,
342 if (demuxer
->s_streams
[id
])
343 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, "Sub stream %i redefined\n", id
);
345 struct sh_sub
*sh
= talloc_zero(demuxer
, struct sh_sub
);
346 demuxer
->s_streams
[id
] = sh
;
348 sh
->opts
= demuxer
->opts
;
349 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SUBTITLE_ID=%d\n", sid
);
351 return demuxer
->s_streams
[id
];
354 struct sh_sub
*new_sh_sub_sid_lang(struct demuxer
*demuxer
, int id
, int sid
,
357 struct sh_sub
*sh
= new_sh_sub_sid(demuxer
, id
, sid
);
358 if (lang
&& lang
[0] && strcmp(lang
, "und")) {
359 sh
->lang
= talloc_strdup(sh
, lang
);
360 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
, lang
);
365 static void free_sh_sub(sh_sub_t
*sh
)
367 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_sub at %p\n", sh
);
369 clear_parser((sh_common_t
*)sh
);
373 sh_audio_t
*new_sh_audio_aid(demuxer_t
*demuxer
, int id
, int aid
)
375 if (id
> MAX_A_STREAMS
- 1 || id
< 0) {
376 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
377 "Requested audio stream id overflow (%d > %d)\n", id
,
381 if (demuxer
->a_streams
[id
]) {
382 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
, "WARNING: Audio stream header %d redefined.\n", id
);
384 mp_tmsg(MSGT_DEMUXER
, MSGL_V
, "==> Found audio stream: %d\n", id
);
385 struct sh_audio
*sh
= talloc_zero(demuxer
, struct sh_audio
);
386 demuxer
->a_streams
[id
] = sh
;
388 sh
->ds
= demuxer
->audio
;
391 sh
->sample_format
= AF_FORMAT_S16_NE
;
392 sh
->opts
= demuxer
->opts
;
393 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AUDIO_ID=%d\n", aid
);
395 return demuxer
->a_streams
[id
];
398 void free_sh_audio(demuxer_t
*demuxer
, int id
)
400 sh_audio_t
*sh
= demuxer
->a_streams
[id
];
401 demuxer
->a_streams
[id
] = NULL
;
402 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_audio at %p\n", sh
);
405 clear_parser((sh_common_t
*)sh
);
409 sh_video_t
*new_sh_video_vid(demuxer_t
*demuxer
, int id
, int vid
)
411 if (id
> MAX_V_STREAMS
- 1 || id
< 0) {
412 mp_msg(MSGT_DEMUXER
, MSGL_WARN
,
413 "Requested video stream id overflow (%d > %d)\n", id
,
417 if (demuxer
->v_streams
[id
])
418 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
, "WARNING: Video stream header %d redefined.\n", id
);
420 mp_tmsg(MSGT_DEMUXER
, MSGL_V
, "==> Found video stream: %d\n", id
);
421 struct sh_video
*sh
= talloc_zero(demuxer
, struct sh_video
);
422 demuxer
->v_streams
[id
] = sh
;
424 sh
->ds
= demuxer
->video
;
425 sh
->opts
= demuxer
->opts
;
426 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VIDEO_ID=%d\n", vid
);
428 return demuxer
->v_streams
[id
];
431 void free_sh_video(sh_video_t
*sh
)
433 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing sh_video at %p\n", sh
);
435 clear_parser((sh_common_t
*)sh
);
439 void free_demuxer(demuxer_t
*demuxer
)
442 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "DEMUXER: freeing %s demuxer at %p\n",
443 demuxer
->desc
->shortdesc
, demuxer
);
444 if (demuxer
->desc
->close
)
445 demuxer
->desc
->close(demuxer
);
446 // Very ugly hack to make it behave like old implementation
447 if (demuxer
->desc
->type
== DEMUXER_TYPE_DEMUXERS
)
448 goto skip_streamfree
;
450 for (i
= 0; i
< MAX_A_STREAMS
; i
++)
451 if (demuxer
->a_streams
[i
])
452 free_sh_audio(demuxer
, i
);
453 for (i
= 0; i
< MAX_V_STREAMS
; i
++)
454 if (demuxer
->v_streams
[i
])
455 free_sh_video(demuxer
->v_streams
[i
]);
456 for (i
= 0; i
< MAX_S_STREAMS
; i
++)
457 if (demuxer
->s_streams
[i
])
458 free_sh_sub(demuxer
->s_streams
[i
]);
460 free_demuxer_stream(demuxer
->audio
);
461 free_demuxer_stream(demuxer
->video
);
462 free_demuxer_stream(demuxer
->sub
);
464 free(demuxer
->filename
);
465 if (demuxer
->teletext
)
466 teletext_control(demuxer
->teletext
, TV_VBI_CONTROL_STOP
, NULL
);
467 talloc_free(demuxer
);
471 void ds_add_packet(demux_stream_t
*ds
, demux_packet_t
*dp
)
473 // append packet to DS stream:
475 ds
->bytes
+= dp
->len
;
477 // next packet in stream
481 // first packet in stream
482 ds
->first
= ds
->last
= dp
;
484 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
485 "DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n",
486 (ds
== ds
->demuxer
->audio
) ? "d_audio" : "d_video", dp
->len
,
487 dp
->pts
, (unsigned int) dp
->pos
, ds
->demuxer
->audio
->packs
,
488 ds
->demuxer
->video
->packs
);
491 static void allocate_parser(AVCodecContext
**avctx
, AVCodecParserContext
**parser
, unsigned format
)
493 enum CodecID codec_id
= CODEC_ID_NONE
;
496 case MKTAG('M', 'P', '4', 'L'):
497 codec_id
= CODEC_ID_AAC_LATM
;
503 case MKTAG('s', 'a', 'c', '3'):
504 codec_id
= CODEC_ID_AC3
;
506 case MKTAG('d', 'n', 'e', 't'):
507 // DNET/byte-swapped AC-3 - there is no parser for that yet
508 //codec_id = CODEC_ID_DNET;
510 case MKTAG('E', 'A', 'C', '3'):
511 codec_id
= CODEC_ID_EAC3
;
515 codec_id
= CODEC_ID_DTS
;
517 case MKTAG('f', 'L', 'a', 'C'):
518 codec_id
= CODEC_ID_FLAC
;
520 case MKTAG('M', 'L', 'P', ' '):
521 codec_id
= CODEC_ID_MLP
;
526 case MKTAG('.', 'm', 'p', '3'):
527 case MKTAG('M', 'P', '3', ' '):
528 case MKTAG('L', 'A', 'M', 'E'):
529 codec_id
= CODEC_ID_MP3
;
533 case MKTAG('.', 'm', 'p', '2'):
534 case MKTAG('.', 'm', 'p', '1'):
535 codec_id
= CODEC_ID_MP2
;
537 case MKTAG('T', 'R', 'H', 'D'):
538 codec_id
= CODEC_ID_TRUEHD
;
541 if (codec_id
!= CODEC_ID_NONE
) {
542 *avctx
= avcodec_alloc_context3(NULL
);
545 *parser
= av_parser_init(codec_id
);
551 static void get_parser(sh_common_t
*sh
, AVCodecContext
**avctx
, AVCodecParserContext
**parser
)
556 if (!sh
|| !sh
->needs_parsing
)
560 *parser
= sh
->parser
;
564 allocate_parser(avctx
, parser
, sh
->format
);
566 sh
->parser
= *parser
;
569 int ds_parse(demux_stream_t
*ds
, uint8_t **buffer
, int *len
, double pts
, off_t pos
)
571 AVCodecContext
*avctx
;
572 AVCodecParserContext
*parser
;
573 get_parser(ds
->sh
, &avctx
, &parser
);
576 return av_parser_parse2(parser
, avctx
, buffer
, len
, *buffer
, *len
, pts
, pts
, pos
);
579 static void clear_parser(sh_common_t
*sh
)
581 av_parser_close(sh
->parser
);
583 av_freep(&sh
->avctx
);
586 void ds_clear_parser(demux_stream_t
*ds
)
590 clear_parser(ds
->sh
);
593 void ds_read_packet(demux_stream_t
*ds
, stream_t
*stream
, int len
,
594 double pts
, off_t pos
, bool keyframe
)
596 demux_packet_t
*dp
= new_demux_packet(len
);
597 len
= stream_read(stream
, dp
->buffer
, len
);
598 resize_demux_packet(dp
, len
);
601 dp
->keyframe
= keyframe
;
602 // append packet to DS stream:
603 ds_add_packet(ds
, dp
);
607 // 0 = EOF or no stream found or invalid type
608 // 1 = successfully read a packet
610 int demux_fill_buffer(demuxer_t
*demux
, demux_stream_t
*ds
)
612 // Note: parameter 'ds' can be NULL!
613 return demux
->desc
->fill_buffer(demux
, ds
);
619 int ds_fill_buffer(demux_stream_t
*ds
)
621 demuxer_t
*demux
= ds
->demuxer
;
623 free_demux_packet(ds
->current
);
625 mp_dbg(MSGT_DEMUXER
, MSGL_DBG3
, "ds_fill_buffer (%s) called\n",
626 ds
== demux
->audio
? "d_audio" : ds
== demux
->video
? "d_video" :
627 ds
== demux
->sub
? "d_sub" : "unknown");
630 demux_packet_t
*p
= ds
->first
;
632 ds
->buffer
= p
->buffer
;
634 ds
->buffer_size
= p
->len
;
636 ds
->dpos
+= p
->len
; // !!!
638 if (p
->pts
!= MP_NOPTS_VALUE
) {
642 ds
->pts_bytes
+= p
->len
; // !!!
643 if (p
->stream_pts
!= MP_NOPTS_VALUE
)
644 demux
->stream_pts
= p
->stream_pts
;
645 ds
->keyframe
= p
->keyframe
;
653 /* The code below can set ds->eof to 1 when another stream runs
654 * out of buffer space. That makes sense because in that situation
655 * the calling code should not count on being able to demux more
656 * packets from this stream.
657 * If however the situation improves and we're called again
658 * despite the eof flag then it's better to clear it to avoid
664 #define MaybeNI _("Maybe you are playing a non-interleaved stream/file or the codec failed?\n" \
665 "For AVI files, try to force non-interleaved mode with the -ni option.\n")
667 if (demux
->audio
->packs
>= MAX_PACKS
668 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
669 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many audio packets in the buffer: (%d in %d bytes).\n",
670 demux
->audio
->packs
, demux
->audio
->bytes
);
671 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
674 if (demux
->video
->packs
>= MAX_PACKS
675 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
676 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many video packets in the buffer: (%d in %d bytes).\n",
677 demux
->video
->packs
, demux
->video
->bytes
);
678 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
681 if (!demux_fill_buffer(demux
, ds
)) {
682 mp_dbg(MSGT_DEMUXER
, MSGL_DBG2
,
683 "ds_fill_buffer()->demux_fill_buffer() failed\n");
687 ds
->buffer_pos
= ds
->buffer_size
= 0;
689 mp_msg(MSGT_DEMUXER
, MSGL_V
,
690 "ds_fill_buffer: EOF reached (stream: %s) \n",
691 ds
== demux
->audio
? "audio" : "video");
696 int demux_read_data(demux_stream_t
*ds
, unsigned char *mem
, int len
)
701 x
= ds
->buffer_size
- ds
->buffer_pos
;
703 if (!ds_fill_buffer(ds
))
709 fast_memcpy(mem
+ bytes
, &ds
->buffer
[ds
->buffer_pos
], x
);
719 * \brief read data until the given 3-byte pattern is encountered, up to maxlen
720 * \param mem memory to read data into, may be NULL to discard data
721 * \param maxlen maximum number of bytes to read
722 * \param read number of bytes actually read
723 * \param pattern pattern to search for (lowest 8 bits are ignored)
724 * \return whether pattern was found
726 int demux_pattern_3(demux_stream_t
*ds
, unsigned char *mem
, int maxlen
,
727 int *read
, uint32_t pattern
)
729 register uint32_t head
= 0xffffff00;
730 register uint32_t pat
= pattern
& 0xffffff00;
733 register unsigned char *ds_buf
= &ds
->buffer
[ds
->buffer_size
];
734 int len
= ds
->buffer_size
- ds
->buffer_pos
;
735 register long pos
= -len
;
736 if (unlikely(pos
>= 0)) { // buffer is empty
743 } while (++pos
&& head
!= pat
);
745 if (total_len
+ len
> maxlen
)
746 len
= maxlen
- total_len
;
747 len
= demux_read_data(ds
, mem
? &mem
[total_len
] : NULL
, len
);
749 } while ((head
!= pat
|| total_len
< 3) && total_len
< maxlen
&& !ds
->eof
);
752 return total_len
>= 3 && head
== pat
;
755 void ds_free_packs(demux_stream_t
*ds
)
757 demux_packet_t
*dp
= ds
->first
;
759 demux_packet_t
*dn
= dp
->next
;
760 free_demux_packet(dp
);
763 if (ds
->asf_packet
) {
764 // free unfinished .asf fragments:
765 free(ds
->asf_packet
->buffer
);
766 free(ds
->asf_packet
);
767 ds
->asf_packet
= NULL
;
769 ds
->first
= ds
->last
= NULL
;
770 ds
->packs
= 0; // !!!!!
773 free_demux_packet(ds
->current
);
776 ds
->buffer_pos
= ds
->buffer_size
;
777 ds
->pts
= MP_NOPTS_VALUE
;
781 int ds_get_packet(demux_stream_t
*ds
, unsigned char **start
)
784 if (ds
->buffer_pos
>= ds
->buffer_size
) {
785 if (!ds_fill_buffer(ds
)) {
791 len
= ds
->buffer_size
- ds
->buffer_pos
;
792 *start
= &ds
->buffer
[ds
->buffer_pos
];
793 ds
->buffer_pos
+= len
;
797 int ds_get_packet_pts(demux_stream_t
*ds
, unsigned char **start
, double *pts
)
800 *pts
= MP_NOPTS_VALUE
;
801 len
= ds_get_packet(ds
, start
);
804 // Return pts unless this read starts from the middle of a packet
805 if (len
== ds
->buffer_pos
)
806 *pts
= ds
->current
->pts
;
810 int ds_get_packet_sub(demux_stream_t
*ds
, unsigned char **start
)
813 if (ds
->buffer_pos
>= ds
->buffer_size
) {
817 if (!ds_fill_buffer(ds
))
820 len
= ds
->buffer_size
- ds
->buffer_pos
;
821 *start
= &ds
->buffer
[ds
->buffer_pos
];
822 ds
->buffer_pos
+= len
;
826 struct demux_packet
*ds_get_packet2(struct demux_stream
*ds
, bool repeat_last
)
828 // This shouldn't get used together with partial reads
829 assert(ds
->buffer_pos
== 0 || ds
->buffer_pos
>= ds
->buffer_size
);
832 ds
->buffer_pos
= ds
->buffer_size
;
836 double ds_get_next_pts(demux_stream_t
*ds
)
838 demuxer_t
*demux
= ds
->demuxer
;
839 // if we have not read from the "current" packet, consider it
840 // as the next, otherwise we never get the pts for the first packet.
841 while (!ds
->first
&& (!ds
->current
|| ds
->buffer_pos
)) {
842 if (demux
->audio
->packs
>= MAX_PACKS
843 || demux
->audio
->bytes
>= MAX_PACK_BYTES
) {
844 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many audio packets in the buffer: (%d in %d bytes).\n",
845 demux
->audio
->packs
, demux
->audio
->bytes
);
846 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
847 return MP_NOPTS_VALUE
;
849 if (demux
->video
->packs
>= MAX_PACKS
850 || demux
->video
->bytes
>= MAX_PACK_BYTES
) {
851 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "\nToo many video packets in the buffer: (%d in %d bytes).\n",
852 demux
->video
->packs
, demux
->video
->bytes
);
853 mp_tmsg(MSGT_DEMUXER
, MSGL_HINT
, MaybeNI
);
854 return MP_NOPTS_VALUE
;
856 if (!demux_fill_buffer(demux
, ds
))
857 return MP_NOPTS_VALUE
;
859 // take pts from "current" if we never read from it.
860 if (ds
->current
&& !ds
->buffer_pos
)
861 return ds
->current
->pts
;
862 return ds
->first
->pts
;
865 // ====================================================================
867 void demuxer_help(void)
871 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "Available demuxers:\n");
872 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " demuxer: info: (comment)\n");
873 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_DEMUXERS\n");
874 for (i
= 0; demuxer_list
[i
]; i
++) {
875 if (demuxer_list
[i
]->type
>= DEMUXER_TYPE_END
) // internal type
877 if (demuxer_list
[i
]->comment
&& strlen(demuxer_list
[i
]->comment
))
878 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %s (%s)\n",
879 demuxer_list
[i
]->name
, demuxer_list
[i
]->info
,
880 demuxer_list
[i
]->comment
);
882 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "%10s %s\n",
883 demuxer_list
[i
]->name
, demuxer_list
[i
]->info
);
889 * Get demuxer type for a given demuxer name
891 * @param demuxer_name string with demuxer name of demuxer number
892 * @param force will be set if demuxer should be forced.
894 * @return DEMUXER_TYPE_xxx, -1 if error or not found
896 static int get_demuxer_type_from_name(char *demuxer_name
, int *force
)
898 if (!demuxer_name
|| !demuxer_name
[0])
899 return DEMUXER_TYPE_UNKNOWN
;
901 *force
= demuxer_name
[0] == '+';
902 if (demuxer_name
[0] == '+')
903 demuxer_name
= &demuxer_name
[1];
904 for (int i
= 0; demuxer_list
[i
]; i
++) {
905 if (demuxer_list
[i
]->type
>= DEMUXER_TYPE_END
)
906 // Can't select special demuxers from commandline
908 if (strcmp(demuxer_name
, demuxer_list
[i
]->name
) == 0)
909 return demuxer_list
[i
]->type
;
915 static struct demuxer
*open_given_type(struct MPOpts
*opts
,
916 const struct demuxer_desc
*desc
,
917 struct stream
*stream
, bool force
,
918 int audio_id
, int video_id
, int sub_id
,
920 struct demuxer_params
*params
)
922 struct demuxer
*demuxer
;
924 demuxer
= new_demuxer(opts
, stream
, desc
->type
, audio_id
,
925 video_id
, sub_id
, filename
);
926 demuxer
->params
= params
;
927 if (desc
->check_file
)
928 fformat
= desc
->check_file(demuxer
);
930 fformat
= desc
->type
;
932 fformat
= desc
->type
;
935 if (fformat
== desc
->type
) {
936 if (demuxer
->filetype
)
937 mp_tmsg(MSGT_DEMUXER
, MSGL_INFO
, "Detected file format: %s (%s)\n",
938 demuxer
->filetype
, desc
->shortdesc
);
940 mp_tmsg(MSGT_DEMUXER
, MSGL_INFO
, "Detected file format: %s\n",
942 if (demuxer
->desc
->open
) {
943 struct demuxer
*demux2
= demuxer
->desc
->open(demuxer
);
945 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "Opening as detected format "
946 "\"%s\" failed.\n", desc
->shortdesc
);
949 /* At least demux_mov can return a demux_demuxers instance
950 * from open() instead of the original fed in. */
953 demuxer
->file_format
= fformat
;
956 // demux_mov can return playlist instead of mov
957 if (fformat
== DEMUXER_TYPE_PLAYLIST
)
958 return demuxer
; // handled in mplayer.c
959 /* Internal MPEG PS demuxer check can return other MPEG subtypes
960 * which don't have their own checks; recurse to try opening as
961 * the returned type instead. */
962 free_demuxer(demuxer
);
963 desc
= get_demuxer_desc_from_type(fformat
);
965 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
966 "BUG: recursion to nonexistent file format\n");
969 return open_given_type(opts
, desc
, stream
, false, audio_id
,
970 video_id
, sub_id
, filename
, params
);
973 free_demuxer(demuxer
);
977 static struct demuxer
*demux_open_stream(struct MPOpts
*opts
,
978 struct stream
*stream
,
979 int file_format
, bool force
,
980 int audio_id
, int video_id
, int sub_id
,
982 struct demuxer_params
*params
)
984 struct demuxer
*demuxer
= NULL
;
985 const struct demuxer_desc
*desc
;
987 // If somebody requested a demuxer check it
989 desc
= get_demuxer_desc_from_type(file_format
);
991 // should only happen with obsolete -demuxer 99 numeric format
993 return open_given_type(opts
, desc
, stream
, force
, audio_id
,
994 video_id
, sub_id
, filename
, params
);
997 // Test demuxers with safe file checks
998 for (int i
= 0; (desc
= demuxer_list
[i
]); i
++) {
999 if (desc
->safe_check
) {
1000 demuxer
= open_given_type(opts
, desc
, stream
, false, audio_id
,
1001 video_id
, sub_id
, filename
, params
);
1007 // Ok. We're over the stable detectable fileformats, the next ones are
1008 // a bit fuzzy. So by default (extension_parsing==1) try extension-based
1010 if (filename
&& opts
->extension_parsing
== 1) {
1011 desc
= get_demuxer_desc_from_type(demuxer_type_by_filename(filename
));
1013 demuxer
= open_given_type(opts
, desc
, stream
, false, audio_id
,
1014 video_id
, sub_id
, filename
, params
);
1019 // Finally try detection for demuxers with unsafe checks
1020 for (int i
= 0; (desc
= demuxer_list
[i
]); i
++) {
1021 if (!desc
->safe_check
&& desc
->check_file
) {
1022 demuxer
= open_given_type(opts
, desc
, stream
, false, audio_id
,
1023 video_id
, sub_id
, filename
, params
);
1032 struct demuxer
*demux_open(struct MPOpts
*opts
, stream_t
*vs
, int file_format
,
1033 int audio_id
, int video_id
, int sub_id
,
1036 return demux_open_withparams(opts
, vs
, file_format
, audio_id
, video_id
,
1037 sub_id
, filename
, NULL
);
1040 struct demuxer
*demux_open_withparams(struct MPOpts
*opts
, stream_t
*vs
,
1041 int file_format
, int audio_id
, int video_id
, int dvdsub_id
,
1042 char *filename
, struct demuxer_params
*params
)
1044 stream_t
*as
= NULL
, *ss
= NULL
;
1045 demuxer_t
*vd
, *ad
= NULL
, *sd
= NULL
;
1047 int afmt
= DEMUXER_TYPE_UNKNOWN
, sfmt
= DEMUXER_TYPE_UNKNOWN
;
1049 int audio_demuxer_type
= 0, sub_demuxer_type
= 0;
1050 int demuxer_force
= 0, audio_demuxer_force
= 0, sub_demuxer_force
= 0;
1053 get_demuxer_type_from_name(opts
->demuxer_name
, &demuxer_force
)) < 0) {
1054 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-demuxer %s does not exist.\n",
1055 opts
->demuxer_name
);
1058 if ((audio_demuxer_type
=
1059 get_demuxer_type_from_name(opts
->audio_demuxer_name
,
1060 &audio_demuxer_force
)) < 0) {
1061 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-audio-demuxer %s does not exist.\n",
1062 opts
->audio_demuxer_name
);
1063 if (opts
->audio_stream
)
1066 if ((sub_demuxer_type
=
1067 get_demuxer_type_from_name(opts
->sub_demuxer_name
,
1068 &sub_demuxer_force
)) < 0) {
1069 mp_msg(MSGT_DEMUXER
, MSGL_ERR
, "-sub-demuxer %s does not exist.\n",
1070 opts
->sub_demuxer_name
);
1071 if (opts
->sub_stream
)
1075 if (opts
->audio_stream
) {
1076 as
= open_stream(opts
->audio_stream
, 0, &afmt
);
1078 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "Cannot open audio stream: %s\n",
1079 opts
->audio_stream
);
1082 if (opts
->audio_stream_cache
) {
1083 if (!stream_enable_cache
1084 (as
, opts
->audio_stream_cache
* 1024,
1085 opts
->audio_stream_cache
* 1024 *
1086 (opts
->stream_cache_min_percent
/ 100.0),
1087 opts
->audio_stream_cache
* 1024 *
1088 (opts
->stream_cache_seek_min_percent
/ 100.0))) {
1090 mp_msg(MSGT_DEMUXER
, MSGL_ERR
,
1091 "Can't enable audio stream cache\n");
1096 if (opts
->sub_stream
) {
1097 ss
= open_stream(opts
->sub_stream
, 0, &sfmt
);
1099 mp_tmsg(MSGT_DEMUXER
, MSGL_ERR
, "Cannot open subtitle stream: %s\n",
1105 vd
= demux_open_stream(opts
, vs
, demuxer_type
? demuxer_type
: file_format
,
1106 demuxer_force
, opts
->audio_stream
? -2 : audio_id
,
1107 video_id
, opts
->sub_stream
? -2 : dvdsub_id
,
1117 ad
= demux_open_stream(opts
, as
,
1118 audio_demuxer_type
? audio_demuxer_type
: afmt
,
1119 audio_demuxer_force
, audio_id
, -2, -2,
1120 opts
->audio_stream
, params
);
1122 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
, "Failed to open audio demuxer: %s\n",
1123 opts
->audio_stream
);
1125 } else if (ad
->audio
->sh
1126 && ((sh_audio_t
*) ad
->audio
->sh
)->format
== 0x55) // MP3
1127 opts
->hr_mp3_seek
= 1; // Enable high res seeking
1130 sd
= demux_open_stream(opts
, ss
,
1131 sub_demuxer_type
? sub_demuxer_type
: sfmt
,
1132 sub_demuxer_force
, -2, -2, dvdsub_id
,
1133 opts
->sub_stream
, params
);
1135 mp_tmsg(MSGT_DEMUXER
, MSGL_WARN
,
1136 "Failed to open subtitle demuxer: %s\n", opts
->sub_stream
);
1142 res
= new_demuxers_demuxer(vd
, ad
, sd
);
1144 res
= new_demuxers_demuxer(vd
, ad
, vd
);
1146 res
= new_demuxers_demuxer(vd
, vd
, sd
);
1150 opts
->correct_pts
= opts
->user_correct_pts
;
1151 if (opts
->correct_pts
< 0)
1153 demux_control(vd
? vd
: res
, DEMUXER_CTRL_CORRECT_PTS
,
1154 NULL
) == DEMUXER_CTRL_OK
;
1159 void demux_flush(demuxer_t
*demuxer
)
1161 ds_free_packs(demuxer
->video
);
1162 ds_free_packs(demuxer
->audio
);
1163 ds_free_packs(demuxer
->sub
);
1166 int demux_seek(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
,
1169 if (!demuxer
->seekable
) {
1170 if (demuxer
->file_format
== DEMUXER_TYPE_AVI
)
1171 mp_tmsg(MSGT_SEEK
, MSGL_WARN
, "Cannot seek in raw AVI streams. (Index required, try with the -idx switch.)\n");
1173 else if (demuxer
->file_format
== DEMUXER_TYPE_TV
)
1174 mp_tmsg(MSGT_SEEK
, MSGL_WARN
, "TV input is not seekable! (Seeking will probably be for changing channels ;)\n");
1177 mp_tmsg(MSGT_SEEK
, MSGL_WARN
, "Cannot seek in this file.\n");
1180 // clear demux buffers:
1181 demux_flush(demuxer
);
1182 demuxer
->video
->eof
= 0;
1183 demuxer
->audio
->eof
= 0;
1184 demuxer
->sub
->eof
= 0;
1186 /* HACK: assume any demuxer used with these streams can cope with
1187 * the stream layer suddenly seeking to a different position under it
1188 * (nothing actually implements DEMUXER_CTRL_RESYNC now).
1190 struct stream
*stream
= demuxer
->stream
;
1191 if (stream
->type
== STREAMTYPE_DVD
|| stream
->type
== STREAMTYPE_DVDNAV
) {
1194 if (flags
& SEEK_ABSOLUTE
)
1197 if (demuxer
->stream_pts
== MP_NOPTS_VALUE
)
1199 pts
= demuxer
->stream_pts
;
1202 if (flags
& SEEK_FACTOR
) {
1204 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_TIME_LENGTH
,
1205 &tmp
) == STREAM_UNSUPPORTED
)
1207 pts
+= tmp
* rel_seek_secs
;
1209 pts
+= rel_seek_secs
;
1211 if (stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_TIME
, &pts
)
1212 != STREAM_UNSUPPORTED
) {
1213 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1219 if (demuxer
->desc
->seek
)
1220 demuxer
->desc
->seek(demuxer
, rel_seek_secs
, audio_delay
, flags
);
1225 int demux_info_add(demuxer_t
*demuxer
, const char *opt
, const char *param
)
1227 return demux_info_add_bstr(demuxer
, bstr(opt
), bstr(param
));
1230 int demux_info_add_bstr(demuxer_t
*demuxer
, struct bstr opt
, struct bstr param
)
1232 char **info
= demuxer
->info
;
1236 for (n
= 0; info
&& info
[2 * n
] != NULL
; n
++) {
1237 if (!bstrcasecmp(opt
, bstr(info
[2*n
]))) {
1238 if (!bstrcmp(param
, bstr(info
[2*n
+ 1]))) {
1239 mp_msg(MSGT_DEMUX
, MSGL_V
, "Demuxer info %.*s set to unchanged value %.*s\n",
1240 BSTR_P(opt
), BSTR_P(param
));
1243 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "Demuxer info %.*s changed to %.*s\n",
1244 BSTR_P(opt
), BSTR_P(param
));
1245 talloc_free(info
[2*n
+ 1]);
1246 info
[2*n
+ 1] = talloc_strndup(demuxer
->info
, param
.start
, param
.len
);
1251 info
= demuxer
->info
= talloc_realloc(demuxer
, info
, char *, 2 * (n
+ 2));
1252 info
[2*n
] = talloc_strndup(demuxer
->info
, opt
.start
, opt
.len
);
1253 info
[2*n
+ 1] = talloc_strndup(demuxer
->info
, param
.start
, param
.len
);
1254 memset(&info
[2 * (n
+ 1)], 0, 2 * sizeof(char *));
1259 int demux_info_print(demuxer_t
*demuxer
)
1261 char **info
= demuxer
->info
;
1267 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "Clip info:\n");
1268 for (n
= 0; info
[2 * n
] != NULL
; n
++) {
1269 mp_msg(MSGT_DEMUX
, MSGL_INFO
, " %s: %s\n", info
[2 * n
],
1271 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_NAME%d=%s\n", n
,
1273 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_VALUE%d=%s\n", n
,
1276 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_CLIP_INFO_N=%d\n", n
);
1281 char *demux_info_get(demuxer_t
*demuxer
, const char *opt
)
1284 char **info
= demuxer
->info
;
1286 for (i
= 0; info
&& info
[2 * i
] != NULL
; i
++) {
1287 if (!strcasecmp(opt
, info
[2 * i
]))
1288 return info
[2 * i
+ 1];
1294 int demux_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
1297 if (demuxer
->desc
->control
)
1298 return demuxer
->desc
->control(demuxer
, cmd
, arg
);
1300 return DEMUXER_CTRL_NOTIMPL
;
1303 int demuxer_switch_audio(demuxer_t
*demuxer
, int index
)
1305 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_AUDIO
, &index
);
1306 if (res
== DEMUXER_CTRL_NOTIMPL
) {
1307 struct sh_audio
*sh_audio
= demuxer
->audio
->sh
;
1308 return sh_audio
? sh_audio
->aid
: -2;
1310 if (demuxer
->audio
->id
>= 0) {
1311 struct sh_audio
*sh_audio
= demuxer
->a_streams
[demuxer
->audio
->id
];
1312 demuxer
->audio
->sh
= sh_audio
;
1313 index
= sh_audio
->aid
; // internal MPEG demuxers don't set it right
1316 demuxer
->audio
->sh
= NULL
;
1320 int demuxer_switch_video(demuxer_t
*demuxer
, int index
)
1322 int res
= demux_control(demuxer
, DEMUXER_CTRL_SWITCH_VIDEO
, &index
);
1323 if (res
== DEMUXER_CTRL_NOTIMPL
) {
1324 struct sh_video
*sh_video
= demuxer
->video
->sh
;
1325 return sh_video
? sh_video
->vid
: -2;
1327 if (demuxer
->video
->id
>= 0) {
1328 struct sh_video
*sh_video
= demuxer
->v_streams
[demuxer
->video
->id
];
1329 demuxer
->video
->sh
= sh_video
;
1330 index
= sh_video
->vid
; // internal MPEG demuxers don't set it right
1332 demuxer
->video
->sh
= NULL
;
1336 int demuxer_add_attachment(demuxer_t
*demuxer
, struct bstr name
,
1337 struct bstr type
, struct bstr data
)
1339 if (!(demuxer
->num_attachments
% 32))
1340 demuxer
->attachments
= talloc_realloc(demuxer
, demuxer
->attachments
,
1341 struct demux_attachment
,
1342 demuxer
->num_attachments
+ 32);
1344 struct demux_attachment
*att
=
1345 demuxer
->attachments
+ demuxer
->num_attachments
;
1346 att
->name
= talloc_strndup(demuxer
->attachments
, name
.start
, name
.len
);
1347 att
->type
= talloc_strndup(demuxer
->attachments
, type
.start
, type
.len
);
1348 att
->data
= talloc_size(demuxer
->attachments
, data
.len
);
1349 memcpy(att
->data
, data
.start
, data
.len
);
1350 att
->data_size
= data
.len
;
1352 return demuxer
->num_attachments
++;
1355 int demuxer_add_chapter(demuxer_t
*demuxer
, struct bstr name
,
1356 uint64_t start
, uint64_t end
)
1358 if (!(demuxer
->num_chapters
% 32))
1359 demuxer
->chapters
= talloc_realloc(demuxer
, demuxer
->chapters
,
1360 struct demux_chapter
,
1361 demuxer
->num_chapters
+ 32);
1363 demuxer
->chapters
[demuxer
->num_chapters
].start
= start
;
1364 demuxer
->chapters
[demuxer
->num_chapters
].end
= end
;
1365 demuxer
->chapters
[demuxer
->num_chapters
].name
= name
.len
?
1366 talloc_strndup(demuxer
->chapters
, name
.start
, name
.len
) :
1367 talloc_strdup(demuxer
->chapters
, mp_gtext("unknown"));
1369 return demuxer
->num_chapters
++;
1373 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1374 * either using the demuxer->chapters structure set by the demuxer
1375 * or asking help to the stream layer (e.g. dvd)
1376 * \param chapter - chapter number wished - 0-based
1377 * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1378 * \return -1 on error, current chapter if successful
1381 int demuxer_seek_chapter(demuxer_t
*demuxer
, int chapter
, double *seek_pts
)
1385 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1386 demux_flush(demuxer
);
1388 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SEEK_TO_CHAPTER
,
1390 if (ris
!= STREAM_UNSUPPORTED
)
1391 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1393 // exit status may be ok, but main() doesn't have to seek itself
1394 // (because e.g. dvds depend on sectors, not on pts)
1397 return ris
!= STREAM_UNSUPPORTED
? chapter
: -1;
1398 } else { // chapters structure is set in the demuxer
1399 if (chapter
>= demuxer
->num_chapters
)
1404 *seek_pts
= demuxer
->chapters
[chapter
].start
/ 1e9
;
1410 int demuxer_get_current_chapter(demuxer_t
*demuxer
, double time_now
)
1413 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1414 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_CURRENT_CHAPTER
,
1415 &chapter
) == STREAM_UNSUPPORTED
)
1418 uint64_t now
= time_now
* 1e9
+ 0.5;
1419 for (chapter
= demuxer
->num_chapters
- 1; chapter
>= 0; --chapter
) {
1420 if (demuxer
->chapters
[chapter
].start
<= now
)
1427 char *demuxer_chapter_name(demuxer_t
*demuxer
, int chapter
)
1429 if (demuxer
->num_chapters
&& demuxer
->chapters
) {
1430 if (chapter
>= 0 && chapter
< demuxer
->num_chapters
1431 && demuxer
->chapters
[chapter
].name
)
1432 return talloc_strdup(NULL
, demuxer
->chapters
[chapter
].name
);
1437 float demuxer_chapter_time(demuxer_t
*demuxer
, int chapter
, float *end
)
1439 if (demuxer
->num_chapters
&& demuxer
->chapters
&& chapter
>= 0
1440 && chapter
< demuxer
->num_chapters
) {
1442 *end
= demuxer
->chapters
[chapter
].end
/ 1e9
;
1443 return demuxer
->chapters
[chapter
].start
/ 1e9
;
1448 int demuxer_chapter_count(demuxer_t
*demuxer
)
1450 if (!demuxer
->num_chapters
|| !demuxer
->chapters
) {
1451 int num_chapters
= 0;
1452 if (stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_CHAPTERS
,
1453 &num_chapters
) == STREAM_UNSUPPORTED
)
1455 return num_chapters
;
1457 return demuxer
->num_chapters
;
1460 int demuxer_angles_count(demuxer_t
*demuxer
)
1462 int ris
, angles
= -1;
1464 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_NUM_ANGLES
, &angles
);
1465 if (ris
== STREAM_UNSUPPORTED
)
1470 int demuxer_get_current_angle(demuxer_t
*demuxer
)
1472 int ris
, curr_angle
= -1;
1473 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_GET_ANGLE
, &curr_angle
);
1474 if (ris
== STREAM_UNSUPPORTED
)
1480 int demuxer_set_angle(demuxer_t
*demuxer
, int angle
)
1482 int ris
, angles
= -1;
1484 angles
= demuxer_angles_count(demuxer
);
1485 if ((angles
< 1) || (angle
> angles
))
1488 demux_flush(demuxer
);
1490 ris
= stream_control(demuxer
->stream
, STREAM_CTRL_SET_ANGLE
, &angle
);
1491 if (ris
== STREAM_UNSUPPORTED
)
1494 demux_control(demuxer
, DEMUXER_CTRL_RESYNC
, NULL
);
1499 int demuxer_audio_track_by_lang_and_default(struct demuxer
*d
, char **langt
)
1503 char *lang
= langt
? langt
[n
++] : NULL
;
1505 for (int i
= 0; i
< MAX_A_STREAMS
; i
++) {
1506 struct sh_audio
*sh
= d
->a_streams
[i
];
1507 if (sh
&& (!lang
|| sh
->lang
&& !strcmp(lang
, sh
->lang
))) {
1508 if (sh
->default_track
)
1521 int demuxer_sub_track_by_lang_and_default(struct demuxer
*d
, char **langt
)
1525 char *lang
= langt
? langt
[n
++] : NULL
;
1527 for (int i
= 0; i
< MAX_S_STREAMS
; i
++) {
1528 struct sh_sub
*sh
= d
->s_streams
[i
];
1529 if (sh
&& (!lang
|| sh
->lang
&& !strcmp(lang
, sh
->lang
))) {
1530 if (sh
->default_track
)