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