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