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