Mercurial > mplayer.hg
annotate libmpdemux/demuxer.c @ 34346:3d0c795524b0
Fix bug with wrong focus in file selector.
The focus can only be set to fsFNameList after it's realized and mapped.
This also removes the irritating selection of the fsPathCombo.
author | ib |
---|---|
date | Sun, 11 Dec 2011 16:02:02 +0000 |
parents | d2a41814c879 |
children | f3d53cd55376 |
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) { |
34080 | 476 case 0x1600: |
33872 | 477 case MKTAG('M', 'P', '4', 'A'): |
478 codec_id = CODEC_ID_AAC; | |
479 break; | |
34080 | 480 case 0x1602: |
32495 | 481 case MKTAG('M', 'P', '4', 'L'): |
482 codec_id = CODEC_ID_AAC_LATM; | |
483 break; | |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
484 case 0x2000: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
485 case 0x332D6361: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
486 case 0x332D4341: |
32509
190a7fc12929
Add missing fourcc's that require libavcodec parsing.
cehoyos
parents:
32508
diff
changeset
|
487 case 0x20736D: |
32940
5bab4a2e1b59
100l, actually only dnet tag indicates byte-swapped AC-3.
reimar
parents:
32939
diff
changeset
|
488 case MKTAG('s', 'a', 'c', '3'): |
5bab4a2e1b59
100l, actually only dnet tag indicates byte-swapped AC-3.
reimar
parents:
32939
diff
changeset
|
489 codec_id = CODEC_ID_AC3; |
5bab4a2e1b59
100l, actually only dnet tag indicates byte-swapped AC-3.
reimar
parents:
32939
diff
changeset
|
490 break; |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
491 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
|
492 // 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
|
493 //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
|
494 break; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
495 case MKTAG('E', 'A', 'C', '3'): |
34146
19b03b022753
add forgotten ec-3 tag to parsers list in demuxers.c
compn
parents:
34080
diff
changeset
|
496 case MKTAG('e', 'c', '-', '3'): |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
497 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
|
498 break; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
499 case 0x2001: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
500 case 0x86: |
34080 | 501 case MKTAG('D', 'T', 'S', ' '): |
502 case MKTAG('d', 't', 's', ' '): | |
503 case MKTAG('d', 't', 's', 'b'): | |
504 case MKTAG('d', 't', 's', 'c'): | |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
505 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
|
506 break; |
32590
10b9ac971ef6
Add support for FLAC audio parsing, fixes playback time jumping
reimar
parents:
32509
diff
changeset
|
507 case MKTAG('f', 'L', 'a', 'C'): |
10b9ac971ef6
Add support for FLAC audio parsing, fixes playback time jumping
reimar
parents:
32509
diff
changeset
|
508 codec_id = CODEC_ID_FLAC; |
10b9ac971ef6
Add support for FLAC audio parsing, fixes playback time jumping
reimar
parents:
32509
diff
changeset
|
509 break; |
30385 | 510 case MKTAG('M', 'L', 'P', ' '): |
511 codec_id = CODEC_ID_MLP; | |
512 break; | |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
513 case 0x55: |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
514 case 0x5500736d: |
32509
190a7fc12929
Add missing fourcc's that require libavcodec parsing.
cehoyos
parents:
32508
diff
changeset
|
515 case 0x55005354: |
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', '3'): |
32508 | 517 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
|
518 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
|
519 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
|
520 break; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
521 case 0x50: |
32509
190a7fc12929
Add missing fourcc's that require libavcodec parsing.
cehoyos
parents:
32508
diff
changeset
|
522 case 0x5000736d: |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
523 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
|
524 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
|
525 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
|
526 break; |
30385 | 527 case MKTAG('T', 'R', 'H', 'D'): |
528 codec_id = CODEC_ID_TRUEHD; | |
529 break; | |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
530 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
531 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
|
532 *avctx = avcodec_alloc_context(); |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
533 if (!*avctx) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
534 return; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
535 *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
|
536 if (!*parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
537 av_freep(avctx); |
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 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
540 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
541 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
|
542 { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
543 *avctx = NULL; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
544 *parser = NULL; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
545 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
546 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
|
547 return; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
548 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
549 *avctx = sh->avctx; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
550 *parser = sh->parser; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
551 if (*parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
552 return; |
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 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
|
555 sh->avctx = *avctx; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
556 sh->parser = *parser; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
557 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
558 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
559 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
|
560 { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
561 AVCodecContext *avctx; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
562 AVCodecParserContext *parser; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
563 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
|
564 if (!parser) |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
565 return *len; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
566 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
|
567 } |
30379
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 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
|
570 { |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
571 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
|
572 sh->parser = NULL; |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
573 av_freep(&sh->avctx); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
574 } |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
575 |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
576 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
|
577 { |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
578 if (!ds->sh) |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
579 return; |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
580 clear_parser(ds->sh); |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
581 } |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
582 #endif |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
583 |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
584 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
|
585 { |
32142
4614728cab25
build system: Merge all FFmpeg library checks into a single FFmpeg check.
diego
parents:
32062
diff
changeset
|
586 #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
|
587 int len = dp->len; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
588 int pos = 0; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
589 while (len > 0) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
590 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
|
591 int parsed_len = len; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
592 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
|
593 pos += consumed; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
594 len -= consumed; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
595 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
|
596 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
|
597 } else if (parsed_len) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
598 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
|
599 if (!dp2) return; |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
600 dp2->pos = dp->pos; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
601 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
|
602 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
|
603 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
|
604 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
605 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
606 #else |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
607 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
|
608 #endif |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
609 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
610 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
611 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
|
612 double pts, off_t pos, int flags) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
613 { |
27055 | 614 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
|
615 if (!dp) return; |
27055 | 616 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
|
617 resize_demux_packet(dp, len); |
27045 | 618 dp->pts = pts; |
27055 | 619 dp->pos = pos; |
620 dp->flags = flags; | |
1 | 621 // append packet to DS stream: |
27055 | 622 ds_add_packet(ds, dp); |
1 | 623 } |
624 | |
625 // return value: | |
626 // 0 = EOF or no stream found or invalid type | |
627 // 1 = successfully read a packet | |
628 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
629 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
|
630 { |
27055 | 631 // Note: parameter 'ds' can be NULL! |
632 return demux->desc->fill_buffer(demux, ds); | |
1 | 633 } |
634 | |
635 // return value: | |
636 // 0 = EOF | |
25197
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
637 // 1 = successful |
33487 | 638 #define MAX_ACCUMULATED_PACKETS 64 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
639 int ds_fill_buffer(demux_stream_t *ds) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
640 { |
27055 | 641 demuxer_t *demux = ds->demuxer; |
642 if (ds->current) | |
643 free_demux_packet(ds->current); | |
644 ds->current = NULL; | |
645 if (mp_msg_test(MSGT_DEMUXER, MSGL_DBG3)) { | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
646 if (ds == demux->audio) |
27056 | 647 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, |
648 "ds_fill_buffer(d_audio) called\n"); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
649 else if (ds == demux->video) |
27056 | 650 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, |
651 "ds_fill_buffer(d_video) called\n"); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
652 else if (ds == demux->sub) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
653 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
|
654 else |
27056 | 655 mp_dbg(MSGT_DEMUXER, MSGL_DBG3, |
656 "ds_fill_buffer(unknown 0x%X) called\n", (unsigned int) ds); | |
27055 | 657 } |
658 while (1) { | |
659 if (ds->packs) { | |
660 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
|
661 // 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
|
662 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
|
663 #if 0 |
27055 | 664 if (demux->reference_clock != MP_NOPTS_VALUE) { |
27059 | 665 if ( p->pts != MP_NOPTS_VALUE |
666 && p->pts > demux->reference_clock | |
33487 | 667 && ds->packs < MAX_ACCUMULATED_PACKETS) { |
27055 | 668 if (demux_fill_buffer(demux, ds)) |
669 continue; | |
670 } | |
671 } | |
26071
449ad51bd8c7
in ds_fill_buffer() disabled the code that demuxes until the arrival of the right reference_clock
nicodvb
parents:
26037
diff
changeset
|
672 #endif |
27055 | 673 // copy useful data: |
674 ds->buffer = p->buffer; | |
675 ds->buffer_pos = 0; | |
676 ds->buffer_size = p->len; | |
677 ds->pos = p->pos; | |
678 ds->dpos += p->len; // !!! | |
679 ++ds->pack_no; | |
680 if (p->pts != MP_NOPTS_VALUE) { | |
681 ds->pts = p->pts; | |
682 ds->pts_bytes = 0; | |
683 } | |
684 ds->pts_bytes += p->len; // !!! | |
685 if (p->stream_pts != MP_NOPTS_VALUE) | |
686 demux->stream_pts = p->stream_pts; | |
687 ds->flags = p->flags; | |
688 // unlink packet: | |
689 ds->bytes -= p->len; | |
690 ds->current = p; | |
691 ds->first = p->next; | |
692 if (!ds->first) | |
693 ds->last = NULL; | |
694 --ds->packs; | |
695 return 1; | |
696 } | |
32736
a25f55874cdd
Improve EOF handling in ds_fill_buffer for the case where one stream ends
reimar
parents:
32590
diff
changeset
|
697 // 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
|
698 if (ds->eof) |
a25f55874cdd
Improve EOF handling in ds_fill_buffer for the case where one stream ends
reimar
parents:
32590
diff
changeset
|
699 break; |
27056 | 700 if (demux->audio->packs >= MAX_PACKS |
701 || demux->audio->bytes >= MAX_PACK_BYTES) { | |
702 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyAudioInBuffer, | |
703 demux->audio->packs, demux->audio->bytes); | |
27055 | 704 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
705 break; | |
706 } | |
27056 | 707 if (demux->video->packs >= MAX_PACKS |
708 || demux->video->bytes >= MAX_PACK_BYTES) { | |
709 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyVideoInBuffer, | |
710 demux->video->packs, demux->video->bytes); | |
27055 | 711 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
712 break; | |
713 } | |
714 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
|
715 #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
|
716 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
|
717 int parsed_len = 0; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
718 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
|
719 if (parsed_len) { |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
720 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
|
721 if (!dp2) continue; |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
722 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
|
723 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
|
724 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
|
725 continue; |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
726 } |
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
29832
diff
changeset
|
727 #endif |
27056 | 728 mp_dbg(MSGT_DEMUXER, MSGL_DBG2, |
729 "ds_fill_buffer()->demux_fill_buffer() failed\n"); | |
27055 | 730 break; // EOF |
731 } | |
1 | 732 } |
27055 | 733 ds->buffer_pos = ds->buffer_size = 0; |
734 ds->buffer = NULL; | |
27056 | 735 mp_msg(MSGT_DEMUXER, MSGL_V, |
736 "ds_fill_buffer: EOF reached (stream: %s) \n", | |
737 ds == demux->audio ? "audio" : "video"); | |
27055 | 738 ds->eof = 1; |
739 return 0; | |
1 | 740 } |
741 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
742 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
|
743 { |
27055 | 744 int x; |
745 int bytes = 0; | |
746 while (len > 0) { | |
747 x = ds->buffer_size - ds->buffer_pos; | |
748 if (x == 0) { | |
749 if (!ds_fill_buffer(ds)) | |
750 return bytes; | |
751 } else { | |
752 if (x > len) | |
753 x = len; | |
754 if (mem) | |
755 fast_memcpy(mem + bytes, &ds->buffer[ds->buffer_pos], x); | |
756 bytes += x; | |
757 len -= x; | |
758 ds->buffer_pos += x; | |
759 } | |
760 } | |
761 return bytes; | |
1 | 762 } |
763 | |
17417
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 * \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
|
766 * \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
|
767 * \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
|
768 * \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
|
769 * \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
|
770 * \return whether pattern was found |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
771 */ |
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
772 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
|
773 int *read, uint32_t pattern) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
774 { |
27055 | 775 register uint32_t head = 0xffffff00; |
776 register uint32_t pat = pattern & 0xffffff00; | |
777 int total_len = 0; | |
17417
960b2fa1567e
function to read from a demuxer up to (and including) the specified
reimar
parents:
17366
diff
changeset
|
778 do { |
27055 | 779 register unsigned char *ds_buf = &ds->buffer[ds->buffer_size]; |
780 int len = ds->buffer_size - ds->buffer_pos; | |
781 register long pos = -len; | |
782 if (unlikely(pos >= 0)) { // buffer is empty | |
783 ds_fill_buffer(ds); | |
784 continue; | |
785 } | |
786 do { | |
787 head |= ds_buf[pos]; | |
788 head <<= 8; | |
789 } while (++pos && head != pat); | |
790 len += pos; | |
791 if (total_len + len > maxlen) | |
792 len = maxlen - total_len; | |
793 len = demux_read_data(ds, mem ? &mem[total_len] : NULL, len); | |
794 total_len += len; | |
795 } while ((head != pat || total_len < 3) && total_len < maxlen && !ds->eof); | |
796 if (read) | |
797 *read = total_len; | |
798 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
|
799 } |
746 | 800 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
801 void ds_free_packs(demux_stream_t *ds) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
802 { |
27055 | 803 demux_packet_t *dp = ds->first; |
804 while (dp) { | |
805 demux_packet_t *dn = dp->next; | |
806 free_demux_packet(dp); | |
807 dp = dn; | |
808 } | |
809 if (ds->asf_packet) { | |
810 // free unfinished .asf fragments: | |
811 free(ds->asf_packet->buffer); | |
812 free(ds->asf_packet); | |
813 ds->asf_packet = NULL; | |
814 } | |
815 ds->first = ds->last = NULL; | |
816 ds->packs = 0; // !!!!! | |
817 ds->bytes = 0; | |
818 if (ds->current) | |
819 free_demux_packet(ds->current); | |
820 ds->current = NULL; | |
821 ds->buffer = NULL; | |
822 ds->buffer_pos = ds->buffer_size; | |
823 ds->pts = 0; | |
824 ds->pts_bytes = 0; | |
1 | 825 } |
826 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
827 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
|
828 { |
24826 | 829 int len; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
830 if (ds->buffer_pos >= ds->buffer_size) { |
27052 | 831 if (!ds_fill_buffer(ds)) { |
1 | 832 // EOF |
833 *start = NULL; | |
834 return -1; | |
27052 | 835 } |
1 | 836 } |
27055 | 837 len = ds->buffer_size - ds->buffer_pos; |
24826 | 838 *start = &ds->buffer[ds->buffer_pos]; |
27055 | 839 ds->buffer_pos += len; |
24826 | 840 return len; |
1 | 841 } |
554 | 842 |
27055 | 843 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
|
844 { |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
845 int len; |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
846 *pts = MP_NOPTS_VALUE; |
29504 | 847 len = ds_get_packet(ds, start); |
848 if (len < 0) | |
849 return len; | |
18917
d9a75b26da6c
Add a new video pts tracking mode, enabled by option -correct-pts.
uau
parents:
18900
diff
changeset
|
850 // Return pts unless this read starts from the middle of a packet |
29504 | 851 if (len == ds->buffer_pos) |
27052 | 852 *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
|
853 return len; |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
854 } |
caac2ca98168
4 - Implement a better way to calculate current audio pts and use it for
rtognimp
parents:
18237
diff
changeset
|
855 |
31558 | 856 /** |
857 * Get a subtitle packet. In particular avoid reading the stream. | |
858 * \param pts input: maximum pts value of subtitle packet. NOPTS or NULL for any. | |
33487 | 859 * output: start/reference pts of subtitle |
31558 | 860 * May be NULL. |
861 * \param endpts output: pts for end of display time. May be NULL. | |
862 * \return -1 if no packet is available | |
863 */ | |
864 int ds_get_packet_sub(demux_stream_t *ds, unsigned char **start, | |
865 double *pts, double *endpts) | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
866 { |
32337
c1a2c51bed1c
Fix ds_get_packet_sub to actually respect the pts-based read-ahead limit.
reimar
parents:
32209
diff
changeset
|
867 double max_pts = MP_NOPTS_VALUE; |
24826 | 868 int len; |
31558 | 869 *start = NULL; |
870 // initialize pts | |
32337
c1a2c51bed1c
Fix ds_get_packet_sub to actually respect the pts-based read-ahead limit.
reimar
parents:
32209
diff
changeset
|
871 if (pts) { |
c1a2c51bed1c
Fix ds_get_packet_sub to actually respect the pts-based read-ahead limit.
reimar
parents:
32209
diff
changeset
|
872 max_pts = *pts; |
31558 | 873 *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
|
874 } |
31558 | 875 if (endpts) |
876 *endpts = MP_NOPTS_VALUE; | |
27055 | 877 if (ds->buffer_pos >= ds->buffer_size) { |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
878 if (!ds->packs) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
879 return -1; // no sub |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
880 if (!ds_fill_buffer(ds)) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
881 return -1; // EOF |
554 | 882 } |
31558 | 883 // only start of buffer has valid pts |
884 if (ds->buffer_pos == 0) { | |
885 if (endpts) | |
886 *endpts = ds->current->endpts; | |
887 if (pts) { | |
888 *pts = ds->current->pts; | |
889 // 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
|
890 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
|
891 *pts > max_pts) |
31558 | 892 return -1; |
893 } | |
894 } | |
27055 | 895 len = ds->buffer_size - ds->buffer_pos; |
24826 | 896 *start = &ds->buffer[ds->buffer_pos]; |
27055 | 897 ds->buffer_pos += len; |
24826 | 898 return len; |
554 | 899 } |
900 | |
18309
87161f96fa66
Change common pts variables from floats to doubles. Individual demuxers
uau
parents:
18242
diff
changeset
|
901 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
|
902 { |
27055 | 903 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
|
904 // 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
|
905 // 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
|
906 while (!ds->first && (!ds->current || ds->buffer_pos)) { |
27056 | 907 if (demux->audio->packs >= MAX_PACKS |
908 || demux->audio->bytes >= MAX_PACK_BYTES) { | |
909 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyAudioInBuffer, | |
910 demux->audio->packs, demux->audio->bytes); | |
27055 | 911 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
912 return MP_NOPTS_VALUE; | |
913 } | |
27056 | 914 if (demux->video->packs >= MAX_PACKS |
915 || demux->video->bytes >= MAX_PACK_BYTES) { | |
916 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_TooManyVideoInBuffer, | |
917 demux->video->packs, demux->video->bytes); | |
27055 | 918 mp_msg(MSGT_DEMUXER, MSGL_HINT, MSGTR_MaybeNI); |
919 return MP_NOPTS_VALUE; | |
920 } | |
921 if (!demux_fill_buffer(demux, ds)) | |
922 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
|
923 } |
31272
e340fa125680
Fix ds_get_next_pts to also work for the first packet of a stream.
reimar
parents:
31250
diff
changeset
|
924 // 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
|
925 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
|
926 return ds->current->pts; |
27055 | 927 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
|
928 } |
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5897
diff
changeset
|
929 |
1375
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
930 // ==================================================================== |
dbcb5b5e1fae
file-format detection stuff moved out from mplayer.c to demuxer.c and dec_video.c
arpi
parents:
1331
diff
changeset
|
931 |
16175 | 932 void demuxer_help(void) |
933 { | |
27055 | 934 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
|
935 |
27055 | 936 mp_msg(MSGT_DEMUXER, MSGL_INFO, "Available demuxers:\n"); |
937 mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer: type info: (comment)\n"); | |
938 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DEMUXERS\n"); | |
939 for (i = 0; demuxer_list[i]; i++) { | |
940 if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Don't display special demuxers | |
941 continue; | |
942 if (demuxer_list[i]->comment && strlen(demuxer_list[i]->comment)) | |
943 mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s %2d %s (%s)\n", | |
27056 | 944 demuxer_list[i]->name, demuxer_list[i]->type, |
945 demuxer_list[i]->info, demuxer_list[i]->comment); | |
27055 | 946 else |
947 mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s %2d %s\n", | |
27056 | 948 demuxer_list[i]->name, demuxer_list[i]->type, |
949 demuxer_list[i]->info); | |
27055 | 950 } |
16175 | 951 } |
952 | |
14693
37116118ab6a
avisynth demuxer patch by Gianluigi Tiesi <mplayer at netfarm.it>
faust3
parents:
14666
diff
changeset
|
953 |
16175 | 954 /** |
955 * Get demuxer type for a given demuxer name | |
956 * | |
957 * @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
|
958 * @param force will be set if demuxer should be forced. |
efbfac98cab1
Allow forcing of demuxers and codecs by prepending '+'
reimar
parents:
16310
diff
changeset
|
959 * May be NULL. |
16175 | 960 * @return DEMUXER_TYPE_xxx, -1 if error or not found |
961 */ | |
16321
efbfac98cab1
Allow forcing of demuxers and codecs by prepending '+'
reimar
parents:
16310
diff
changeset
|
962 int get_demuxer_type_from_name(char *demuxer_name, int *force) |
16175 | 963 { |
27055 | 964 int i; |
965 long type_int; | |
966 char *endptr; | |
5133
9841a86d66f9
Initial ogg demuxer. No seeking, a/v sync is broken. Support avi
albeu
parents:
5107
diff
changeset
|
967 |
27055 | 968 if (!demuxer_name || !demuxer_name[0]) |
969 return DEMUXER_TYPE_UNKNOWN; | |
970 if (force) | |
971 *force = demuxer_name[0] == '+'; | |
972 if (demuxer_name[0] == '+') | |
973 demuxer_name = &demuxer_name[1]; | |
974 for (i = 0; demuxer_list[i]; i++) { | |
975 if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Can't select special demuxers from commandline | |
976 continue; | |
977 if (strcmp(demuxer_name, demuxer_list[i]->name) == 0) | |
978 return demuxer_list[i]->type; | |
979 } | |
16175 | 980 |
27055 | 981 // No match found, try to parse name as an integer (demuxer number) |
982 type_int = strtol(demuxer_name, &endptr, 0); | |
983 if (*endptr) // Conversion failed | |
984 return -1; | |
985 if ((type_int > 0) && (type_int <= DEMUXER_TYPE_MAX)) | |
986 return (int) type_int; | |
987 | |
26437 | 988 return -1; |
16175 | 989 } |
3801
3cea69dda1b3
added NuppelVideo demuxer, based on Panagiotis Issaris' patch
alex
parents:
3786
diff
changeset
|
990 |
27055 | 991 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
|
992 |
27055 | 993 int correct_pts = 0; |
994 int user_correct_pts = -1; | |
18917
d9a75b26da6c
Add a new video pts tracking mode, enabled by option -correct-pts.
uau
parents:
18900
diff
changeset
|
995 |
9751
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
996 /* |
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
997 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
|
998 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
|
999 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
|
1000 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
|
1001 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
|
1002 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
|
1003 to the right type (ex: rawaudio,rawvideo). |
25197
eb2c5925ec34
Fix typos in comments to stop them hurting my eyes
reimar
parents:
24826
diff
changeset
|
1004 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
|
1005 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
|
1006 (ex: tv,mf). |
00c97b0891e3
Fix all demuxers wich where using a global var to enable themself.
albeu
parents:
9709
diff
changeset
|
1007 */ |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1008 |
27054 | 1009 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
|
1010 int force, int audio_id, int video_id, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1011 int dvdsub_id, char *filename) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1012 { |
27055 | 1013 demuxer_t *demuxer = NULL; |
1659 | 1014 |
27055 | 1015 sh_video_t *sh_video = NULL; |
26437 | 1016 |
27055 | 1017 const demuxer_desc_t *demuxer_desc; |
1018 int fformat = 0; | |
1019 int i; | |
26437 | 1020 |
27055 | 1021 // If somebody requested a demuxer check it |
1022 if (file_format) { | |
1023 if ((demuxer_desc = get_demuxer_desc_from_type(file_format))) { | |
27056 | 1024 demuxer = new_demuxer(stream, demuxer_desc->type, audio_id, |
1025 video_id, dvdsub_id, filename); | |
27055 | 1026 if (demuxer_desc->check_file) |
1027 fformat = demuxer_desc->check_file(demuxer); | |
1028 if (force || !demuxer_desc->check_file) | |
1029 fformat = demuxer_desc->type; | |
1030 if (fformat != 0) { | |
1031 if (fformat == demuxer_desc->type) { | |
1032 demuxer_t *demux2 = demuxer; | |
1033 // Move messages to demuxer detection code? | |
27056 | 1034 mp_msg(MSGT_DEMUXER, MSGL_INFO, |
1035 MSGTR_Detected_XXX_FileFormat, | |
1036 demuxer_desc->shortdesc); | |
27055 | 1037 file_format = fformat; |
27056 | 1038 if (!demuxer->desc->open |
1039 || (demux2 = demuxer->desc->open(demuxer))) { | |
27055 | 1040 demuxer = demux2; |
1041 goto dmx_open; | |
1042 } | |
1043 } else { | |
1044 // Format changed after check, recurse | |
1045 free_demuxer(demuxer); | |
27056 | 1046 return demux_open_stream(stream, fformat, force, audio_id, |
1047 video_id, dvdsub_id, filename); | |
27055 | 1048 } |
1049 } | |
1050 // Check failed for forced demuxer, quit | |
1051 free_demuxer(demuxer); | |
1052 return NULL; | |
20303 | 1053 } |
1054 } | |
27055 | 1055 // Test demuxers with safe file checks |
1056 for (i = 0; (demuxer_desc = demuxer_list[i]); i++) { | |
1057 if (demuxer_desc->safe_check) { | |
27056 | 1058 demuxer = new_demuxer(stream, demuxer_desc->type, audio_id, |
1059 video_id, dvdsub_id, filename); | |
27055 | 1060 if ((fformat = demuxer_desc->check_file(demuxer)) != 0) { |
1061 if (fformat == demuxer_desc->type) { | |
1062 demuxer_t *demux2 = demuxer; | |
27056 | 1063 mp_msg(MSGT_DEMUXER, MSGL_INFO, |
1064 MSGTR_Detected_XXX_FileFormat, | |
1065 demuxer_desc->shortdesc); | |
27055 | 1066 file_format = fformat; |
27056 | 1067 if (!demuxer->desc->open |
1068 || (demux2 = demuxer->desc->open(demuxer))) { | |
27055 | 1069 demuxer = demux2; |
1070 goto dmx_open; | |
1071 } | |
1072 } else { | |
1073 if (fformat == DEMUXER_TYPE_PLAYLIST) | |
1074 return demuxer; // handled in mplayer.c | |
1075 // Format changed after check, recurse | |
1076 free_demuxer(demuxer); | |
1077 demuxer = demux_open_stream(stream, fformat, force, | |
27056 | 1078 audio_id, video_id, |
1079 dvdsub_id, filename); | |
27055 | 1080 if (demuxer) |
1081 return demuxer; // done! | |
1082 file_format = DEMUXER_TYPE_UNKNOWN; | |
1083 } | |
1084 } | |
1085 free_demuxer(demuxer); | |
1086 demuxer = NULL; | |
26379 | 1087 } |
1088 } | |
9006
d00997f12257
extension-based filetype detection for headerless files (mp3 vs mpeg, etc)
arpi
parents:
8937
diff
changeset
|
1089 |
27055 | 1090 // If no forced demuxer perform file extension based detection |
27056 | 1091 // Ok. We're over the stable detectable fileformats, the next ones are |
1092 // a bit fuzzy. So by default (extension_parsing==1) try extension-based | |
1093 // detection first: | |
1094 if (file_format == DEMUXER_TYPE_UNKNOWN && filename | |
1095 && extension_parsing == 1) { | |
27055 | 1096 file_format = demuxer_type_by_filename(filename); |
1097 if (file_format != DEMUXER_TYPE_UNKNOWN) { | |
1098 // we like recursion :) | |
27056 | 1099 demuxer = demux_open_stream(stream, file_format, force, audio_id, |
1100 video_id, dvdsub_id, filename); | |
27055 | 1101 if (demuxer) |
1102 return demuxer; // done! | |
1103 file_format = DEMUXER_TYPE_UNKNOWN; // continue fuzzy guessing... | |
27056 | 1104 mp_msg(MSGT_DEMUXER, MSGL_V, |
1105 "demuxer: continue fuzzy content-based format guessing...\n"); | |
26437 | 1106 } |
1107 } | |
27055 | 1108 // Try detection for all other demuxers |
1109 for (i = 0; (demuxer_desc = demuxer_list[i]); i++) { | |
1110 if (!demuxer_desc->safe_check && demuxer_desc->check_file) { | |
27056 | 1111 demuxer = new_demuxer(stream, demuxer_desc->type, audio_id, |
1112 video_id, dvdsub_id, filename); | |
27055 | 1113 if ((fformat = demuxer_desc->check_file(demuxer)) != 0) { |
1114 if (fformat == demuxer_desc->type) { | |
1115 demuxer_t *demux2 = demuxer; | |
27056 | 1116 mp_msg(MSGT_DEMUXER, MSGL_INFO, |
1117 MSGTR_Detected_XXX_FileFormat, | |
1118 demuxer_desc->shortdesc); | |
27055 | 1119 file_format = fformat; |
27056 | 1120 if (!demuxer->desc->open |
1121 || (demux2 = demuxer->desc->open(demuxer))) { | |
27055 | 1122 demuxer = demux2; |
1123 goto dmx_open; | |
1124 } | |
1125 } else { | |
1126 if (fformat == DEMUXER_TYPE_PLAYLIST) | |
1127 return demuxer; // handled in mplayer.c | |
1128 // Format changed after check, recurse | |
1129 free_demuxer(demuxer); | |
1130 demuxer = demux_open_stream(stream, fformat, force, | |
27056 | 1131 audio_id, video_id, |
1132 dvdsub_id, filename); | |
27055 | 1133 if (demuxer) |
1134 return demuxer; // done! | |
1135 file_format = DEMUXER_TYPE_UNKNOWN; | |
1136 } | |
1137 } | |
1138 free_demuxer(demuxer); | |
1139 demuxer = NULL; | |
1140 } | |
1141 } | |
26437 | 1142 |
27055 | 1143 return NULL; |
1144 //====== File format recognized, set up these for compatibility: ========= | |
1145 dmx_open: | |
1146 | |
1147 demuxer->file_format = file_format; | |
1148 | |
1149 if ((sh_video = demuxer->video->sh) && sh_video->bih) { | |
1150 int biComp = le2me_32(sh_video->bih->biCompression); | |
27056 | 1151 mp_msg(MSGT_DEMUX, MSGL_INFO, |
1152 "VIDEO: [%.4s] %dx%d %dbpp %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n", | |
1153 (char *) &biComp, sh_video->bih->biWidth, | |
1154 sh_video->bih->biHeight, sh_video->bih->biBitCount, | |
1155 sh_video->fps, sh_video->i_bps * 0.008f, | |
27055 | 1156 sh_video->i_bps / 1024.0f); |
1157 } | |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
1158 #ifdef CONFIG_ASS |
27055 | 1159 if (ass_enabled && ass_library) { |
1160 for (i = 0; i < MAX_S_STREAMS; ++i) { | |
1161 sh_sub_t *sh = demuxer->s_streams[i]; | |
1162 if (sh && sh->type == 'a') { | |
1163 sh->ass_track = ass_new_track(ass_library); | |
1164 if (sh->ass_track && sh->extradata) | |
27056 | 1165 ass_process_codec_private(sh->ass_track, sh->extradata, |
1166 sh->extradata_len); | |
27055 | 1167 } else if (sh && sh->type != 'v') |
1168 sh->ass_track = ass_default_track(ass_library); | |
1169 } | |
1170 } | |
26437 | 1171 #endif |
27055 | 1172 return demuxer; |
26437 | 1173 } |
1174 | |
27054 | 1175 char *audio_stream = NULL; |
27056 | 1176 char *sub_stream = NULL; |
9709 | 1177 int audio_stream_cache = 0; |
7867 | 1178 |
27056 | 1179 char *demuxer_name = NULL; // parameter from -demuxer |
16175 | 1180 char *audio_demuxer_name = NULL; // parameter from -audio-demuxer |
27056 | 1181 char *sub_demuxer_name = NULL; // parameter from -sub-demuxer |
16175 | 1182 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1183 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
|
1184 int video_id, int dvdsub_id, char *filename) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1185 { |
27055 | 1186 stream_t *as = NULL, *ss = NULL; |
1187 demuxer_t *vd, *ad = NULL, *sd = NULL; | |
1188 demuxer_t *res; | |
1189 int afmt = DEMUXER_TYPE_UNKNOWN, sfmt = DEMUXER_TYPE_UNKNOWN; | |
1190 int demuxer_type; | |
1191 int audio_demuxer_type = 0, sub_demuxer_type = 0; | |
1192 int demuxer_force = 0, audio_demuxer_force = 0, sub_demuxer_force = 0; | |
16175 | 1193 |
27056 | 1194 if ((demuxer_type = |
1195 get_demuxer_type_from_name(demuxer_name, &demuxer_force)) < 0) { | |
1196 mp_msg(MSGT_DEMUXER, MSGL_ERR, "-demuxer %s does not exist.\n", | |
1197 demuxer_name); | |
27055 | 1198 } |
27056 | 1199 if ((audio_demuxer_type = |
1200 get_demuxer_type_from_name(audio_demuxer_name, | |
1201 &audio_demuxer_force)) < 0) { | |
1202 mp_msg(MSGT_DEMUXER, MSGL_ERR, "-audio-demuxer %s does not exist.\n", | |
1203 audio_demuxer_name); | |
27055 | 1204 } |
27056 | 1205 if ((sub_demuxer_type = |
1206 get_demuxer_type_from_name(sub_demuxer_name, | |
1207 &sub_demuxer_force)) < 0) { | |
1208 mp_msg(MSGT_DEMUXER, MSGL_ERR, "-sub-demuxer %s does not exist.\n", | |
1209 sub_demuxer_name); | |
27055 | 1210 } |
26437 | 1211 |
27055 | 1212 if (audio_stream) { |
1213 as = open_stream(audio_stream, 0, &afmt); | |
1214 if (!as) { | |
27056 | 1215 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_CannotOpenAudioStream, |
1216 audio_stream); | |
27055 | 1217 return NULL; |
1218 } | |
1219 if (audio_stream_cache) { | |
27056 | 1220 if (!stream_enable_cache |
1221 (as, audio_stream_cache * 1024, | |
1222 audio_stream_cache * 1024 * (stream_cache_min_percent / | |
1223 100.0), | |
1224 audio_stream_cache * 1024 * (stream_cache_seek_min_percent / | |
1225 100.0))) { | |
27055 | 1226 free_stream(as); |
27056 | 1227 mp_msg(MSGT_DEMUXER, MSGL_ERR, |
1228 "Can't enable audio stream cache\n"); | |
27055 | 1229 return NULL; |
1230 } | |
1231 } | |
26379 | 1232 } |
27055 | 1233 if (sub_stream) { |
1234 ss = open_stream(sub_stream, 0, &sfmt); | |
1235 if (!ss) { | |
27056 | 1236 mp_msg(MSGT_DEMUXER, MSGL_ERR, MSGTR_CannotOpenSubtitlesStream, |
1237 sub_stream); | |
27055 | 1238 return NULL; |
1239 } | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1240 } |
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1241 |
27055 | 1242 vd = demux_open_stream(vs, demuxer_type ? demuxer_type : file_format, |
27056 | 1243 demuxer_force, audio_stream ? -2 : audio_id, |
1244 video_id, sub_stream ? -2 : dvdsub_id, filename); | |
27055 | 1245 if (!vd) { |
1246 if (as) | |
1247 free_stream(as); | |
1248 if (ss) | |
1249 free_stream(ss); | |
1250 return NULL; | |
1251 } | |
1252 if (as) { | |
27056 | 1253 ad = demux_open_stream(as, |
1254 audio_demuxer_type ? audio_demuxer_type : afmt, | |
1255 audio_demuxer_force, audio_id, -2, -2, | |
1256 audio_stream); | |
27055 | 1257 if (!ad) { |
27056 | 1258 mp_msg(MSGT_DEMUXER, MSGL_WARN, MSGTR_OpeningAudioDemuxerFailed, |
1259 audio_stream); | |
27055 | 1260 free_stream(as); |
27056 | 1261 } else if (ad->audio->sh |
1262 && ((sh_audio_t *) ad->audio->sh)->format == 0x55) // MP3 | |
27055 | 1263 hr_mp3_seek = 1; // Enable high res seeking |
9709 | 1264 } |
27055 | 1265 if (ss) { |
1266 sd = demux_open_stream(ss, sub_demuxer_type ? sub_demuxer_type : sfmt, | |
27056 | 1267 sub_demuxer_force, -2, -2, dvdsub_id, |
1268 sub_stream); | |
27055 | 1269 if (!sd) { |
27056 | 1270 mp_msg(MSGT_DEMUXER, MSGL_WARN, |
1271 MSGTR_OpeningSubtitlesDemuxerFailed, sub_stream); | |
27055 | 1272 free_stream(ss); |
1273 } | |
1274 } | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1275 |
27055 | 1276 if (ad && sd) |
1277 res = new_demuxers_demuxer(vd, ad, sd); | |
1278 else if (ad) | |
1279 res = new_demuxers_demuxer(vd, ad, vd); | |
1280 else if (sd) | |
1281 res = new_demuxers_demuxer(vd, vd, sd); | |
1282 else | |
1283 res = vd; | |
25919
382672c7480a
Allow demuxers to choose a default value for correct_pts
reimar
parents:
25883
diff
changeset
|
1284 |
27055 | 1285 correct_pts = user_correct_pts; |
1286 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
|
1287 correct_pts = !force_fps && demux_control(res, DEMUXER_CTRL_CORRECT_PTS, NULL) |
27056 | 1288 == DEMUXER_CTRL_OK; |
27055 | 1289 return res; |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1290 } |
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1291 |
30396
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1292 /** |
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1293 * 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
|
1294 * 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
|
1295 * seeking with ASF demuxer. |
5fe2615e5db7
Remove ds_fill_buffer calls from demux_resync, they cause issues at least with
reimar
parents:
30385
diff
changeset
|
1296 */ |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1297 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
|
1298 { |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1299 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
|
1300 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
|
1301 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
|
1302 if (sh_video) { |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1303 resync_video_stream(sh_video); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1304 } |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1305 if (sh_audio) { |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1306 resync_audio_stream(sh_audio); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1307 } |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1308 } |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1309 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1310 void demux_flush(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1311 { |
30379
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1312 #if PARSE_ON_ADD |
0140d505dd91
Reset the parser on seek. Should fix some cases of audio "blips" after seeking.
reimar
parents:
30378
diff
changeset
|
1313 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
|
1314 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
|
1315 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
|
1316 #endif |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1317 ds_free_packs(demuxer->video); |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1318 ds_free_packs(demuxer->audio); |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1319 ds_free_packs(demuxer->sub); |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1320 } |
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1321 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1322 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
|
1323 int flags) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1324 { |
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
|
1325 double tmp = 0; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1326 double pts; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1327 |
27055 | 1328 if (!demuxer->seekable) { |
1329 if (demuxer->file_format == DEMUXER_TYPE_AVI) | |
1330 mp_msg(MSGT_SEEK, MSGL_WARN, MSGTR_CantSeekRawAVI); | |
27341
e7c989f7a7c9
Start unifying names of internal preprocessor directives.
diego
parents:
27282
diff
changeset
|
1331 #ifdef CONFIG_TV |
27055 | 1332 else if (demuxer->file_format == DEMUXER_TYPE_TV) |
1333 mp_msg(MSGT_SEEK, MSGL_WARN, MSGTR_TVInputNotSeekable); | |
2790 | 1334 #endif |
27055 | 1335 else |
1336 mp_msg(MSGT_SEEK, MSGL_WARN, MSGTR_CantSeekFile); | |
1337 return 0; | |
1338 } | |
26437 | 1339 |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1340 demux_flush(demuxer); |
27055 | 1341 |
27045 | 1342 demuxer->stream->eof = 0; |
27055 | 1343 demuxer->video->eof = 0; |
1344 demuxer->audio->eof = 0; | |
31949 | 1345 demuxer->sub->eof = 0; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1346 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1347 if (flags & SEEK_ABSOLUTE) |
27055 | 1348 pts = 0.0f; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1349 else { |
27055 | 1350 if (demuxer->stream_pts == MP_NOPTS_VALUE) |
1351 goto dmx_seek; | |
1352 pts = demuxer->stream_pts; | |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1353 } |
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1354 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1355 if (flags & SEEK_FACTOR) { |
27056 | 1356 if (stream_control(demuxer->stream, STREAM_CTRL_GET_TIME_LENGTH, &tmp) |
1357 == STREAM_UNSUPPORTED) | |
27055 | 1358 goto dmx_seek; |
1359 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
|
1360 } else |
27055 | 1361 pts += rel_seek_secs; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1362 |
27056 | 1363 if (stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_TIME, &pts) != |
1364 STREAM_UNSUPPORTED) { | |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1365 demux_resync(demuxer); |
27055 | 1366 return 1; |
20748
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1367 } |
865b71a83296
now demux_seek() tries to seek aided by the stream layer, if possible
nicodvb
parents:
20319
diff
changeset
|
1368 |
27055 | 1369 dmx_seek: |
1370 if (demuxer->desc->seek) | |
1371 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
|
1372 |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1373 demux_resync(demuxer); |
16877
9081ae3a702c
move resync_audio_stream after seeking to demuxer.c
reimar
parents:
16572
diff
changeset
|
1374 |
27055 | 1375 return 1; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1376 } |
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1377 |
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
|
1378 int demux_info_add(demuxer_t *demuxer, const char *opt, const char *param) |
3050 | 1379 { |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1380 char **info = demuxer->info; |
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1381 int n = 0; |
1497
ad4d402b3d29
seek.c moved to demuxer.c, stream_reset in new_demuxer()
arpi
parents:
1496
diff
changeset
|
1382 |
3050 | 1383 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1384 for (n = 0; info && info[2 * n] != NULL; n++) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1385 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
|
1386 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
|
1387 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
|
1388 return 0; |
342a78c13eeb
Reduce verbosity if demuxer sets an info value to the same as the current value.
reimar
parents:
29504
diff
changeset
|
1389 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1390 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_DemuxerInfoChanged, opt, |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1391 param); |
27055 | 1392 free(info[2 * n + 1]); |
1393 info[2 * n + 1] = strdup(param); | |
27052 | 1394 return 0; |
27055 | 1395 } |
1396 } | |
27051 | 1397 |
30702 | 1398 info = demuxer->info = realloc(info, (2 * (n + 2)) * sizeof(char *)); |
27055 | 1399 info[2 * n] = strdup(opt); |
1400 info[2 * n + 1] = strdup(param); | |
1401 memset(&info[2 * (n + 1)], 0, 2 * sizeof(char *)); | |
3050 | 1402 |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1403 return 1; |
3050 | 1404 } |
1405 | |
1406 int demux_info_print(demuxer_t *demuxer) | |
1407 { | |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1408 char **info = demuxer->info; |
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1409 int n; |
3050 | 1410 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1411 if (!info) |
27055 | 1412 return 0; |
4694
a21735031d6a
Audio file demuxer. Extended version for demuxer info.
albeu
parents:
4660
diff
changeset
|
1413 |
27055 | 1414 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_ClipInfo); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1415 for (n = 0; info[2 * n] != NULL; n++) { |
27056 | 1416 mp_msg(MSGT_DEMUX, MSGL_INFO, " %s: %s\n", info[2 * n], |
1417 info[2 * n + 1]); | |
1418 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_NAME%d=%s\n", n, | |
1419 info[2 * n]); | |
1420 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_VALUE%d=%s\n", n, | |
1421 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
|
1422 } |
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
|
1423 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_N=%d\n", n); |
4189 | 1424 |
1425 return 0; | |
3050 | 1426 } |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1427 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1428 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
|
1429 { |
27055 | 1430 int i; |
1431 char **info = demuxer->info; | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1432 |
27055 | 1433 for (i = 0; info && info[2 * i] != NULL; i++) { |
1434 if (!strcasecmp(opt, info[2 * i])) | |
1435 return info[2 * i + 1]; | |
1436 } | |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1437 |
27055 | 1438 return NULL; |
4765
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1439 } |
d0c2c8af46b4
Demuxers demuxer support for using external audiofile (or muxed subtitles).
albeu
parents:
4735
diff
changeset
|
1440 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1441 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
|
1442 { |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1443 |
16175 | 1444 if (demuxer->desc->control) |
27055 | 1445 return demuxer->desc->control(demuxer, cmd, arg); |
16175 | 1446 |
1447 return DEMUXER_CTRL_NOTIMPL; | |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1448 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1449 |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1450 |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1451 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1452 double demuxer_get_time_length(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1453 { |
16346
6ff303d2876b
Make -identify's 'ID_LENGTH=' print a float and not an integer.. The
ods15
parents:
16326
diff
changeset
|
1454 double get_time_ans; |
14502
8769fa370f83
Move generic length and percent pos calculation to demuxer.c
reimar
parents:
14276
diff
changeset
|
1455 sh_video_t *sh_video = demuxer->video->sh; |
16925 | 1456 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
|
1457 // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW |
27056 | 1458 if (demux_control |
1459 (demuxer, DEMUXER_CTRL_GET_TIME_LENGTH, (void *) &get_time_ans) <= 0) { | |
27055 | 1460 if (sh_video && sh_video->i_bps && sh_audio && sh_audio->i_bps) |
27056 | 1461 get_time_ans = (double) (demuxer->movi_end - |
1462 demuxer->movi_start) / (sh_video->i_bps + | |
1463 sh_audio->i_bps); | |
27055 | 1464 else if (sh_video && sh_video->i_bps) |
27056 | 1465 get_time_ans = (double) (demuxer->movi_end - |
1466 demuxer->movi_start) / sh_video->i_bps; | |
27055 | 1467 else if (sh_audio && sh_audio->i_bps) |
27056 | 1468 get_time_ans = (double) (demuxer->movi_end - |
1469 demuxer->movi_start) / sh_audio->i_bps; | |
27055 | 1470 else |
1471 get_time_ans = 0; | |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1472 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1473 return get_time_ans; |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1474 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1475 |
20749
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1476 /** |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1477 * \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
|
1478 * 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
|
1479 * 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
|
1480 * 0 otherwise |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1481 * \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
|
1482 */ |
34312
d2a41814c879
Fix OSD time and e.g. frame number displayed with osd_fractions
reimar
parents:
34146
diff
changeset
|
1483 double demuxer_get_current_time(demuxer_t *demuxer) |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1484 { |
20749
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1485 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
|
1486 sh_video_t *sh_video = demuxer->video->sh; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1487 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
|
1488 get_time_ans = demuxer->stream_pts; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1489 else if (sh_video) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1490 get_time_ans = sh_video->pts; |
34312
d2a41814c879
Fix OSD time and e.g. frame number displayed with osd_fractions
reimar
parents:
34146
diff
changeset
|
1491 return get_time_ans; |
20749
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1492 } |
eafd9953b505
added demuxer_get_current_time() to get the current playtime (possibly aided by the stream layer)
nicodvb
parents:
20748
diff
changeset
|
1493 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1494 int demuxer_get_percent_pos(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1495 { |
14197
2ae224195625
Use demuxer_get_percent_pos for the OSD position bar
reimar
parents:
14160
diff
changeset
|
1496 int ans = 0; |
2ae224195625
Use demuxer_get_percent_pos for the OSD position bar
reimar
parents:
14160
diff
changeset
|
1497 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
|
1498 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
|
1499 if (res <= 0) { |
29486
a373af1e3b24
Handle demuxers that never set filepos by using stream_tell.
reimar
parents:
29366
diff
changeset
|
1500 off_t pos = demuxer->filepos > 0 ? demuxer->filepos : stream_tell(demuxer->stream); |
27055 | 1501 if (len > 0) |
29486
a373af1e3b24
Handle demuxers that never set filepos by using stream_tell.
reimar
parents:
29366
diff
changeset
|
1502 ans = (pos - demuxer->movi_start) / len; |
27055 | 1503 else |
1504 ans = 0; | |
14502
8769fa370f83
Move generic length and percent pos calculation to demuxer.c
reimar
parents:
14276
diff
changeset
|
1505 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1506 if (ans < 0) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1507 ans = 0; |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1508 if (ans > 100) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1509 ans = 100; |
8208
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1510 return ans; |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1511 } |
ae5a2ae1c349
demuxer_control(), percent position and time length query implemented in
arpi
parents:
8123
diff
changeset
|
1512 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1513 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
|
1514 { |
15285
39eb8a327ea9
adds a parameter to the switch_audio command to directly select a track.
reimar
parents:
15046
diff
changeset
|
1515 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
|
1516 if (res == DEMUXER_CTRL_NOTIMPL) |
27055 | 1517 index = demuxer->audio->id; |
26089
e2f35d90ad39
Set audio->sh correctly when switching audio tracks. The same for video tracks.
eugeni
parents:
26088
diff
changeset
|
1518 if (demuxer->audio->id >= 0) |
27055 | 1519 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
|
1520 else |
27055 | 1521 demuxer->audio->sh = NULL; |
15285
39eb8a327ea9
adds a parameter to the switch_audio command to directly select a track.
reimar
parents:
15046
diff
changeset
|
1522 return index; |
15046
b7aa70b05d76
Added support of audio stream switching in the MPEG demuxer using the #-key
gpoirier
parents:
14934
diff
changeset
|
1523 } |
19342 | 1524 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1525 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
|
1526 { |
20948 | 1527 int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_VIDEO, &index); |
1528 if (res == DEMUXER_CTRL_NOTIMPL) | |
27055 | 1529 index = demuxer->video->id; |
26089
e2f35d90ad39
Set audio->sh correctly when switching audio tracks. The same for video tracks.
eugeni
parents:
26088
diff
changeset
|
1530 if (demuxer->video->id >= 0) |
27055 | 1531 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
|
1532 else |
27055 | 1533 demuxer->video->sh = NULL; |
20948 | 1534 return index; |
1535 } | |
1536 | |
27054 | 1537 int demuxer_add_attachment(demuxer_t *demuxer, const char *name, |
1538 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
|
1539 { |
25657 | 1540 if (!(demuxer->num_attachments & 31)) |
27056 | 1541 demuxer->attachments = realloc(demuxer->attachments, |
1542 (demuxer->num_attachments + 32) * sizeof(demux_attachment_t)); | |
25657 | 1543 |
33189 | 1544 demuxer->attachments[demuxer->num_attachments].name = name ? strdup(name) : NULL; |
25657 | 1545 demuxer->attachments[demuxer->num_attachments].type = strdup(type); |
1546 demuxer->attachments[demuxer->num_attachments].data = malloc(size); | |
1547 memcpy(demuxer->attachments[demuxer->num_attachments].data, data, size); | |
1548 demuxer->attachments[demuxer->num_attachments].data_size = size; | |
1549 | |
27055 | 1550 return demuxer->num_attachments++; |
25657 | 1551 } |
1552 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1553 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
|
1554 uint64_t end) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1555 { |
19342 | 1556 if (demuxer->chapters == NULL) |
27055 | 1557 demuxer->chapters = malloc(32 * sizeof(*demuxer->chapters)); |
19342 | 1558 else if (!(demuxer->num_chapters % 32)) |
27056 | 1559 demuxer->chapters = realloc(demuxer->chapters, |
1560 (demuxer->num_chapters + 32) * | |
1561 sizeof(*demuxer->chapters)); | |
19342 | 1562 |
1563 demuxer->chapters[demuxer->num_chapters].start = start; | |
1564 demuxer->chapters[demuxer->num_chapters].end = end; | |
27057
42332b47d6aa
Support NULL name parameter for demuxer_add_chapter.
reimar
parents:
27056
diff
changeset
|
1565 demuxer->chapters[demuxer->num_chapters].name = strdup(name ? name : MSGTR_Unknown); |
19342 | 1566 |
29366 | 1567 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_ID=%d\n", demuxer->num_chapters); |
1568 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_START=%"PRIu64"\n", demuxer->num_chapters, start); | |
1569 if (end) | |
1570 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_END=%"PRIu64"\n", demuxer->num_chapters, end); | |
1571 if (name) | |
1572 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_NAME=%s\n", demuxer->num_chapters, name); | |
1573 | |
27055 | 1574 return demuxer->num_chapters++; |
19342 | 1575 } |
1576 | |
19435 | 1577 /** |
27051 | 1578 * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways: |
19435 | 1579 * either using the demuxer->chapters structure set by the demuxer |
1580 * or asking help to the stream layer (e.g. dvd) | |
19439 | 1581 * \param chapter - chapter number wished - 0-based |
19435 | 1582 * \param mode 0: relative to current main pts, 1: absolute |
1583 * \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
|
1584 * \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
|
1585 * \param chapter_name name of chapter found (set by this function is param is not null) |
19435 | 1586 * \return -1 on error, current chapter if successful |
1587 */ | |
1588 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1589 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
|
1590 float *seek_pts, int *num_chapters, |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1591 char **chapter_name) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1592 { |
19435 | 1593 int ris; |
1594 int current, total; | |
1595 | |
1596 if (!demuxer->num_chapters || !demuxer->chapters) { | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1597 if (!mode) { |
27056 | 1598 ris = stream_control(demuxer->stream, |
1599 STREAM_CTRL_GET_CURRENT_CHAPTER, ¤t); | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1600 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1601 return -1; |
19438
263e95c47aec
support relative seeking in the stream-driven case
nicodvb
parents:
19435
diff
changeset
|
1602 chapter += current; |
263e95c47aec
support relative seeking in the stream-driven case
nicodvb
parents:
19435
diff
changeset
|
1603 } |
263e95c47aec
support relative seeking in the stream-driven case
nicodvb
parents:
19435
diff
changeset
|
1604 |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1605 demux_flush(demuxer); |
19435 | 1606 |
27056 | 1607 ris = stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_CHAPTER, |
1608 &chapter); | |
19435 | 1609 |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1610 demux_resync(demuxer); |
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1611 |
27056 | 1612 // exit status may be ok, but main() doesn't have to seek itself |
1613 // (because e.g. dvds depend on sectors, not on pts) | |
19435 | 1614 *seek_pts = -1.0; |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1615 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1616 if (num_chapters) { |
27056 | 1617 if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS, |
1618 num_chapters) == STREAM_UNSUPPORTED) | |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1619 *num_chapters = 0; |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1620 } |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1621 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1622 if (chapter_name) { |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1623 *chapter_name = NULL; |
25314
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1624 if (num_chapters && *num_chapters) { |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1625 char *tmp = malloc(16); |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1626 if (tmp) { |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1627 sprintf(tmp, " of %3d", *num_chapters); |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1628 *chapter_name = tmp; |
02e2e7a5599a
Fix memory leak that tmp allocated but maybe not used.
ulion
parents:
25266
diff
changeset
|
1629 } |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1630 } |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1631 } |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1632 |
26758
9fb1d2c3dbd4
cosmetics: Remove pointless parentheses from return statements.
diego
parents:
26437
diff
changeset
|
1633 return ris != STREAM_UNSUPPORTED ? chapter : -1; |
27055 | 1634 } 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
|
1635 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
|
1636 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
|
1637 |
19435 | 1638 total = demuxer->num_chapters; |
1639 | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1640 if (mode == 1) //absolute seeking |
19435 | 1641 current = chapter; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1642 else { //relative seeking |
19435 | 1643 uint64_t now; |
27056 | 1644 now = (sh_video ? sh_video->pts : (sh_audio ? sh_audio->pts : 0.)) |
1645 * 1000 + .5; | |
19435 | 1646 |
1647 for (current = total - 1; current >= 0; --current) { | |
27054 | 1648 demux_chapter_t *chapter = demuxer->chapters + current; |
19435 | 1649 if (chapter->start <= now) |
1650 break; | |
1651 } | |
1652 current += chapter; | |
1653 } | |
1654 | |
1655 if (current >= total) | |
27055 | 1656 return -1; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1657 if (current < 0) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1658 current = 0; |
19435 | 1659 |
1660 *seek_pts = demuxer->chapters[current].start / 1000.0; | |
1661 | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1662 if (num_chapters) |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1663 *num_chapters = demuxer->num_chapters; |
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1664 |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1665 if (chapter_name) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1666 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
|
1667 *chapter_name = strdup(demuxer->chapters[current].name); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1668 else |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1669 *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
|
1670 } |
19478
bab82c53e433
demuxer_seek_chapter() returns informations about chapters count and name
nicodvb
parents:
19439
diff
changeset
|
1671 |
19435 | 1672 return current; |
1673 } | |
1674 } | |
25358 | 1675 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1676 int demuxer_get_current_chapter(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1677 { |
25358 | 1678 int chapter = -1; |
1679 if (!demuxer->num_chapters || !demuxer->chapters) { | |
1680 if (stream_control(demuxer->stream, STREAM_CTRL_GET_CURRENT_CHAPTER, | |
1681 &chapter) == STREAM_UNSUPPORTED) | |
1682 chapter = -1; | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1683 } else { |
25358 | 1684 sh_video_t *sh_video = demuxer->video->sh; |
1685 sh_audio_t *sh_audio = demuxer->audio->sh; | |
1686 uint64_t now; | |
27056 | 1687 now = (sh_video ? sh_video->pts : (sh_audio ? sh_audio->pts : 0)) |
1688 * 1000 + 0.5; | |
25358 | 1689 for (chapter = demuxer->num_chapters - 1; chapter >= 0; --chapter) { |
1690 if (demuxer->chapters[chapter].start <= now) | |
1691 break; | |
1692 } | |
1693 } | |
1694 return chapter; | |
1695 } | |
1696 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1697 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
|
1698 { |
25358 | 1699 if (demuxer->num_chapters && demuxer->chapters) { |
27056 | 1700 if (chapter >= 0 && chapter < demuxer->num_chapters |
1701 && demuxer->chapters[chapter].name) | |
25358 | 1702 return strdup(demuxer->chapters[chapter].name); |
1703 } | |
1704 return NULL; | |
1705 } | |
1706 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1707 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
|
1708 { |
25358 | 1709 char *chapter_name = demuxer_chapter_name(demuxer, chapter); |
1710 if (chapter_name) { | |
1711 char *tmp = malloc(strlen(chapter_name) + 14); | |
1712 snprintf(tmp, 63, "(%d) %s", chapter + 1, chapter_name); | |
27051 | 1713 free(chapter_name); |
25358 | 1714 return tmp; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1715 } else { |
25358 | 1716 int chapter_num = demuxer_chapter_count(demuxer); |
1717 char tmp[30]; | |
1718 if (chapter_num <= 0) | |
1719 sprintf(tmp, "(%d)", chapter + 1); | |
1720 else | |
1721 sprintf(tmp, "(%d) of %d", chapter + 1, chapter_num); | |
1722 return strdup(tmp); | |
1723 } | |
1724 } | |
1725 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1726 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
|
1727 { |
25358 | 1728 if (demuxer->num_chapters && demuxer->chapters && chapter >= 0 |
27055 | 1729 && chapter < demuxer->num_chapters) { |
25358 | 1730 if (end) |
1731 *end = demuxer->chapters[chapter].end / 1000.0; | |
1732 return demuxer->chapters[chapter].start / 1000.0; | |
1733 } | |
1734 return -1.0; | |
1735 } | |
1736 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1737 int demuxer_chapter_count(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1738 { |
25358 | 1739 if (!demuxer->num_chapters || !demuxer->chapters) { |
1740 int num_chapters = 0; | |
1741 if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS, | |
1742 &num_chapters) == STREAM_UNSUPPORTED) | |
1743 num_chapters = 0; | |
1744 return num_chapters; | |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1745 } else |
25358 | 1746 return demuxer->num_chapters; |
1747 } | |
1748 | |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1749 int demuxer_angles_count(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1750 { |
27055 | 1751 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
|
1752 |
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
|
1753 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
|
1754 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1755 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
|
1756 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
|
1757 } |
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 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1759 int demuxer_get_current_angle(demuxer_t *demuxer) |
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1760 { |
27055 | 1761 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
|
1762 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
|
1763 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1764 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
|
1765 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
|
1766 } |
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
|
1767 |
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
|
1768 |
27047
6ff2454fe5ec
cosmetics: Make all function declarations consistent by moving the opening
diego
parents:
27046
diff
changeset
|
1769 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
|
1770 { |
27055 | 1771 int ris, angles = -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1772 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1773 angles = demuxer_angles_count(demuxer); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1774 if ((angles < 1) || (angle > angles)) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1775 return -1; |
25575
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1776 |
26926
1e6241274552
added and reused demux_flush() instead of emptying the demux_stream buffers;
nicodvb
parents:
26876
diff
changeset
|
1777 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
|
1778 |
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 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
|
1780 if (ris == STREAM_UNSUPPORTED) |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1781 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
|
1782 |
30378
8339bca8e4b4
Move the resync-related code into more consistent places instead of having it
reimar
parents:
30088
diff
changeset
|
1783 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
|
1784 |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1785 return angle; |
f94eee219ee0
wrapper functions to get/set angle: the wrapping is needed to RESYNC the demuxer; patch by oattila chello hu
nicodvb
parents:
25444
diff
changeset
|
1786 } |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1787 |
27054 | 1788 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
|
1789 { |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1790 int i, len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1791 lang += strspn(lang, ","); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1792 while ((len = strcspn(lang, ",")) > 0) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1793 for (i = 0; i < MAX_A_STREAMS; ++i) { |
27054 | 1794 sh_audio_t *sh = d->a_streams[i]; |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1795 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
|
1796 return sh->aid; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1797 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1798 lang += len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1799 lang += strspn(lang, ","); |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1800 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1801 return -1; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1802 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1803 |
27054 | 1804 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
|
1805 { |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1806 int i, len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1807 lang += strspn(lang, ","); |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1808 while ((len = strcspn(lang, ",")) > 0) { |
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1809 for (i = 0; i < MAX_S_STREAMS; ++i) { |
27054 | 1810 sh_sub_t *sh = d->s_streams[i]; |
26086
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1811 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
|
1812 return sh->sid; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1813 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1814 lang += len; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1815 lang += strspn(lang, ","); |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1816 } |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1817 return -1; |
c9a877daca42
Demuxer-independent functions for selecting tracks based on language.
eugeni
parents:
26085
diff
changeset
|
1818 } |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1819 |
27054 | 1820 int demuxer_default_audio_track(demuxer_t *d) |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1821 { |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1822 int i; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1823 for (i = 0; i < MAX_A_STREAMS; ++i) { |
27054 | 1824 sh_audio_t *sh = d->a_streams[i]; |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1825 if (sh && sh->default_track) |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1826 return sh->aid; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1827 } |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1828 for (i = 0; i < MAX_A_STREAMS; ++i) { |
27054 | 1829 sh_audio_t *sh = d->a_streams[i]; |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1830 if (sh) |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1831 return sh->aid; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1832 } |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1833 return -1; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1834 } |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1835 |
27054 | 1836 int demuxer_default_sub_track(demuxer_t *d) |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1837 { |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1838 int i; |
27049
762a9c6bfb43
cosmetics: Consistently format all if, for, while constructs.
diego
parents:
27048
diff
changeset
|
1839 for (i = 0; i < MAX_S_STREAMS; ++i) { |
27054 | 1840 sh_sub_t *sh = d->s_streams[i]; |
26269
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1841 if (sh && sh->default_track) |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1842 return sh->sid; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1843 } |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1844 return -1; |
65ad20416dd7
Support 'default' attribute for audio and subtitle tracks.
eugeni
parents:
26089
diff
changeset
|
1845 } |