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