Mercurial > mplayer.hg
annotate libmpdemux/demuxer.c @ 32142:4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
There is little point in assuming that some parts of FFmpeg might be
available without the others. Plus, mixing and matching static and
shared FFmpeg libraries was never supported.
author | diego |
---|---|
date | Mon, 13 Sep 2010 18:19:25 +0000 |
parents | 734f9a57c186 |
children | ef21cbba62ee |
rev | line source |
---|---|
29238
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
1 /* |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
2 * DEMUXER v2.5 |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
3 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
4 * This file is part of MPlayer. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
5 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
6 * MPlayer is free software; you can redistribute it and/or modify |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
7 * it under the terms of the GNU General Public License as published by |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
8 * the Free Software Foundation; either version 2 of the License, or |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
9 * (at your option) any later version. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
10 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
11 * MPlayer is distributed in the hope that it will be useful, |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
14 * GNU General Public License for more details. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
15 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
16 * You should have received a copy of the GNU General Public License along |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
17 * with MPlayer; if not, write to the Free Software Foundation, Inc., |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
29056
diff
changeset
|
19 */ |
1 | 20 |
1430 | 21 #include <stdio.h> |
22 #include <stdlib.h> | |
3150 | 23 #include <string.h> |
1430 | 24 #include <unistd.h> |
25 | |
1428
a90d889eb649
largefile patch by Stephen Davies <steve@daviesfam.org>
arpi
parents:
1421
diff
changeset
|
26 #include <sys/types.h> |
a90d889eb649
largefile patch by Stephen Davies <steve@daviesfam.org>
arpi
parents:
1421
diff
changeset
|
27 #include <sys/stat.h> |
a90d889eb649
largefile patch by Stephen Davies <steve@daviesfam.org>
arpi
parents:
1421
diff
changeset
|
28 |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
29 #include "config.h" |
1567 | 30 #include "mp_msg.h" |
1584 | 31 #include "help_mp.h" |
17012 | 32 #include "m_config.h" |
32043
f6249bc89c38
Move extern declarations used by both mplayer.c and mencoder.c to mpcommon.h.
diego
parents:
31960
diff
changeset
|
33 #include "mpcommon.h" |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
34 |
17200
a1b8eeffdfcd
include fastmemcpy.h before stream.h, so it is used for the stream_read
reimar
parents:
17012
diff
changeset
|
35 #include "libvo/fastmemcpy.h" |
a1b8eeffdfcd
include fastmemcpy.h before stream.h, so it is used for the stream_read
reimar
parents:
17012
diff
changeset
|
36 |
22605
4d81dbdf46b9
Add explicit location for headers from the stream/ directory.
diego
parents:
22488
diff
changeset
|
37 #include "stream/stream.h" |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
554
diff
changeset
|
38 #include "demuxer.h" |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
39 #include "stheader.h" |
4551 | 40 #include "mf.h" |
31418
d2fd0e4d0b9a
Move hr_mp3_seek extern variable declaration to demux_audio.h.
diego
parents:
31272
diff
changeset
|
41 #include "demux_audio.h" |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
42 |
17012 | 43 #include "libaf/af_format.h" |
29832 | 44 #include "libmpcodecs/dec_teletext.h" |
31960
1ba5eef167aa
Refactor more instances of avcodec_initialized handling into init_avcodec().
diego
parents:
31949
diff
changeset
|
45 #include "libmpcodecs/vd_ffmpeg.h" |
5084 | 46 |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
47 #ifdef CONFIG_ASS |
25654
0190aa38aae2
Init and destroy ass_tracks in demuxer.c based on sh_sub->type value.
eugeni
parents:
25652
diff
changeset
|
48 #include "libass/ass.h" |
0190aa38aae2
Init and destroy ass_tracks in demuxer.c based on sh_sub->type value.
eugeni
parents:
25652
diff
changeset
|
49 #include "libass/ass_mp.h" |
0190aa38aae2
Init and destroy ass_tracks in demuxer.c based on sh_sub->type value.
eugeni
parents:
25652
diff
changeset
|
50 #endif |
0190aa38aae2
Init and destroy ass_tracks in demuxer.c based on sh_sub->type value.
eugeni
parents:
25652
diff
changeset
|
51 |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
52 #ifdef CONFIG_FFMPEG |
27282
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27059
diff
changeset
|
53 #include "libavcodec/avcodec.h" |
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27059
diff
changeset
|
54 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE |
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27059
diff
changeset
|
55 #error MP_INPUT_BUFFER_PADDING_SIZE is too small! |
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27059
diff
changeset
|
56 #endif |
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27059
diff
changeset
|
57 #endif |
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27059
diff
changeset
|
58 |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
59 // This is quite experimental, in particular it will mess up the pts values |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
60 // in the queue - on the other hand it might fix some issues like generating |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
61 // broken files with mencoder and stream copy. |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
62 // Better leave it disabled for now, if we find no use for it this code should |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
63 // just be removed again. |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
64 #define PARSE_ON_ADD 0 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
65 |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
66 static void clear_parser(sh_common_t *sh); |
28051 | 67 void resync_video_stream(sh_video_t *sh_video); |
68 void resync_audio_stream(sh_audio_t *sh_audio); | |
16175 | 69 |
70 // Demuxer list | |
25707
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
71 extern const demuxer_desc_t demuxer_desc_rawaudio; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
72 extern const demuxer_desc_t demuxer_desc_rawvideo; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
73 extern const demuxer_desc_t demuxer_desc_tv; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
74 extern const demuxer_desc_t demuxer_desc_mf; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
75 extern const demuxer_desc_t demuxer_desc_avi; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
76 extern const demuxer_desc_t demuxer_desc_y4m; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
77 extern const demuxer_desc_t demuxer_desc_asf; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
78 extern const demuxer_desc_t demuxer_desc_real; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
79 extern const demuxer_desc_t demuxer_desc_smjpeg; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
80 extern const demuxer_desc_t demuxer_desc_matroska; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
81 extern const demuxer_desc_t demuxer_desc_realaudio; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
82 extern const demuxer_desc_t demuxer_desc_vqf; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
83 extern const demuxer_desc_t demuxer_desc_mov; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
84 extern const demuxer_desc_t demuxer_desc_vivo; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
85 extern const demuxer_desc_t demuxer_desc_fli; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
86 extern const demuxer_desc_t demuxer_desc_film; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
87 extern const demuxer_desc_t demuxer_desc_roq; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
88 extern const demuxer_desc_t demuxer_desc_gif; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
89 extern const demuxer_desc_t demuxer_desc_ogg; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
90 extern const demuxer_desc_t demuxer_desc_avs; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
91 extern const demuxer_desc_t demuxer_desc_pva; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
92 extern const demuxer_desc_t demuxer_desc_nsv; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
93 extern const demuxer_desc_t demuxer_desc_mpeg_ts; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
94 extern const demuxer_desc_t demuxer_desc_lmlm4; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
95 extern const demuxer_desc_t demuxer_desc_mpeg_ps; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
96 extern const demuxer_desc_t demuxer_desc_mpeg_pes; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
97 extern const demuxer_desc_t demuxer_desc_mpeg_es; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
98 extern const demuxer_desc_t demuxer_desc_mpeg_gxf; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
99 extern const demuxer_desc_t demuxer_desc_mpeg4_es; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
100 extern const demuxer_desc_t demuxer_desc_h264_es; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
101 extern const demuxer_desc_t demuxer_desc_rawdv; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
102 extern const demuxer_desc_t demuxer_desc_mpc; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
103 extern const demuxer_desc_t demuxer_desc_audio; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
104 extern const demuxer_desc_t demuxer_desc_xmms; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
105 extern const demuxer_desc_t demuxer_desc_mpeg_ty; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
106 extern const demuxer_desc_t demuxer_desc_rtp; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
107 extern const demuxer_desc_t demuxer_desc_rtp_nemesi; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
108 extern const demuxer_desc_t demuxer_desc_lavf; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
109 extern const demuxer_desc_t demuxer_desc_lavf_preferred; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
110 extern const demuxer_desc_t demuxer_desc_aac; |
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25706
diff
changeset
|
111 extern const demuxer_desc_t demuxer_desc_nut; |
28018
4ac70bd6acac
MNG demuxer by Stefan Schuermans, stefan blinkenarea org
diego
parents:
27397
diff
changeset
|
112 extern const demuxer_desc_t demuxer_desc_mng; |
16175 | 113 |
25876
edfe8baed49f
copy note on new demuxers and codecs to the top of the array as well to be
ivo
parents:
25872
diff
changeset
|
114 /* Please do not add any new demuxers here. If you want to implement a new |
25880
4df11ac927fc
clarify comments/docs about lav* being the preferred place to implement new
ivo
parents:
25876
diff
changeset
|
115 * demuxer, add it to libavformat, except for wrappers around external |
4df11ac927fc
clarify comments/docs about lav* being the preferred place to implement new
ivo
parents:
25876
diff
changeset
|
116 * libraries and demuxers requiring binary support. */ |
25876
edfe8baed49f
copy note on new demuxers and codecs to the top of the array as well to be
ivo
parents:
25872
diff
changeset
|
117 |
27054 | 118 const demuxer_desc_t *const demuxer_list[] = { |
27055 | 119 &demuxer_desc_rawaudio, |
120 &demuxer_desc_rawvideo, | |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
121 #ifdef CONFIG_TV |
27055 | 122 &demuxer_desc_tv, |
16175 | 123 #endif |
27055 | 124 &demuxer_desc_mf, |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
125 #ifdef CONFIG_FFMPEG |
27055 | 126 &demuxer_desc_lavf_preferred, |
23069
93948eb0280f
demuxer_desc_lavf_preferred depends on USE_LIBAVFORMAT or USE_LIBAVFORMAT_SO
nicodvb
parents:
22971
diff
changeset
|
127 #endif |
27055 | 128 &demuxer_desc_avi, |
129 &demuxer_desc_y4m, | |
130 &demuxer_desc_asf, | |
131 &demuxer_desc_nsv, | |
132 &demuxer_desc_real, | |
133 &demuxer_desc_smjpeg, | |
134 &demuxer_desc_matroska, | |
135 &demuxer_desc_realaudio, | |
136 &demuxer_desc_vqf, | |
137 &demuxer_desc_mov, | |
138 &demuxer_desc_vivo, | |
139 &demuxer_desc_fli, | |
140 &demuxer_desc_film, | |
141 &demuxer_desc_roq, | |
27385
2113bd9c6bd9
Rename preprocessor directives related to image libraries.
diego
parents:
27363
diff
changeset
|
142 #ifdef CONFIG_GIF |
27055 | 143 &demuxer_desc_gif, |
16175 | 144 #endif |
27363
40057010b1fa
Change a bunch of codec-specific preprocessor directives from a HAVE_
diego
parents:
27341
diff
changeset
|
145 #ifdef CONFIG_OGGVORBIS |
27055 | 146 &demuxer_desc_ogg, |
16175 | 147 #endif |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
148 #ifdef CONFIG_WIN32DLL |
27055 | 149 &demuxer_desc_avs, |
16175 | 150 #endif |
27055 | 151 &demuxer_desc_pva, |
152 &demuxer_desc_mpeg_ts, | |
153 &demuxer_desc_lmlm4, | |
154 &demuxer_desc_mpeg_ps, | |
155 &demuxer_desc_mpeg_pes, | |
156 &demuxer_desc_mpeg_es, | |
157 &demuxer_desc_mpeg_gxf, | |
158 &demuxer_desc_mpeg4_es, | |
159 &demuxer_desc_h264_es, | |
160 &demuxer_desc_audio, | |
161 &demuxer_desc_mpeg_ty, | |
27397
d47744b95b78
Give a CONFIG_ prefix to preprocessor directives that lacked one and
diego
parents:
27395
diff
changeset
|
162 #ifdef CONFIG_LIVE555 |
27055 | 163 &demuxer_desc_rtp, |
16175 | 164 #endif |
27397
d47744b95b78
Give a CONFIG_ prefix to preprocessor directives that lacked one and
diego
parents:
27395
diff
changeset
|
165 #ifdef CONFIG_LIBNEMESI |
27055 | 166 &demuxer_desc_rtp_nemesi, |
25266
239330301b33
Make libnemesi use specific struct and DEMUXER_TYPE
lu_zero
parents:
25197
diff
changeset
|
167 #endif |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
168 #ifdef CONFIG_FFMPEG |
27055 | 169 &demuxer_desc_lavf, |
16175 | 170 #endif |
27395 | 171 #ifdef CONFIG_MUSEPACK |
27055 | 172 &demuxer_desc_mpc, |
26873
a90971b955af
Move native musepack demuxer further down in demuxer list
reimar
parents:
26758
diff
changeset
|
173 #endif |
27363
40057010b1fa
Change a bunch of codec-specific preprocessor directives from a HAVE_
diego
parents:
27341
diff
changeset
|
174 #ifdef CONFIG_LIBDV095 |
27055 | 175 &demuxer_desc_rawdv, |
18900
0b53e6d1b27f
move some ill-behaving demuxers further down the list
reimar
parents:
18708
diff
changeset
|
176 #endif |
27055 | 177 &demuxer_desc_aac, |
27363
40057010b1fa
Change a bunch of codec-specific preprocessor directives from a HAVE_
diego
parents:
27341
diff
changeset
|
178 #ifdef CONFIG_LIBNUT |
27055 | 179 &demuxer_desc_nut, |
19861 | 180 #endif |
27391
1d2faa1020fb
Rename a bunch of miscellaneous preprocessor directives.
diego
parents:
27385
diff
changeset
|
181 #ifdef CONFIG_XMMS |
27055 | 182 &demuxer_desc_xmms, |
18900
0b53e6d1b27f
move some ill-behaving demuxers further down the list
reimar
parents:
18708
diff
changeset
|
183 #endif |
28018
4ac70bd6acac
MNG demuxer by Stefan Schuermans, stefan blinkenarea org
diego
parents:
27397
diff
changeset
|
184 #ifdef CONFIG_MNG |
4ac70bd6acac
MNG demuxer by Stefan Schuermans, stefan blinkenarea org
diego
parents:
27397
diff
changeset
|
185 &demuxer_desc_mng, |
4ac70bd6acac
MNG demuxer by Stefan Schuermans, stefan blinkenarea org
diego
parents:
27397
diff
changeset
|
186 #endif |
27055 | 187 /* Please do not add any new demuxers here. If you want to implement a new |
188 * demuxer, add it to libavformat, except for wrappers around external | |
189 * libraries and demuxers requiring binary support. */ | |
190 NULL | |
16175 | 191 }; |
192 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
193 void free_demuxer_stream(demux_stream_t *ds) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
194 { |
1643 | 195 ds_free_packs(ds); |
196 free(ds); | |
197 } | |
198 | |
30644
390c8d36d463
Drop weird and unnecessary _s/_st suffixes from demuxer struct names.
diego
parents:
30626
diff
changeset
|
199 demux_stream_t *new_demuxer_stream(struct demuxer *demuxer, int id) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
200 { |
27055 | 201 demux_stream_t *ds = malloc(sizeof(demux_stream_t)); |
29770
db80b9d20406
demuxer.c: Add initialization missing from previous commit
uau
parents:
29634
diff
changeset
|
202 *ds = (demux_stream_t){ |
db80b9d20406
demuxer.c: Add initialization missing from previous commit
uau
parents:
29634
diff
changeset
|
203 .id = id, |
db80b9d20406
demuxer.c: Add initialization missing from previous commit
uau
parents:
29634
diff
changeset
|
204 .demuxer = demuxer, |
db80b9d20406
demuxer.c: Add initialization missing from previous commit
uau
parents:
29634
diff
changeset
|
205 .asf_seq = -1, |
db80b9d20406
demuxer.c: Add initialization missing from previous commit
uau
parents:
29634
diff
changeset
|
206 }; |
27055 | 207 return ds; |
1 | 208 } |
209 | |
16175 | 210 |
211 /** | |
212 * Get demuxer description structure for a given demuxer type | |
213 * | |
214 * @param file_format type of the demuxer | |
215 * @return structure for the demuxer, NULL if not found | |
216 */ | |
27054 | 217 static const demuxer_desc_t *get_demuxer_desc_from_type(int file_format) |
16175 | 218 { |
27055 | 219 int i; |
16175 | 220 |
27055 | 221 for (i = 0; demuxer_list[i]; i++) |
222 if (file_format == demuxer_list[i]->type) | |
223 return demuxer_list[i]; | |
16175 | 224 |
27055 | 225 return NULL; |
16175 | 226 } |
227 | |
228 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
229 demuxer_t *new_demuxer(stream_t *stream, int type, int a_id, int v_id, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
230 int s_id, char *filename) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
231 { |
27055 | 232 demuxer_t *d = malloc(sizeof(demuxer_t)); |
233 memset(d, 0, sizeof(demuxer_t)); | |
234 d->stream = stream; | |
235 d->stream_pts = MP_NOPTS_VALUE; | |
236 d->reference_clock = MP_NOPTS_VALUE; | |
237 d->movi_start = stream->start_pos; | |
238 d->movi_end = stream->end_pos; | |
239 d->seekable = 1; | |
240 d->synced = 0; | |
29486
a373af1e3b24
Handle demuxers that never set filepos by using stream_tell.
reimar
parents:
29366
diff
changeset
|
241 d->filepos = -1; |
27055 | 242 d->audio = new_demuxer_stream(d, a_id); |
243 d->video = new_demuxer_stream(d, v_id); | |
244 d->sub = new_demuxer_stream(d, s_id); | |
245 d->type = type; | |
246 if (type) | |
247 if (!(d->desc = get_demuxer_desc_from_type(type))) | |
27056 | 248 mp_msg(MSGT_DEMUXER, MSGL_ERR, |
249 "BUG! Invalid demuxer type in new_demuxer(), " | |
250 "big troubles ahead."); | |
27055 | 251 if (filename) // Filename hack for avs_check_file |
252 d->filename = strdup(filename); | |
30626
27b133678bbd
Do not discard stream buffer on eof, instead reuse it to slightly improve
reimar
parents:
30624
diff
changeset
|
253 stream->eof = 0; |
27055 | 254 stream_seek(stream, stream->start_pos); |
255 return d; | |
1 | 256 } |
257 | |
31925
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
258 const char *sh_sub_type2str(int type) |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
259 { |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
260 switch (type) { |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
261 case 't': return "text"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
262 case 'm': return "movtext"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
263 case 'a': return "ass"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
264 case 'v': return "vobsub"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
265 case 'x': return "xsub"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
266 case 'b': return "dvb"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
267 case 'd': return "dvb-teletext"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
268 case 'p': return "hdmv pgs"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
269 } |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
270 return "unknown"; |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
271 } |
616375aefdda
Print subtitle type also for internally-supported types with a libavcodec decoder.
reimar
parents:
31609
diff
changeset
|
272 |
31609
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
273 sh_sub_t *new_sh_sub_sid(demuxer_t *demuxer, int id, int sid, const char *lang) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
274 { |
27055 | 275 if (id > MAX_S_STREAMS - 1 || id < 0) { |
27056 | 276 mp_msg(MSGT_DEMUXER, MSGL_WARN, |
277 "Requested sub stream id overflow (%d > %d)\n", id, | |
278 MAX_S_STREAMS); | |
27055 | 279 return NULL; |
280 } | |
281 if (demuxer->s_streams[id]) | |
282 mp_msg(MSGT_DEMUXER, MSGL_WARN, "Sub stream %i redefined\n", id); | |
283 else { | |
284 sh_sub_t *sh = calloc(1, sizeof(sh_sub_t)); | |
285 demuxer->s_streams[id] = sh; | |
286 sh->sid = sid; | |
287 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SUBTITLE_ID=%d\n", sid); | |
31609
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
288 if (lang && lang[0] && strcmp(lang, "und")) { |
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
289 sh->lang = strdup(lang); |
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
290 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", sid, lang); |
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
291 } |
27055 | 292 } |
29056
93e72ef080ab
Update demuxer->sub->id and demuxer->sub->sh if a new subtitle stream is
reimar
parents:
28872
diff
changeset
|
293 if (sid == dvdsub_id) { |
93e72ef080ab
Update demuxer->sub->id and demuxer->sub->sh if a new subtitle stream is
reimar
parents:
28872
diff
changeset
|
294 demuxer->sub->id = id; |
93e72ef080ab
Update demuxer->sub->id and demuxer->sub->sh if a new subtitle stream is
reimar
parents:
28872
diff
changeset
|
295 demuxer->sub->sh = demuxer->s_streams[id]; |
93e72ef080ab
Update demuxer->sub->id and demuxer->sub->sh if a new subtitle stream is
reimar
parents:
28872
diff
changeset
|
296 } |
27055 | 297 return demuxer->s_streams[id]; |
20872
a8b42366e68a
Make subtitle stream handling more similar to audio and video streams.
reimar
parents:
20851
diff
changeset
|
298 } |
a8b42366e68a
Make subtitle stream handling more similar to audio and video streams.
reimar
parents:
20851
diff
changeset
|
299 |
30570
98dc6ae7ede2
libmpdemux: Mark functions not used outside of their files as static.
diego
parents:
30396
diff
changeset
|
300 static void free_sh_sub(sh_sub_t *sh) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
301 { |
23592 | 302 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing sh_sub at %p\n", sh); |
26085 | 303 free(sh->extradata); |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
304 #ifdef CONFIG_ASS |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
305 if (sh->ass_track) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
306 ass_free_track(sh->ass_track); |
25702
c4275201a489
Add a forgotten #ifdef USE_ASS around ass_free_track
reimar
parents:
25657
diff
changeset
|
307 #endif |
26082 | 308 free(sh->lang); |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
309 #ifdef CONFIG_FFMPEG |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
310 clear_parser((sh_common_t *)sh); |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
311 #endif |
23592 | 312 free(sh); |
313 } | |
314 | |
31609
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
315 sh_audio_t *new_sh_audio_aid(demuxer_t *demuxer, int id, int aid, const char *lang) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
316 { |
27055 | 317 if (id > MAX_A_STREAMS - 1 || id < 0) { |
27056 | 318 mp_msg(MSGT_DEMUXER, MSGL_WARN, |
319 "Requested audio stream id overflow (%d > %d)\n", id, | |
320 MAX_A_STREAMS); | |
27052 | 321 return NULL; |
4642 | 322 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
323 if (demuxer->a_streams[id]) |
27055 | 324 mp_msg(MSGT_DEMUXER, MSGL_WARN, MSGTR_AudioStreamRedefined, id); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
325 else { |
26874 | 326 sh_audio_t *sh = calloc(1, sizeof(sh_audio_t)); |
27055 | 327 mp_msg(MSGT_DEMUXER, MSGL_V, MSGTR_FoundAudioStream, id); |
26874 | 328 demuxer->a_streams[id] = sh; |
26875
c276296cb6f8
Simplify/make new_sh behaviour more consistent when a stream gets redefined.
reimar
parents:
26874
diff
changeset
|
329 sh->aid = aid; |
26876 | 330 sh->ds = demuxer->audio; |
13357
c605df89ca9f
moved sh_audio initialization from dec_audio to demuxer.c to fix
reimar
parents:
13301
diff
changeset
|
331 // set some defaults |
27055 | 332 sh->samplesize = 2; |
333 sh->sample_format = AF_FORMAT_S16_NE; | |
334 sh->audio_out_minsize = 8192; /* default size, maybe not enough for Win32/ACM */ | |
335 sh->pts = MP_NOPTS_VALUE; | |
336 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_ID=%d\n", aid); | |
31609
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
337 if (lang && lang[0] && strcmp(lang, "und")) { |
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
338 sh->lang = strdup(lang); |
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
339 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", aid, lang); |
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
31558
diff
changeset
|
340 } |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
341 } |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
342 return demuxer->a_streams[id]; |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
343 } |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
344 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
345 void free_sh_audio(demuxer_t *demuxer, int id) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
346 { |
18708
9e2b300db17b
Change free_sh_audio() to take demuxer and stream id as parameters
uau
parents:
18404
diff
changeset
|
347 sh_audio_t *sh = demuxer->a_streams[id]; |
9e2b300db17b
Change free_sh_audio() to take demuxer and stream id as parameters
uau
parents:
18404
diff
changeset
|
348 demuxer->a_streams[id] = NULL; |
27055 | 349 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing sh_audio at %p\n", sh); |
26085 | 350 free(sh->wf); |
351 free(sh->codecdata); | |
26082 | 352 free(sh->lang); |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
353 #ifdef CONFIG_FFMPEG |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
354 clear_parser((sh_common_t *)sh); |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
355 #endif |
1643 | 356 free(sh); |
357 } | |
358 | |
27054 | 359 sh_video_t *new_sh_video_vid(demuxer_t *demuxer, int id, int vid) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
360 { |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
361 if (id > MAX_V_STREAMS - 1 || id < 0) { |
27056 | 362 mp_msg(MSGT_DEMUXER, MSGL_WARN, |
363 "Requested video stream id overflow (%d > %d)\n", id, | |
364 MAX_V_STREAMS); | |
27052 | 365 return NULL; |
4642 | 366 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
367 if (demuxer->v_streams[id]) |
27055 | 368 mp_msg(MSGT_DEMUXER, MSGL_WARN, MSGTR_VideoStreamRedefined, id); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
369 else { |
26875
c276296cb6f8
Simplify/make new_sh behaviour more consistent when a stream gets redefined.
reimar
parents:
26874
diff
changeset
|
370 sh_video_t *sh = calloc(1, sizeof(sh_video_t)); |
27055 | 371 mp_msg(MSGT_DEMUXER, MSGL_V, MSGTR_FoundVideoStream, id); |
26875
c276296cb6f8
Simplify/make new_sh behaviour more consistent when a stream gets redefined.
reimar
parents:
26874
diff
changeset
|
372 demuxer->v_streams[id] = sh; |
c276296cb6f8
Simplify/make new_sh behaviour more consistent when a stream gets redefined.
reimar
parents:
26874
diff
changeset
|
373 sh->vid = vid; |
26876 | 374 sh->ds = demuxer->video; |
27055 | 375 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_ID=%d\n", vid); |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
376 } |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
377 return demuxer->v_streams[id]; |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
378 } |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
379 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
380 void free_sh_video(sh_video_t *sh) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
381 { |
27055 | 382 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing sh_video at %p\n", sh); |
26085 | 383 free(sh->bih); |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
384 #ifdef CONFIG_FFMPEG |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
385 clear_parser((sh_common_t *)sh); |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
386 #endif |
1643 | 387 free(sh); |
388 } | |
389 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
390 void free_demuxer(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
391 { |
1643 | 392 int i; |
30624 | 393 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing %s demuxer at %p\n", |
394 demuxer->desc->shortdesc, demuxer); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
395 if (demuxer->desc->close) |
27055 | 396 demuxer->desc->close(demuxer); |
16175 | 397 // Very ugly hack to make it behave like old implementation |
398 if (demuxer->desc->type == DEMUXER_TYPE_DEMUXERS) | |
27055 | 399 goto skip_streamfree; |
1643 | 400 // free streams: |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
401 for (i = 0; i < MAX_A_STREAMS; i++) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
402 if (demuxer->a_streams[i]) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
403 free_sh_audio(demuxer, i); |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
404 for (i = 0; i < MAX_V_STREAMS; i++) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
405 if (demuxer->v_streams[i]) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
406 free_sh_video(demuxer->v_streams[i]); |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
407 for (i = 0; i < MAX_S_STREAMS; i++) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
408 if (demuxer->s_streams[i]) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
409 free_sh_sub(demuxer->s_streams[i]); |
1643 | 410 // free demuxers: |
411 free_demuxer_stream(demuxer->audio); | |
412 free_demuxer_stream(demuxer->video); | |
5412 | 413 free_demuxer_stream(demuxer->sub); |
27055 | 414 skip_streamfree: |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
415 if (demuxer->info) { |
27055 | 416 for (i = 0; demuxer->info[i] != NULL; i++) |
417 free(demuxer->info[i]); | |
418 free(demuxer->info); | |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
419 } |
26085 | 420 free(demuxer->filename); |
19342 | 421 if (demuxer->chapters) { |
27055 | 422 for (i = 0; i < demuxer->num_chapters; i++) |
423 free(demuxer->chapters[i].name); | |
424 free(demuxer->chapters); | |
19342 | 425 } |
25657 | 426 if (demuxer->attachments) { |
27055 | 427 for (i = 0; i < demuxer->num_attachments; i++) { |
428 free(demuxer->attachments[i].name); | |
429 free(demuxer->attachments[i].type); | |
430 free(demuxer->attachments[i].data); | |
431 } | |
432 free(demuxer->attachments); | |
25657 | 433 } |
29832 | 434 if (demuxer->teletext) |
435 teletext_control(demuxer->teletext, TV_VBI_CONTROL_STOP, NULL); | |
1643 | 436 free(demuxer); |
437 } | |
438 | |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
439 |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
440 static void ds_add_packet_internal(demux_stream_t *ds, demux_packet_t *dp) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
441 { |
1 | 442 // append packet to DS stream: |
443 ++ds->packs; | |
27055 | 444 ds->bytes += dp->len; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
445 if (ds->last) { |
27055 | 446 // next packet in stream |
447 ds->last->next = dp; | |
448 ds->last = dp; | |
1 | 449 } else { |
27055 | 450 // first packet in stream |
451 ds->first = ds->last = dp; | |
1 | 452 } |
27056 | 453 mp_dbg(MSGT_DEMUXER, MSGL_DBG2, |
454 "DEMUX: Append packet to %s, len=%d pts=%5.3f pos=%u [packs: A=%d V=%d]\n", | |
455 (ds == ds->demuxer->audio) ? "d_audio" : "d_video", dp->len, | |
456 dp->pts, (unsigned int) dp->pos, ds->demuxer->audio->packs, | |
457 ds->demuxer->video->packs); | |
1 | 458 } |
459 | |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
460 #ifdef CONFIG_FFMPEG |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
461 static void allocate_parser(AVCodecContext **avctx, AVCodecParserContext **parser, unsigned format) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
462 { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
463 enum CodecID codec_id = CODEC_ID_NONE; |
31960
1ba5eef167aa
Refactor more instances of avcodec_initialized handling into init_avcodec().
diego
parents:
31949
diff
changeset
|
464 |
1ba5eef167aa
Refactor more instances of avcodec_initialized handling into init_avcodec().
diego
parents:
31949
diff
changeset
|
465 init_avcodec(); |
1ba5eef167aa
Refactor more instances of avcodec_initialized handling into init_avcodec().
diego
parents:
31949
diff
changeset
|
466 |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
467 switch (format) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
468 case 0x2000: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
469 case 0x332D6361: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
470 case 0x332D4341: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
471 case MKTAG('d', 'n', 'e', 't'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
472 case MKTAG('s', 'a', 'c', '3'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
473 codec_id = CODEC_ID_AC3; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
474 break; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
475 case MKTAG('E', 'A', 'C', '3'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
476 codec_id = CODEC_ID_EAC3; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
477 break; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
478 case 0x2001: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
479 case 0x86: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
480 codec_id = CODEC_ID_DTS; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
481 break; |
30385 | 482 case MKTAG('M', 'L', 'P', ' '): |
483 codec_id = CODEC_ID_MLP; | |
484 break; | |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
485 case 0x55: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
486 case 0x5500736d: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
487 case MKTAG('.', 'm', 'p', '3'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
488 case MKTAG('M', 'P', 'E', ' '): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
489 case MKTAG('L', 'A', 'M', 'E'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
490 codec_id = CODEC_ID_MP3; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
491 break; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
492 case 0x50: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
493 case MKTAG('.', 'm', 'p', '2'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
494 case MKTAG('.', 'm', 'p', '1'): |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
495 codec_id = CODEC_ID_MP2; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
496 break; |
30385 | 497 case MKTAG('T', 'R', 'H', 'D'): |
498 codec_id = CODEC_ID_TRUEHD; | |
499 break; | |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
500 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
501 if (codec_id != CODEC_ID_NONE) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
502 *avctx = avcodec_alloc_context(); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
503 if (!*avctx) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
504 return; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
505 *parser = av_parser_init(codec_id); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
506 if (!*parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
507 av_freep(avctx); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
508 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
509 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
510 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
511 static void get_parser(sh_common_t *sh, AVCodecContext **avctx, AVCodecParserContext **parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
512 { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
513 *avctx = NULL; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
514 *parser = NULL; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
515 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
516 if (!sh || !sh->needs_parsing) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
517 return; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
518 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
519 *avctx = sh->avctx; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
520 *parser = sh->parser; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
521 if (*parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
522 return; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
523 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
524 allocate_parser(avctx, parser, sh->format); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
525 sh->avctx = *avctx; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
526 sh->parser = *parser; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
527 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
528 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
529 int ds_parse(demux_stream_t *ds, uint8_t **buffer, int *len, double pts, off_t pos) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
530 { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
531 AVCodecContext *avctx; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
532 AVCodecParserContext *parser; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
533 get_parser(ds->sh, &avctx, &parser); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
534 if (!parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
535 return *len; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
536 return av_parser_parse2(parser, avctx, buffer, len, *buffer, *len, pts, pts, pos); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
537 } |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
538 |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
539 static void clear_parser(sh_common_t *sh) |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
540 { |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
541 av_parser_close(sh->parser); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
542 sh->parser = NULL; |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
543 av_freep(&sh->avctx); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
544 } |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
545 |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
546 void ds_clear_parser(demux_stream_t *ds) |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
547 { |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
548 if (!ds->sh) |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
549 return; |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
550 clear_parser(ds->sh); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
551 } |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
552 #endif |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
553 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
554 void ds_add_packet(demux_stream_t *ds, demux_packet_t *dp) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
555 { |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
556 #if PARSE_ON_ADD && defined(CONFIG_FFMPEG) |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
557 int len = dp->len; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
558 int pos = 0; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
559 while (len > 0) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
560 uint8_t *parsed_start = dp->buffer + pos; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
561 int parsed_len = len; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
562 int consumed = ds_parse(ds->sh, &parsed_start, &parsed_len, dp->pts, dp->pos); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
563 pos += consumed; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
564 len -= consumed; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
565 if (parsed_start == dp->buffer && parsed_len == dp->len) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
566 ds_add_packet_internal(ds, dp); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
567 } else if (parsed_len) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
568 demux_packet_t *dp2 = new_demux_packet(parsed_len); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
569 dp2->pos = dp->pos; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
570 dp2->pts = dp->pts; // should be parser->pts but that works badly |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
571 memcpy(dp2->buffer, parsed_start, parsed_len); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
572 ds_add_packet_internal(ds, dp2); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
573 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
574 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
575 #else |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
576 ds_add_packet_internal(ds, dp); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
577 #endif |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
578 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
579 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
580 void ds_read_packet(demux_stream_t *ds, stream_t *stream, int len, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
581 double pts, off_t pos, int flags) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
582 { |
27055 | 583 demux_packet_t *dp = new_demux_packet(len); |
584 len = stream_read(stream, dp->buffer, len); | |
10891
65ed62e138fa
Fixed 'reading after EOF'. demuxers didn't check, how many they've read!
lumag
parents:
10882
diff
changeset
|
585 resize_demux_packet(dp, len); |
27045 | 586 dp->pts = pts; |
27055 | 587 dp->pos = pos; |
588 dp->flags = flags; | |
1 | 589 // append packet to DS stream: |
27055 | 590 ds_add_packet(ds, dp); |
1 | 591 } |
592 | |
593 // return value: | |
594 // 0 = EOF or no stream found or invalid type | |
595 // 1 = successfully read a packet | |
596 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
597 int demux_fill_buffer(demuxer_t *demux, demux_stream_t *ds) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
598 { |
27055 | 599 // Note: parameter 'ds' can be NULL! |
600 return demux->desc->fill_buffer(demux, ds); | |
1 | 601 } |
602 | |
603 // return value: | |
604 // 0 = EOF | |
25197
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
605 // 1 = successful |
26037 | 606 #define MAX_ACUMULATED_PACKETS 64 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
607 int ds_fill_buffer(demux_stream_t *ds) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
608 { |
27055 | 609 demuxer_t *demux = ds->demuxer; |
610 if (ds->current) | |
611 free_demux_packet(ds->current); | |
612 ds->current = NULL; | |
613 if (mp_msg_test(MSGT_DEMUXER, MSGL_DBG3)) { | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
614 if (ds == demux->audio) |
27056 | 615 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, |
616 "ds_fill_buffer(d_audio) called\n"); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
617 else if (ds == demux->video) |
27056 | 618 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, |
619 "ds_fill_buffer(d_video) called\n"); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
620 else if (ds == demux->sub) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
621 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, "ds_fill_buffer(d_sub) called\n"); |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
622 else |
27056 | 623 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, |
624 "ds_fill_buffer(unknown 0x%X) called\n", (unsigned int) ds); | |
27055 | 625 } |
626 while (1) { | |
627 if (ds->packs) { | |
628 demux_packet_t *p = ds->first; | |
26071
449ad51bd8c7
in ds_fill_buffer() disabled the code that demuxes until the arrival of the right reference_clock
nicodvb
parents:
26037
diff
changeset
|
629 #if 0 |
27055 | 630 if (demux->reference_clock != MP_NOPTS_VALUE) { |
27059 | 631 if ( p->pts != MP_NOPTS_VALUE |
632 && p->pts > demux->reference_clock | |
633 && ds->packs < MAX_ACUMULATED_PACKETS) { | |
27055 | 634 if (demux_fill_buffer(demux, ds)) |
635 continue; | |
636 } | |
637 } | |
26071
449ad51bd8c7
in ds_fill_buffer() disabled the code that demuxes until the arrival of the right reference_clock
nicodvb
parents:
26037
diff
changeset
|
638 #endif |
27055 | 639 // copy useful data: |
640 ds->buffer = p->buffer; | |
641 ds->buffer_pos = 0; | |
642 ds->buffer_size = p->len; | |
643 ds->pos = p->pos; | |
644 ds->dpos += p->len; // !!! | |
645 ++ds->pack_no; | |
646 if (p->pts != MP_NOPTS_VALUE) { | |
647 ds->pts = p->pts; | |
648 ds->pts_bytes = 0; | |
649 } | |
650 ds->pts_bytes += p->len; // !!! | |
651 if (p->stream_pts != MP_NOPTS_VALUE) | |
652 demux->stream_pts = p->stream_pts; | |
653 ds->flags = p->flags; | |
654 // unlink packet: | |
655 ds->bytes -= p->len; | |
656 ds->current = p; | |
657 ds->first = p->next; | |
658 if (!ds->first) | |
659 ds->last = NULL; | |
660 --ds->packs; | |
661 return 1; | |
662 } | |
27056 | 663 if (demux->audio->packs >= MAX_PACKS |
664 || demux->audio->bytes >= MAX_PACK_BYTES) { | |
665 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyAudioInBuffer, | |
666 demux->audio->packs, demux->audio->bytes); | |
27055 | 667 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
668 break; | |
669 } | |
27056 | 670 if (demux->video->packs >= MAX_PACKS |
671 || demux->video->bytes >= MAX_PACK_BYTES) { | |
672 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyVideoInBuffer, | |
673 demux->video->packs, demux->video->bytes); | |
27055 | 674 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
675 break; | |
676 } | |
677 if (!demux_fill_buffer(demux, ds)) { | |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
678 #if PARSE_ON_ADD && defined(CONFIG_FFMPEG) |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
679 uint8_t *parsed_start = NULL; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
680 int parsed_len = 0; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
681 ds_parse(ds->sh, &parsed_start, &parsed_len, MP_NOPTS_VALUE, 0); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
682 if (parsed_len) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
683 demux_packet_t *dp2 = new_demux_packet(parsed_len); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
684 dp2->pts = MP_NOPTS_VALUE; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
685 memcpy(dp2->buffer, parsed_start, parsed_len); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
686 ds_add_packet_internal(ds, dp2); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
687 continue; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
688 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
689 #endif |
27056 | 690 mp_dbg(MSGT_DEMUXER, MSGL_DBG2, |
691 "ds_fill_buffer()->demux_fill_buffer() failed\n"); | |
27055 | 692 break; // EOF |
693 } | |
1 | 694 } |
27055 | 695 ds->buffer_pos = ds->buffer_size = 0; |
696 ds->buffer = NULL; | |
27056 | 697 mp_msg(MSGT_DEMUXER, MSGL_V, |
698 "ds_fill_buffer: EOF reached (stream: %s) \n", | |
699 ds == demux->audio ? "audio" : "video"); | |
27055 | 700 ds->eof = 1; |
701 return 0; | |
1 | 702 } |
703 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
704 int demux_read_data(demux_stream_t *ds, unsigned char *mem, int len) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
705 { |
27055 | 706 int x; |
707 int bytes = 0; | |
708 while (len > 0) { | |
709 x = ds->buffer_size - ds->buffer_pos; | |
710 if (x == 0) { | |
711 if (!ds_fill_buffer(ds)) | |
712 return bytes; | |
713 } else { | |
714 if (x > len) | |
715 x = len; | |
716 if (mem) | |
717 fast_memcpy(mem + bytes, &ds->buffer[ds->buffer_pos], x); | |
718 bytes += x; | |
719 len -= x; | |
720 ds->buffer_pos += x; | |
721 } | |
722 } | |
723 return bytes; | |
1 | 724 } |
725 | |
17417
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
726 /** |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
727 * \brief read data until the given 3-byte pattern is encountered, up to maxlen |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
728 * \param mem memory to read data into, may be NULL to discard data |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
729 * \param maxlen maximum number of bytes to read |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
730 * \param read number of bytes actually read |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
731 * \param pattern pattern to search for (lowest 8 bits are ignored) |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
732 * \return whether pattern was found |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
733 */ |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
734 int demux_pattern_3(demux_stream_t *ds, unsigned char *mem, int maxlen, |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
735 int *read, uint32_t pattern) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
736 { |
27055 | 737 register uint32_t head = 0xffffff00; |
738 register uint32_t pat = pattern & 0xffffff00; | |
739 int total_len = 0; | |
17417
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
740 do { |
27055 | 741 register unsigned char *ds_buf = &ds->buffer[ds->buffer_size]; |
742 int len = ds->buffer_size - ds->buffer_pos; | |
743 register long pos = -len; | |
744 if (unlikely(pos >= 0)) { // buffer is empty | |
745 ds_fill_buffer(ds); | |
746 continue; | |
747 } | |
748 do { | |
749 head |= ds_buf[pos]; | |
750 head <<= 8; | |
751 } while (++pos && head != pat); | |
752 len += pos; | |
753 if (total_len + len > maxlen) | |
754 len = maxlen - total_len; | |
755 len = demux_read_data(ds, mem ? &mem[total_len] : NULL, len); | |
756 total_len += len; | |
757 } while ((head != pat || total_len < 3) && total_len < maxlen && !ds->eof); | |
758 if (read) | |
759 *read = total_len; | |
760 return total_len >= 3 && head == pat; | |
17417
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
761 } |
746 | 762 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
763 void ds_free_packs(demux_stream_t *ds) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
764 { |
27055 | 765 demux_packet_t *dp = ds->first; |
766 while (dp) { | |
767 demux_packet_t *dn = dp->next; | |
768 free_demux_packet(dp); | |
769 dp = dn; | |
770 } | |
771 if (ds->asf_packet) { | |
772 // free unfinished .asf fragments: | |
773 free(ds->asf_packet->buffer); | |
774 free(ds->asf_packet); | |
775 ds->asf_packet = NULL; | |
776 } | |
777 ds->first = ds->last = NULL; | |
778 ds->packs = 0; // !!!!! | |
779 ds->bytes = 0; | |
780 if (ds->current) | |
781 free_demux_packet(ds->current); | |
782 ds->current = NULL; | |
783 ds->buffer = NULL; | |
784 ds->buffer_pos = ds->buffer_size; | |
785 ds->pts = 0; | |
786 ds->pts_bytes = 0; | |
1 | 787 } |
788 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
789 int ds_get_packet(demux_stream_t *ds, unsigned char **start) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
790 { |
24826 | 791 int len; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
792 if (ds->buffer_pos >= ds->buffer_size) { |
27052 | 793 if (!ds_fill_buffer(ds)) { |
1 | 794 // EOF |
795 *start = NULL; | |
796 return -1; | |
27052 | 797 } |
1 | 798 } |
27055 | 799 len = ds->buffer_size - ds->buffer_pos; |
24826 | 800 *start = &ds->buffer[ds->buffer_pos]; |
27055 | 801 ds->buffer_pos += len; |
24826 | 802 return len; |
1 | 803 } |
554 | 804 |
27055 | 805 int ds_get_packet_pts(demux_stream_t *ds, unsigned char **start, double *pts) |
18242
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
806 { |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
807 int len; |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
808 *pts = MP_NOPTS_VALUE; |
29504 | 809 len = ds_get_packet(ds, start); |
810 if (len < 0) | |
811 return len; | |
18917
d9a75b26da6c
Add a new video pts tracking mode, enabled by option -correct-pts.
uau
parents:
18900
diff
changeset
|
812 // Return pts unless this read starts from the middle of a packet |
29504 | 813 if (len == ds->buffer_pos) |
27052 | 814 *pts = ds->current->pts; |
18242
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
815 return len; |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
816 } |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
817 |
31558 | 818 /** |
819 * Get a subtitle packet. In particular avoid reading the stream. | |
820 * \param pts input: maximum pts value of subtitle packet. NOPTS or NULL for any. | |
821 * output: start/referece pts of subtitle | |
822 * May be NULL. | |
823 * \param endpts output: pts for end of display time. May be NULL. | |
824 * \return -1 if no packet is available | |
825 */ | |
826 int ds_get_packet_sub(demux_stream_t *ds, unsigned char **start, | |
827 double *pts, double *endpts) | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
828 { |
24826 | 829 int len; |
31558 | 830 *start = NULL; |
831 // initialize pts | |
832 if (pts) | |
833 *pts = MP_NOPTS_VALUE; | |
834 if (endpts) | |
835 *endpts = MP_NOPTS_VALUE; | |
27055 | 836 if (ds->buffer_pos >= ds->buffer_size) { |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
837 if (!ds->packs) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
838 return -1; // no sub |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
839 if (!ds_fill_buffer(ds)) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
840 return -1; // EOF |
554 | 841 } |
31558 | 842 // only start of buffer has valid pts |
843 if (ds->buffer_pos == 0) { | |
844 if (endpts) | |
845 *endpts = ds->current->endpts; | |
846 if (pts) { | |
847 *pts = ds->current->pts; | |
848 // check if we are too early | |
849 if (*pts != MP_NOPTS_VALUE && ds->current->pts != MP_NOPTS_VALUE && | |
850 ds->current->pts > *pts) | |
851 return -1; | |
852 } | |
853 } | |
27055 | 854 len = ds->buffer_size - ds->buffer_pos; |
24826 | 855 *start = &ds->buffer[ds->buffer_pos]; |
27055 | 856 ds->buffer_pos += len; |
24826 | 857 return len; |
554 | 858 } |
859 | |
18309
87161f96fa66
Change common pts variables from floats to doubles. Individual demuxers
uau
parents:
18242
diff
changeset
|
860 double ds_get_next_pts(demux_stream_t *ds) |
87161f96fa66
Change common pts variables from floats to doubles. Individual demuxers
uau
parents:
18242
diff
changeset
|
861 { |
27055 | 862 demuxer_t *demux = ds->demuxer; |
31272
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
863 // if we have not read from the "current" packet, consider it |
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
864 // as the next, otherwise we never get the pts for the first packet. |
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
865 while (!ds->first && (!ds->current || ds->buffer_pos)) { |
27056 | 866 if (demux->audio->packs >= MAX_PACKS |
867 || demux->audio->bytes >= MAX_PACK_BYTES) { | |
868 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyAudioInBuffer, | |
869 demux->audio->packs, demux->audio->bytes); | |
27055 | 870 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
871 return MP_NOPTS_VALUE; | |
872 } | |
27056 | 873 if (demux->video->packs >= MAX_PACKS |
874 || demux->video->bytes >= MAX_PACK_BYTES) { | |
875 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyVideoInBuffer, | |
876 demux->video->packs, demux->video->bytes); | |
27055 | 877 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
878 return MP_NOPTS_VALUE; | |
879 } | |
880 if (!demux_fill_buffer(demux, ds)) | |
881 return MP_NOPTS_VALUE; | |
5930
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5897
diff
changeset
|
882 } |
31272
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
883 // take pts from "current" if we never read from it. |
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
884 if (ds->current && !ds->buffer_pos) |
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
885 return ds->current->pts; |
27055 | 886 return ds->first->pts; |
5930
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5897
diff
changeset
|
887 } |
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5897
diff
changeset
|
888 |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
889 // ==================================================================== |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
890 |
16175 | 891 void demuxer_help(void) |
892 { | |
27055 | 893 int i; |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
894 |
27055 | 895 mp_msg(MSGT_DEMUXER, MSGL_INFO, "Available demuxers:\n"); |
896 mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer: type info: (comment)\n"); | |
897 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DEMUXERS\n"); | |
898 for (i = 0; demuxer_list[i]; i++) { | |
899 if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Don't display special demuxers | |
900 continue; | |
901 if (demuxer_list[i]->comment && strlen(demuxer_list[i]->comment)) | |
902 mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s %2d %s (%s)\n", | |
27056 | 903 demuxer_list[i]->name, demuxer_list[i]->type, |
904 demuxer_list[i]->info, demuxer_list[i]->comment); | |
27055 | 905 else |
906 mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s %2d %s\n", | |
27056 | 907 demuxer_list[i]->name, demuxer_list[i]->type, |
908 demuxer_list[i]->info); | |
27055 | 909 } |
16175 | 910 } |
911 | |
14693
37116118ab6a
avisynth demuxer patch by Gianluigi Tiesi <mplayer at netfarm.it>
faust3
parents:
14666
diff
changeset
|
912 |
16175 | 913 /** |
914 * Get demuxer type for a given demuxer name | |
915 * | |
916 * @param demuxer_name string with demuxer name of demuxer number | |
16321
efbfac98cab1
Allow forcing of demuxers and codecs by prepending '+'
reimar
parents:
16310
diff
changeset
|
917 * @param force will be set if demuxer should be forced. |
efbfac98cab1
Allow forcing of demuxers and codecs by prepending '+'
reimar
parents:
16310
diff
changeset
|
918 * May be NULL. |
16175 | 919 * @return DEMUXER_TYPE_xxx, -1 if error or not found |
920 */ | |
16321
efbfac98cab1
Allow forcing of demuxers and codecs by prepending '+'
reimar
parents:
16310
diff
changeset
|
921 int get_demuxer_type_from_name(char *demuxer_name, int *force) |
16175 | 922 { |
27055 | 923 int i; |
924 long type_int; | |
925 char *endptr; | |
5133
9841a86d66f9
Initial ogg demuxer. No seeking, a/v sync is broken. Support avi
albeu
parents:
5107
diff
changeset
|
926 |
27055 | 927 if (!demuxer_name || !demuxer_name[0]) |
928 return DEMUXER_TYPE_UNKNOWN; | |
929 if (force) | |
930 *force = demuxer_name[0] == '+'; | |
931 if (demuxer_name[0] == '+') | |
932 demuxer_name = &demuxer_name[1]; | |
933 for (i = 0; demuxer_list[i]; i++) { | |
934 if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Can't select special demuxers from commandline | |
935 continue; | |
936 if (strcmp(demuxer_name, demuxer_list[i]->name) == 0) | |
937 return demuxer_list[i]->type; | |
938 } | |
16175 | 939 |
27055 | 940 // No match found, try to parse name as an integer (demuxer number) |
941 type_int = strtol(demuxer_name, &endptr, 0); | |
942 if (*endptr) // Conversion failed | |
943 return -1; | |
944 if ((type_int > 0) && (type_int <= DEMUXER_TYPE_MAX)) | |
945 return (int) type_int; | |
946 | |
26437 | 947 return -1; |
16175 | 948 } |
3801
3cea69dda1b3
added NuppelVideo demuxer, based on Panagiotis Issaris' patch
alex
parents:
3786
diff
changeset
|
949 |
27055 | 950 int extension_parsing = 1; // 0=off 1=mixed (used only for unstable formats) |
6384
f0b933918a22
Support for playing audio cds using cdparanoia. Include a raw audio
albeu
parents:
6192
diff
changeset
|
951 |
27055 | 952 int correct_pts = 0; |
953 int user_correct_pts = -1; | |
18917
d9a75b26da6c
Add a new video pts tracking mode, enabled by option -correct-pts.
uau
parents:
18900
diff
changeset
|
954 |
9751
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
955 /* |
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
956 NOTE : Several demuxers may be opened at the same time so |
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
957 demuxers should NEVER rely on an external var to enable them |
25197
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
958 self. If a demuxer can't do any auto-detection it should only use |
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
959 file_format. The user can explicitly set file_format with the -demuxer |
9751
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
960 option so there is really no need for another extra var. |
25197
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
961 For convenience an option can be added to set file_format directly |
9751
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
962 to the right type (ex: rawaudio,rawvideo). |
25197
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
963 Also the stream can override the file_format so a demuxer which rely |
9751
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
964 on a special stream type can set file_format at the stream level |
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
965 (ex: tv,mf). |
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
966 */ |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
967 |
27054 | 968 static demuxer_t *demux_open_stream(stream_t *stream, int file_format, |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
969 int force, int audio_id, int video_id, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
970 int dvdsub_id, char *filename) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
971 { |
27055 | 972 demuxer_t *demuxer = NULL; |
1659 | 973 |
27055 | 974 sh_video_t *sh_video = NULL; |
26437 | 975 |
27055 | 976 const demuxer_desc_t *demuxer_desc; |
977 int fformat = 0; | |
978 int i; | |
26437 | 979 |
27055 | 980 // If somebody requested a demuxer check it |
981 if (file_format) { | |
982 if ((demuxer_desc = get_demuxer_desc_from_type(file_format))) { | |
27056 | 983 demuxer = new_demuxer(stream, demuxer_desc->type, audio_id, |
984 video_id, dvdsub_id, filename); | |
27055 | 985 if (demuxer_desc->check_file) |
986 fformat = demuxer_desc->check_file(demuxer); | |
987 if (force || !demuxer_desc->check_file) | |
988 fformat = demuxer_desc->type; | |
989 if (fformat != 0) { | |
990 if (fformat == demuxer_desc->type) { | |
991 demuxer_t *demux2 = demuxer; | |
992 // Move messages to demuxer detection code? | |
27056 | 993 mp_msg(MSGT_DEMUXER, MSGL_INFO, |
994 MSGTR_Detected_XXX_FileFormat, | |
995 demuxer_desc->shortdesc); | |
27055 | 996 file_format = fformat; |
27056 | 997 if (!demuxer->desc->open |
998 || (demux2 = demuxer->desc->open(demuxer))) { | |
27055 | 999 demuxer = demux2; |
1000 goto dmx_open; | |
1001 } | |
1002 } else { | |
1003 // Format changed after check, recurse | |
1004 free_demuxer(demuxer); | |
27056 | 1005 return demux_open_stream(stream, fformat, force, audio_id, |
1006 video_id, dvdsub_id, filename); | |
27055 | 1007 } |
1008 } | |
1009 // Check failed for forced demuxer, quit | |
1010 free_demuxer(demuxer); | |
1011 return NULL; | |
20303 | 1012 } |
1013 } | |
27055 | 1014 // Test demuxers with safe file checks |
1015 for (i = 0; (demuxer_desc = demuxer_list[i]); i++) { | |
1016 if (demuxer_desc->safe_check) { | |
27056 | 1017 demuxer = new_demuxer(stream, demuxer_desc->type, audio_id, |
1018 video_id, dvdsub_id, filename); | |
27055 | 1019 if ((fformat = demuxer_desc->check_file(demuxer)) != 0) { |
1020 if (fformat == demuxer_desc->type) { | |
1021 demuxer_t *demux2 = demuxer; | |
27056 | 1022 mp_msg(MSGT_DEMUXER, MSGL_INFO, |
1023 MSGTR_Detected_XXX_FileFormat, | |
1024 demuxer_desc->shortdesc); | |
27055 | 1025 file_format = fformat; |
27056 | 1026 if (!demuxer->desc->open |
1027 || (demux2 = demuxer->desc->open(demuxer))) { | |
27055 | 1028 demuxer = demux2; |
1029 goto dmx_open; | |
1030 } | |
1031 } else { | |
1032 if (fformat == DEMUXER_TYPE_PLAYLIST) | |
1033 return demuxer; // handled in mplayer.c | |
1034 // Format changed after check, recurse | |
1035 free_demuxer(demuxer); | |
1036 demuxer = demux_open_stream(stream, fformat, force, | |
27056 | 1037 audio_id, video_id, |
1038 dvdsub_id, filename); | |
27055 | 1039 if (demuxer) |
1040 return demuxer; // done! | |
1041 file_format = DEMUXER_TYPE_UNKNOWN; | |
1042 } | |
1043 } | |
1044 free_demuxer(demuxer); | |
1045 demuxer = NULL; | |
26379 | 1046 } |
1047 } | |
9006
d00997f12257
extension-based filetype detection for headerless files (mp3 vs mpeg, etc)
arpi
parents:
8937
diff
changeset
|
1048 |
27055 | 1049 // If no forced demuxer perform file extension based detection |
27056 | 1050 // Ok. We're over the stable detectable fileformats, the next ones are |
1051 // a bit fuzzy. So by default (extension_parsing==1) try extension-based | |
1052 // detection first: | |
1053 if (file_format == DEMUXER_TYPE_UNKNOWN && filename | |
1054 && extension_parsing == 1) { | |
27055 | 1055 file_format = demuxer_type_by_filename(filename); |
1056 if (file_format != DEMUXER_TYPE_UNKNOWN) { | |
1057 // we like recursion :) | |
27056 | 1058 demuxer = demux_open_stream(stream, file_format, force, audio_id, |
1059 video_id, dvdsub_id, filename); | |
27055 | 1060 if (demuxer) |
1061 return demuxer; // done! | |
1062 file_format = DEMUXER_TYPE_UNKNOWN; // continue fuzzy guessing... | |
27056 | 1063 mp_msg(MSGT_DEMUXER, MSGL_V, |
1064 "demuxer: continue fuzzy content-based format guessing...\n"); | |
26437 | 1065 } |
1066 } | |
27055 | 1067 // Try detection for all other demuxers |
1068 for (i = 0; (demuxer_desc = demuxer_list[i]); i++) { | |
1069 if (!demuxer_desc->safe_check && demuxer_desc->check_file) { | |
27056 | 1070 demuxer = new_demuxer(stream, demuxer_desc->type, audio_id, |
1071 video_id, dvdsub_id, filename); | |
27055 | 1072 if ((fformat = demuxer_desc->check_file(demuxer)) != 0) { |
1073 if (fformat == demuxer_desc->type) { | |
1074 demuxer_t *demux2 = demuxer; | |
27056 | 1075 mp_msg(MSGT_DEMUXER, MSGL_INFO, |
1076 MSGTR_Detected_XXX_FileFormat, | |
1077 demuxer_desc->shortdesc); | |
27055 | 1078 file_format = fformat; |
27056 | 1079 if (!demuxer->desc->open |
1080 || (demux2 = demuxer->desc->open(demuxer))) { | |
27055 | 1081 demuxer = demux2; |
1082 goto dmx_open; | |
1083 } | |
1084 } else { | |
1085 if (fformat == DEMUXER_TYPE_PLAYLIST) | |
1086 return demuxer; // handled in mplayer.c | |
1087 // Format changed after check, recurse | |
1088 free_demuxer(demuxer); | |
1089 demuxer = demux_open_stream(stream, fformat, force, | |
27056 | 1090 audio_id, video_id, |
1091 dvdsub_id, filename); | |
27055 | 1092 if (demuxer) |
1093 return demuxer; // done! | |
1094 file_format = DEMUXER_TYPE_UNKNOWN; | |
1095 } | |
1096 } | |
1097 free_demuxer(demuxer); | |
1098 demuxer = NULL; | |
1099 } | |
1100 } | |
26437 | 1101 |
27055 | 1102 return NULL; |
1103 //====== File format recognized, set up these for compatibility: ========= | |
1104 dmx_open: | |
1105 | |
1106 demuxer->file_format = file_format; | |
1107 | |
1108 if ((sh_video = demuxer->video->sh) && sh_video->bih) { | |
1109 int biComp = le2me_32(sh_video->bih->biCompression); | |
27056 | 1110 mp_msg(MSGT_DEMUX, MSGL_INFO, |
1111 "VIDEO: [%.4s] %dx%d %dbpp %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n", | |
1112 (char *) &biComp, sh_video->bih->biWidth, | |
1113 sh_video->bih->biHeight, sh_video->bih->biBitCount, | |
1114 sh_video->fps, sh_video->i_bps * 0.008f, | |
27055 | 1115 sh_video->i_bps / 1024.0f); |
1116 } | |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
1117 #ifdef CONFIG_ASS |
27055 | 1118 if (ass_enabled && ass_library) { |
1119 for (i = 0; i < MAX_S_STREAMS; ++i) { | |
1120 sh_sub_t *sh = demuxer->s_streams[i]; | |
1121 if (sh && sh->type == 'a') { | |
1122 sh->ass_track = ass_new_track(ass_library); | |
1123 if (sh->ass_track && sh->extradata) | |
27056 | 1124 ass_process_codec_private(sh->ass_track, sh->extradata, |
1125 sh->extradata_len); | |
27055 | 1126 } else if (sh && sh->type != 'v') |
1127 sh->ass_track = ass_default_track(ass_library); | |
1128 } | |
1129 } | |
26437 | 1130 #endif |
27055 | 1131 return demuxer; |
26437 | 1132 } |
1133 | |
27054 | 1134 char *audio_stream = NULL; |
27056 | 1135 char *sub_stream = NULL; |
9709 | 1136 int audio_stream_cache = 0; |
7867 | 1137 |
27056 | 1138 char *demuxer_name = NULL; // parameter from -demuxer |
16175 | 1139 char *audio_demuxer_name = NULL; // parameter from -audio-demuxer |
27056 | 1140 char *sub_demuxer_name = NULL; // parameter from -sub-demuxer |
16175 | 1141 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1142 demuxer_t *demux_open(stream_t *vs, int file_format, int audio_id, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1143 int video_id, int dvdsub_id, char *filename) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1144 { |
27055 | 1145 stream_t *as = NULL, *ss = NULL; |
1146 demuxer_t *vd, *ad = NULL, *sd = NULL; | |
1147 demuxer_t *res; | |
1148 int afmt = DEMUXER_TYPE_UNKNOWN, sfmt = DEMUXER_TYPE_UNKNOWN; | |
1149 int demuxer_type; | |
1150 int audio_demuxer_type = 0, sub_demuxer_type = 0; | |
1151 int demuxer_force = 0, audio_demuxer_force = 0, sub_demuxer_force = 0; | |
16175 | 1152 |
27056 | 1153 if ((demuxer_type = |
1154 get_demuxer_type_from_name(demuxer_name, &demuxer_force)) < 0) { | |
1155 mp_msg(MSGT_DEMUXER, MSGL_ERR, "-demuxer %s does not exist.\n", | |
1156 demuxer_name); | |
27055 | 1157 } |
27056 | 1158 if ((audio_demuxer_type = |
1159 get_demuxer_type_from_name(audio_demuxer_name, | |
1160 &audio_demuxer_force)) < 0) { | |
1161 mp_msg(MSGT_DEMUXER, MSGL_ERR, "-audio-demuxer %s does not exist.\n", | |
1162 audio_demuxer_name); | |
27055 | 1163 } |
27056 | 1164 if ((sub_demuxer_type = |
1165 get_demuxer_type_from_name(sub_demuxer_name, | |
1166 &sub_demuxer_force)) < 0) { | |
1167 mp_msg(MSGT_DEMUXER, MSGL_ERR, "-sub-demuxer %s does not exist.\n", | |
1168 sub_demuxer_name); | |
27055 | 1169 } |
26437 | 1170 |
27055 | 1171 if (audio_stream) { |
1172 as = open_stream(audio_stream, 0, &afmt); | |
1173 if (!as) { | |
27056 | 1174 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_CannotOpenAudioStream, |
1175 audio_stream); | |
27055 | 1176 return NULL; |
1177 } | |
1178 if (audio_stream_cache) { | |
27056 | 1179 if (!stream_enable_cache |
1180 (as, audio_stream_cache * 1024, | |
1181 audio_stream_cache * 1024 * (stream_cache_min_percent / | |
1182 100.0), | |
1183 audio_stream_cache * 1024 * (stream_cache_seek_min_percent / | |
1184 100.0))) { | |
27055 | 1185 free_stream(as); |
27056 | 1186 mp_msg(MSGT_DEMUXER, MSGL_ERR, |
1187 "Can't enable audio stream cache\n"); | |
27055 | 1188 return NULL; |
1189 } | |
1190 } | |
26379 | 1191 } |
27055 | 1192 if (sub_stream) { |
1193 ss = open_stream(sub_stream, 0, &sfmt); | |
1194 if (!ss) { | |
27056 | 1195 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_CannotOpenSubtitlesStream, |
1196 sub_stream); | |
27055 | 1197 return NULL; |
1198 } | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1199 } |
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1200 |
27055 | 1201 vd = demux_open_stream(vs, demuxer_type ? demuxer_type : file_format, |
27056 | 1202 demuxer_force, audio_stream ? -2 : audio_id, |
1203 video_id, sub_stream ? -2 : dvdsub_id, filename); | |
27055 | 1204 if (!vd) { |
1205 if (as) | |
1206 free_stream(as); | |
1207 if (ss) | |
1208 free_stream(ss); | |
1209 return NULL; | |
1210 } | |
1211 if (as) { | |
27056 | 1212 ad = demux_open_stream(as, |
1213 audio_demuxer_type ? audio_demuxer_type : afmt, | |
1214 audio_demuxer_force, audio_id, -2, -2, | |
1215 audio_stream); | |
27055 | 1216 if (!ad) { |
27056 | 1217 mp_msg(MSGT_DEMUXER, MSGL_WARN, MSGTR_OpeningAudioDemuxerFailed, |
1218 audio_stream); | |
27055 | 1219 free_stream(as); |
27056 | 1220 } else if (ad->audio->sh |
1221 && ((sh_audio_t *) ad->audio->sh)->format == 0x55) // MP3 | |
27055 | 1222 hr_mp3_seek = 1; // Enable high res seeking |
9709 | 1223 } |
27055 | 1224 if (ss) { |
1225 sd = demux_open_stream(ss, sub_demuxer_type ? sub_demuxer_type : sfmt, | |
27056 | 1226 sub_demuxer_force, -2, -2, dvdsub_id, |
1227 sub_stream); | |
27055 | 1228 if (!sd) { |
27056 | 1229 mp_msg(MSGT_DEMUXER, MSGL_WARN, |
1230 MSGTR_OpeningSubtitlesDemuxerFailed, sub_stream); | |
27055 | 1231 free_stream(ss); |
1232 } | |
1233 } | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1234 |
27055 | 1235 if (ad && sd) |
1236 res = new_demuxers_demuxer(vd, ad, sd); | |
1237 else if (ad) | |
1238 res = new_demuxers_demuxer(vd, ad, vd); | |
1239 else if (sd) | |
1240 res = new_demuxers_demuxer(vd, vd, sd); | |
1241 else | |
1242 res = vd; | |
25919
382672c7480a
Allow demuxers to choose a default value for correct_pts
reimar
parents:
25883
diff
changeset
|
1243 |
27055 | 1244 correct_pts = user_correct_pts; |
1245 if (correct_pts < 0) | |
31250
a7c91e121d79
Default to -correct-pts off if -fps was given, since -fps has no effect
reimar
parents:
30702
diff
changeset
|
1246 correct_pts = !force_fps && demux_control(res, DEMUXER_CTRL_CORRECT_PTS, NULL) |
27056 | 1247 == DEMUXER_CTRL_OK; |
27055 | 1248 return res; |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1249 } |
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1250 |
30396
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1251 /** |
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1252 * Do necessary reinitialization after e.g. a seek. |
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1253 * Do _not_ call ds_fill_buffer between the seek and this, it breaks at least |
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1254 * seeking with ASF demuxer. |
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1255 */ |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1256 static void demux_resync(demuxer_t *demuxer) |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1257 { |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1258 sh_video_t *sh_video = demuxer->video->sh; |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1259 sh_audio_t *sh_audio = demuxer->audio->sh; |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1260 demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1261 if (sh_video) { |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1262 resync_video_stream(sh_video); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1263 } |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1264 if (sh_audio) { |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1265 resync_audio_stream(sh_audio); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1266 } |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1267 } |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1268 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1269 void demux_flush(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1270 { |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1271 #if PARSE_ON_ADD |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1272 ds_clear_parser(demuxer->video); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1273 ds_clear_parser(demuxer->audio); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1274 ds_clear_parser(demuxer->sub); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1275 #endif |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1276 ds_free_packs(demuxer->video); |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1277 ds_free_packs(demuxer->audio); |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1278 ds_free_packs(demuxer->sub); |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1279 } |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1280 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1281 int demux_seek(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1282 int flags) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1283 { |
20851
6602a90a06ec
consistency fix: STREAM_CTRL_GET_TIME_LENGTH and STREAM_CTRL_GET_CURRENT_TIME now return time in (double) seconds
nicodvb
parents:
20841
diff
changeset
|
1284 double tmp = 0; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1285 double pts; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1286 |
27055 | 1287 if (!demuxer->seekable) { |
1288 if (demuxer->file_format == DEMUXER_TYPE_AVI) | |
1289 mp_msg(MSGT_SEEK, MSGL_WARN, MSGTR_CantSeekRawAVI); | |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
1290 #ifdef CONFIG_TV |
27055 | 1291 else if (demuxer->file_format == DEMUXER_TYPE_TV) |
1292 mp_msg(MSGT_SEEK, MSGL_WARN, MSGTR_TVInputNotSeekable); | |
2790 | 1293 #endif |
27055 | 1294 else |
1295 mp_msg(MSGT_SEEK, MSGL_WARN, MSGTR_CantSeekFile); | |
1296 return 0; | |
1297 } | |
26437 | 1298 |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1299 demux_flush(demuxer); |
27055 | 1300 |
27045 | 1301 demuxer->stream->eof = 0; |
27055 | 1302 demuxer->video->eof = 0; |
1303 demuxer->audio->eof = 0; | |
31949 | 1304 demuxer->sub->eof = 0; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1305 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1306 if (flags & SEEK_ABSOLUTE) |
27055 | 1307 pts = 0.0f; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1308 else { |
27055 | 1309 if (demuxer->stream_pts == MP_NOPTS_VALUE) |
1310 goto dmx_seek; | |
1311 pts = demuxer->stream_pts; | |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1312 } |
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1313 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1314 if (flags & SEEK_FACTOR) { |
27056 | 1315 if (stream_control(demuxer->stream, STREAM_CTRL_GET_TIME_LENGTH, &tmp) |
1316 == STREAM_UNSUPPORTED) | |
27055 | 1317 goto dmx_seek; |
1318 pts += tmp * rel_seek_secs; | |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1319 } else |
27055 | 1320 pts += rel_seek_secs; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1321 |
27056 | 1322 if (stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_TIME, &pts) != |
1323 STREAM_UNSUPPORTED) { | |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1324 demux_resync(demuxer); |
27055 | 1325 return 1; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1326 } |
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1327 |
27055 | 1328 dmx_seek: |
1329 if (demuxer->desc->seek) | |
1330 demuxer->desc->seek(demuxer, rel_seek_secs, audio_delay, flags); | |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1331 |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1332 demux_resync(demuxer); |
16877
9081ae3a702c
move resync_audio_stream after seeking to demuxer.c
reimar
parents:
16572
diff
changeset
|
1333 |
27055 | 1334 return 1; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1335 } |
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1336 |
19053
75327b24e06f
marks several string parameters as const, as they are not modified inside the function, Patch by Stefan Huehner, stefan AT huehner-org
reynaldo
parents:
18917
diff
changeset
|
1337 int demux_info_add(demuxer_t *demuxer, const char *opt, const char *param) |
3050 | 1338 { |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1339 char **info = demuxer->info; |
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1340 int n = 0; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1341 |
3050 | 1342 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1343 for (n = 0; info && info[2 * n] != NULL; n++) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1344 if (!strcasecmp(opt, info[2 * n])) { |
29634
342a78c13eeb
Reduce verbosity if demuxer sets an info value to the same as the current value.
reimar
parents:
29504
diff
changeset
|
1345 if (!strcmp(param, info[2 * n + 1])) { |
342a78c13eeb
Reduce verbosity if demuxer sets an info value to the same as the current value.
reimar
parents:
29504
diff
changeset
|
1346 mp_msg(MSGT_DEMUX, MSGL_V, "Demuxer info %s set to unchanged value %s\n", opt, param); |
342a78c13eeb
Reduce verbosity if demuxer sets an info value to the same as the current value.
reimar
parents:
29504
diff
changeset
|
1347 return 0; |
342a78c13eeb
Reduce verbosity if demuxer sets an info value to the same as the current value.
reimar
parents:
29504
diff
changeset
|
1348 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1349 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_DemuxerInfoChanged, opt, |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1350 param); |
27055 | 1351 free(info[2 * n + 1]); |
1352 info[2 * n + 1] = strdup(param); | |
27052 | 1353 return 0; |
27055 | 1354 } |
1355 } | |
27051 | 1356 |
30702 | 1357 info = demuxer->info = realloc(info, (2 * (n + 2)) * sizeof(char *)); |
27055 | 1358 info[2 * n] = strdup(opt); |
1359 info[2 * n + 1] = strdup(param); | |
1360 memset(&info[2 * (n + 1)], 0, 2 * sizeof(char *)); | |
3050 | 1361 |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1362 return 1; |
3050 | 1363 } |
1364 | |
1365 int demux_info_print(demuxer_t *demuxer) | |
1366 { | |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1367 char **info = demuxer->info; |
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1368 int n; |
3050 | 1369 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1370 if (!info) |
27055 | 1371 return 0; |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1372 |
27055 | 1373 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_ClipInfo); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1374 for (n = 0; info[2 * n] != NULL; n++) { |
27056 | 1375 mp_msg(MSGT_DEMUX, MSGL_INFO, " %s: %s\n", info[2 * n], |
1376 info[2 * n + 1]); | |
1377 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_NAME%d=%s\n", n, | |
1378 info[2 * n]); | |
1379 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_VALUE%d=%s\n", n, | |
1380 info[2 * n + 1]); | |
15789
32d9c8a0a02b
adds some more -identify output, patch by kiriuja < mplayer DASH patches PAM en DASH directo POUM net>
gpoirier
parents:
15780
diff
changeset
|
1381 } |
18237
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18128
diff
changeset
|
1382 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_N=%d\n", n); |
4189 | 1383 |
1384 return 0; | |
3050 | 1385 } |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1386 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1387 char *demux_info_get(demuxer_t *demuxer, const char *opt) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1388 { |
27055 | 1389 int i; |
1390 char **info = demuxer->info; | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1391 |
27055 | 1392 for (i = 0; info && info[2 * i] != NULL; i++) { |
1393 if (!strcasecmp(opt, info[2 * i])) | |
1394 return info[2 * i + 1]; | |
1395 } | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1396 |
27055 | 1397 return NULL; |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1398 } |
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1399 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1400 int demux_control(demuxer_t *demuxer, int cmd, void *arg) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1401 { |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1402 |
16175 | 1403 if (demuxer->desc->control) |
27055 | 1404 return demuxer->desc->control(demuxer, cmd, arg); |
16175 | 1405 |
1406 return DEMUXER_CTRL_NOTIMPL; | |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1407 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1408 |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1409 |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1410 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1411 double demuxer_get_time_length(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1412 { |
16346
6ff303d2876b
Make -identify's 'ID_LENGTH=' print a float and not an integer.. The
ods15
parents:
16326
diff
changeset
|
1413 double get_time_ans; |
14502
8769fa370f83
Move generic length and percent pos calculation to demuxer.c
reimar
parents:
14276
diff
changeset
|
1414 sh_video_t *sh_video = demuxer->video->sh; |
16925 | 1415 sh_audio_t *sh_audio = demuxer->audio->sh; |
14502
8769fa370f83
Move generic length and percent pos calculation to demuxer.c
reimar
parents:
14276
diff
changeset
|
1416 // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW |
27056 | 1417 if (demux_control |
1418 (demuxer, DEMUXER_CTRL_GET_TIME_LENGTH, (void *) &get_time_ans) <= 0) { | |
27055 | 1419 if (sh_video && sh_video->i_bps && sh_audio && sh_audio->i_bps) |
27056 | 1420 get_time_ans = (double) (demuxer->movi_end - |
1421 demuxer->movi_start) / (sh_video->i_bps + | |
1422 sh_audio->i_bps); | |
27055 | 1423 else if (sh_video && sh_video->i_bps) |
27056 | 1424 get_time_ans = (double) (demuxer->movi_end - |
1425 demuxer->movi_start) / sh_video->i_bps; | |
27055 | 1426 else if (sh_audio && sh_audio->i_bps) |
27056 | 1427 get_time_ans = (double) (demuxer->movi_end - |
1428 demuxer->movi_start) / sh_audio->i_bps; | |
27055 | 1429 else |
1430 get_time_ans = 0; | |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1431 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1432 return get_time_ans; |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1433 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1434 |
20749
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1435 /** |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1436 * \brief demuxer_get_current_time() returns the time of the current play in three possible ways: |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1437 * either when the stream reader satisfies STREAM_CTRL_GET_CURRENT_TIME (e.g. dvd) |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1438 * or using sh_video->pts when the former method fails |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1439 * 0 otherwise |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1440 * \return the current play time |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1441 */ |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1442 int demuxer_get_current_time(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1443 { |
20749
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1444 double get_time_ans = 0; |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1445 sh_video_t *sh_video = demuxer->video->sh; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1446 if (demuxer->stream_pts != MP_NOPTS_VALUE) |
21782
99ab6c41eb1e
use demuxer->stream_pts rather than stream_control(STREAM_CTRL_GET_CURRENT_TIME)
nicodvb
parents:
21780
diff
changeset
|
1447 get_time_ans = demuxer->stream_pts; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1448 else if (sh_video) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1449 get_time_ans = sh_video->pts; |
20749
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1450 return (int) get_time_ans; |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1451 } |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1452 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1453 int demuxer_get_percent_pos(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1454 { |
14197
2ae224195625
Use demuxer_get_percent_pos for the OSD position bar
reimar
parents:
14160
diff
changeset
|
1455 int ans = 0; |
2ae224195625
Use demuxer_get_percent_pos for the OSD position bar
reimar
parents:
14160
diff
changeset
|
1456 int res = demux_control(demuxer, DEMUXER_CTRL_GET_PERCENT_POS, &ans); |
2ae224195625
Use demuxer_get_percent_pos for the OSD position bar
reimar
parents:
14160
diff
changeset
|
1457 int len = (demuxer->movi_end - demuxer->movi_start) / 100; |
14502
8769fa370f83
Move generic length and percent pos calculation to demuxer.c
reimar
parents:
14276
diff
changeset
|
1458 if (res <= 0) { |
29486
a373af1e3b24
Handle demuxers that never set filepos by using stream_tell.
reimar
parents:
29366
diff
changeset
|
1459 off_t pos = demuxer->filepos > 0 ? demuxer->filepos : stream_tell(demuxer->stream); |
27055 | 1460 if (len > 0) |
29486
a373af1e3b24
Handle demuxers that never set filepos by using stream_tell.
reimar
parents:
29366
diff
changeset
|
1461 ans = (pos - demuxer->movi_start) / len; |
27055 | 1462 else |
1463 ans = 0; | |
14502
8769fa370f83
Move generic length and percent pos calculation to demuxer.c
reimar
parents:
14276
diff
changeset
|
1464 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1465 if (ans < 0) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1466 ans = 0; |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1467 if (ans > 100) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1468 ans = 100; |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1469 return ans; |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1470 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1471 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1472 int demuxer_switch_audio(demuxer_t *demuxer, int index) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1473 { |
15285
39eb8a327ea9
adds a parameter to the switch_audio command to directly select a track.
reimar
parents:
15046
diff
changeset
|
1474 int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_AUDIO, &index); |
39eb8a327ea9
adds a parameter to the switch_audio command to directly select a track.
reimar
parents:
15046
diff
changeset
|
1475 if (res == DEMUXER_CTRL_NOTIMPL) |
27055 | 1476 index = demuxer->audio->id; |
26089
e2f35d90ad39
Set audio->sh correctly when switching audio tracks. The same for video tracks.
eugeni
parents:
26088
diff
changeset
|
1477 if (demuxer->audio->id >= 0) |
27055 | 1478 demuxer->audio->sh = demuxer->a_streams[demuxer->audio->id]; |
26089
e2f35d90ad39
Set audio->sh correctly when switching audio tracks. The same for video tracks.
eugeni
parents:
26088
diff
changeset
|
1479 else |
27055 | 1480 demuxer->audio->sh = NULL; |
15285
39eb8a327ea9
adds a parameter to the switch_audio command to directly select a track.
reimar
parents:
15046
diff
changeset
|
1481 return index; |
15046
b7aa70b05d76
Added support of audio stream switching in the MPEG demuxer using the #-key
gpoirier
parents:
14934
diff
changeset
|
1482 } |
19342 | 1483 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1484 int demuxer_switch_video(demuxer_t *demuxer, int index) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1485 { |
20948 | 1486 int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_VIDEO, &index); |
1487 if (res == DEMUXER_CTRL_NOTIMPL) | |
27055 | 1488 index = demuxer->video->id; |
26089
e2f35d90ad39
Set audio->sh correctly when switching audio tracks. The same for video tracks.
eugeni
parents:
26088
diff
changeset
|
1489 if (demuxer->video->id >= 0) |
27055 | 1490 demuxer->video->sh = demuxer->v_streams[demuxer->video->id]; |
26089
e2f35d90ad39
Set audio->sh correctly when switching audio tracks. The same for video tracks.
eugeni
parents:
26088
diff
changeset
|
1491 else |
27055 | 1492 demuxer->video->sh = NULL; |
20948 | 1493 return index; |
1494 } | |
1495 | |
27054 | 1496 int demuxer_add_attachment(demuxer_t *demuxer, const char *name, |
1497 const char *type, const void *data, size_t size) | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1498 { |
25657 | 1499 if (!(demuxer->num_attachments & 31)) |
27056 | 1500 demuxer->attachments = realloc(demuxer->attachments, |
1501 (demuxer->num_attachments + 32) * sizeof(demux_attachment_t)); | |
25657 | 1502 |
1503 demuxer->attachments[demuxer->num_attachments].name = strdup(name); | |
1504 demuxer->attachments[demuxer->num_attachments].type = strdup(type); | |
1505 demuxer->attachments[demuxer->num_attachments].data = malloc(size); | |
1506 memcpy(demuxer->attachments[demuxer->num_attachments].data, data, size); | |
1507 demuxer->attachments[demuxer->num_attachments].data_size = size; | |
1508 | |
27055 | 1509 return demuxer->num_attachments++; |
25657 | 1510 } |
1511 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1512 int demuxer_add_chapter(demuxer_t *demuxer, const char *name, uint64_t start, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1513 uint64_t end) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1514 { |
19342 | 1515 if (demuxer->chapters == NULL) |
27055 | 1516 demuxer->chapters = malloc(32 * sizeof(*demuxer->chapters)); |
19342 | 1517 else if (!(demuxer->num_chapters % 32)) |
27056 | 1518 demuxer->chapters = realloc(demuxer->chapters, |
1519 (demuxer->num_chapters + 32) * | |
1520 sizeof(*demuxer->chapters)); | |
19342 | 1521 |
1522 demuxer->chapters[demuxer->num_chapters].start = start; | |
1523 demuxer->chapters[demuxer->num_chapters].end = end; | |
27057
42332b47d6aa
Support NULL name parameter for demuxer_add_chapter.
reimar
parents:
27056
diff
changeset
|
1524 demuxer->chapters[demuxer->num_chapters].name = strdup(name ? name : MSGTR_Unknown); |
19342 | 1525 |
29366 | 1526 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_ID=%d\n", demuxer->num_chapters); |
1527 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_START=%"PRIu64"\n", demuxer->num_chapters, start); | |
1528 if (end) | |
1529 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_END=%"PRIu64"\n", demuxer->num_chapters, end); | |
1530 if (name) | |
1531 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_NAME=%s\n", demuxer->num_chapters, name); | |
1532 | |
27055 | 1533 return demuxer->num_chapters++; |
19342 | 1534 } |
1535 | |
19435 | 1536 /** |
27051 | 1537 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways: |
19435 | 1538 * either using the demuxer->chapters structure set by the demuxer |
1539 * or asking help to the stream layer (e.g. dvd) | |
19439 | 1540 * \param chapter - chapter number wished - 0-based |
19435 | 1541 * \param mode 0: relative to current main pts, 1: absolute |
1542 * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set) | |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1543 * \param num_chapters number of chapters present (set by this function is param is not null) |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1544 * \param chapter_name name of chapter found (set by this function is param is not null) |
19435 | 1545 * \return -1 on error, current chapter if successful |
1546 */ | |
1547 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1548 int demuxer_seek_chapter(demuxer_t *demuxer, int chapter, int mode, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1549 float *seek_pts, int *num_chapters, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1550 char **chapter_name) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1551 { |
19435 | 1552 int ris; |
1553 int current, total; | |
1554 | |
1555 if (!demuxer->num_chapters || !demuxer->chapters) { | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1556 if (!mode) { |
27056 | 1557 ris = stream_control(demuxer->stream, |
1558 STREAM_CTRL_GET_CURRENT_CHAPTER, ¤t); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1559 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1560 return -1; |
19438
263e95c47aec
support relative seeking in the stream-driven case
nicodvb
parents:
19435
diff
changeset
|
1561 chapter += current; |
263e95c47aec
support relative seeking in the stream-driven case
nicodvb
parents:
19435
diff
changeset
|
1562 } |
263e95c47aec
support relative seeking in the stream-driven case
nicodvb
parents:
19435
diff
changeset
|
1563 |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1564 demux_flush(demuxer); |
19435 | 1565 |
27056 | 1566 ris = stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_CHAPTER, |
1567 &chapter); | |
19435 | 1568 |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1569 demux_resync(demuxer); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1570 |
27056 | 1571 // exit status may be ok, but main() doesn't have to seek itself |
1572 // (because e.g. dvds depend on sectors, not on pts) | |
19435 | 1573 *seek_pts = -1.0; |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1574 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1575 if (num_chapters) { |
27056 | 1576 if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS, |
1577 num_chapters) == STREAM_UNSUPPORTED) | |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1578 *num_chapters = 0; |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1579 } |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1580 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1581 if (chapter_name) { |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1582 *chapter_name = NULL; |
25314
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1583 if (num_chapters && *num_chapters) { |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1584 char *tmp = malloc(16); |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1585 if (tmp) { |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1586 sprintf(tmp, " of %3d", *num_chapters); |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1587 *chapter_name = tmp; |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1588 } |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1589 } |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1590 } |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1591 |
26758
9fb1d2c3dbd4
cosmetics: Remove pointless parentheses from return statements.
diego
parents:
26437
diff
changeset
|
1592 return ris != STREAM_UNSUPPORTED ? chapter : -1; |
27055 | 1593 } else { // chapters structure is set in the demuxer |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1594 sh_video_t *sh_video = demuxer->video->sh; |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1595 sh_audio_t *sh_audio = demuxer->audio->sh; |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1596 |
19435 | 1597 total = demuxer->num_chapters; |
1598 | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1599 if (mode == 1) //absolute seeking |
19435 | 1600 current = chapter; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1601 else { //relative seeking |
19435 | 1602 uint64_t now; |
27056 | 1603 now = (sh_video ? sh_video->pts : (sh_audio ? sh_audio->pts : 0.)) |
1604 * 1000 + .5; | |
19435 | 1605 |
1606 for (current = total - 1; current >= 0; --current) { | |
27054 | 1607 demux_chapter_t *chapter = demuxer->chapters + current; |
19435 | 1608 if (chapter->start <= now) |
1609 break; | |
1610 } | |
1611 current += chapter; | |
1612 } | |
1613 | |
1614 if (current >= total) | |
27055 | 1615 return -1; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1616 if (current < 0) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1617 current = 0; |
19435 | 1618 |
1619 *seek_pts = demuxer->chapters[current].start / 1000.0; | |
1620 | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1621 if (num_chapters) |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1622 *num_chapters = demuxer->num_chapters; |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1623 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1624 if (chapter_name) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1625 if (demuxer->chapters[current].name) |
19479
8dd04ec733f5
100l: *chapter_name was copied from the pointer rather than strupd()-ed (and next free()d in mplayer.c
nicodvb
parents:
19478
diff
changeset
|
1626 *chapter_name = strdup(demuxer->chapters[current].name); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1627 else |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1628 *chapter_name = NULL; |
19479
8dd04ec733f5
100l: *chapter_name was copied from the pointer rather than strupd()-ed (and next free()d in mplayer.c
nicodvb
parents:
19478
diff
changeset
|
1629 } |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1630 |
19435 | 1631 return current; |
1632 } | |
1633 } | |
25358 | 1634 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1635 int demuxer_get_current_chapter(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1636 { |
25358 | 1637 int chapter = -1; |
1638 if (!demuxer->num_chapters || !demuxer->chapters) { | |
1639 if (stream_control(demuxer->stream, STREAM_CTRL_GET_CURRENT_CHAPTER, | |
1640 &chapter) == STREAM_UNSUPPORTED) | |
1641 chapter = -1; | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1642 } else { |
25358 | 1643 sh_video_t *sh_video = demuxer->video->sh; |
1644 sh_audio_t *sh_audio = demuxer->audio->sh; | |
1645 uint64_t now; | |
27056 | 1646 now = (sh_video ? sh_video->pts : (sh_audio ? sh_audio->pts : 0)) |
1647 * 1000 + 0.5; | |
25358 | 1648 for (chapter = demuxer->num_chapters - 1; chapter >= 0; --chapter) { |
1649 if (demuxer->chapters[chapter].start <= now) | |
1650 break; | |
1651 } | |
1652 } | |
1653 return chapter; | |
1654 } | |
1655 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1656 char *demuxer_chapter_name(demuxer_t *demuxer, int chapter) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1657 { |
25358 | 1658 if (demuxer->num_chapters && demuxer->chapters) { |
27056 | 1659 if (chapter >= 0 && chapter < demuxer->num_chapters |
1660 && demuxer->chapters[chapter].name) | |
25358 | 1661 return strdup(demuxer->chapters[chapter].name); |
1662 } | |
1663 return NULL; | |
1664 } | |
1665 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1666 char *demuxer_chapter_display_name(demuxer_t *demuxer, int chapter) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1667 { |
25358 | 1668 char *chapter_name = demuxer_chapter_name(demuxer, chapter); |
1669 if (chapter_name) { | |
1670 char *tmp = malloc(strlen(chapter_name) + 14); | |
1671 snprintf(tmp, 63, "(%d) %s", chapter + 1, chapter_name); | |
27051 | 1672 free(chapter_name); |
25358 | 1673 return tmp; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1674 } else { |
25358 | 1675 int chapter_num = demuxer_chapter_count(demuxer); |
1676 char tmp[30]; | |
1677 if (chapter_num <= 0) | |
1678 sprintf(tmp, "(%d)", chapter + 1); | |
1679 else | |
1680 sprintf(tmp, "(%d) of %d", chapter + 1, chapter_num); | |
1681 return strdup(tmp); | |
1682 } | |
1683 } | |
1684 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1685 float demuxer_chapter_time(demuxer_t *demuxer, int chapter, float *end) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1686 { |
25358 | 1687 if (demuxer->num_chapters && demuxer->chapters && chapter >= 0 |
27055 | 1688 && chapter < demuxer->num_chapters) { |
25358 | 1689 if (end) |
1690 *end = demuxer->chapters[chapter].end / 1000.0; | |
1691 return demuxer->chapters[chapter].start / 1000.0; | |
1692 } | |
1693 return -1.0; | |
1694 } | |
1695 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1696 int demuxer_chapter_count(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1697 { |
25358 | 1698 if (!demuxer->num_chapters || !demuxer->chapters) { |
1699 int num_chapters = 0; | |
1700 if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS, | |
1701 &num_chapters) == STREAM_UNSUPPORTED) | |
1702 num_chapters = 0; | |
1703 return num_chapters; | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1704 } else |
25358 | 1705 return demuxer->num_chapters; |
1706 } | |
1707 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1708 int demuxer_angles_count(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1709 { |
27055 | 1710 int ris, angles = -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1711 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1712 ris = stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_ANGLES, &angles); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1713 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1714 return -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1715 return angles; |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1716 } |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1717 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1718 int demuxer_get_current_angle(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1719 { |
27055 | 1720 int ris, curr_angle = -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1721 ris = stream_control(demuxer->stream, STREAM_CTRL_GET_ANGLE, &curr_angle); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1722 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1723 return -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1724 return curr_angle; |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1725 } |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1726 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1727 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1728 int demuxer_set_angle(demuxer_t *demuxer, int angle) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1729 { |
27055 | 1730 int ris, angles = -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1731 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1732 angles = demuxer_angles_count(demuxer); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1733 if ((angles < 1) || (angle > angles)) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1734 return -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1735 |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1736 demux_flush(demuxer); |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1737 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1738 ris = stream_control(demuxer->stream, STREAM_CTRL_SET_ANGLE, &angle); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1739 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1740 return -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1741 |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1742 demux_resync(demuxer); |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1743 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1744 return angle; |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1745 } |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1746 |
27054 | 1747 int demuxer_audio_track_by_lang(demuxer_t *d, char *lang) |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1748 { |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1749 int i, len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1750 lang += strspn(lang, ","); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1751 while ((len = strcspn(lang, ",")) > 0) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1752 for (i = 0; i < MAX_A_STREAMS; ++i) { |
27054 | 1753 sh_audio_t *sh = d->a_streams[i]; |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1754 if (sh && sh->lang && strncmp(sh->lang, lang, len) == 0) |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1755 return sh->aid; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1756 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1757 lang += len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1758 lang += strspn(lang, ","); |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1759 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1760 return -1; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1761 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1762 |
27054 | 1763 int demuxer_sub_track_by_lang(demuxer_t *d, char *lang) |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1764 { |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1765 int i, len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1766 lang += strspn(lang, ","); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1767 while ((len = strcspn(lang, ",")) > 0) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1768 for (i = 0; i < MAX_S_STREAMS; ++i) { |
27054 | 1769 sh_sub_t *sh = d->s_streams[i]; |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1770 if (sh && sh->lang && strncmp(sh->lang, lang, len) == 0) |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1771 return sh->sid; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1772 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1773 lang += len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1774 lang += strspn(lang, ","); |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1775 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1776 return -1; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1777 } |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1778 |
27054 | 1779 int demuxer_default_audio_track(demuxer_t *d) |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1780 { |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1781 int i; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1782 for (i = 0; i < MAX_A_STREAMS; ++i) { |
27054 | 1783 sh_audio_t *sh = d->a_streams[i]; |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1784 if (sh && sh->default_track) |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1785 return sh->aid; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1786 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1787 for (i = 0; i < MAX_A_STREAMS; ++i) { |
27054 | 1788 sh_audio_t *sh = d->a_streams[i]; |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1789 if (sh) |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1790 return sh->aid; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1791 } |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1792 return -1; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1793 } |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1794 |
27054 | 1795 int demuxer_default_sub_track(demuxer_t *d) |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1796 { |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1797 int i; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1798 for (i = 0; i < MAX_S_STREAMS; ++i) { |
27054 | 1799 sh_sub_t *sh = d->s_streams[i]; |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1800 if (sh && sh->default_track) |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1801 return sh->sid; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1802 } |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1803 return -1; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1804 } |