Mercurial > mplayer.hg
annotate libmpdemux/demux_lavf.c @ 23803:ec1a81c77628
fixed bug introduced with the addition of get_ext_stream_properties()
that should close bug #843, too.
Patch by John Donaghy. Explanation:
The issue is that get_ext_stream_properties shouldnt be returning
false when no extended stream properties are found for the stream in
question because that is not an error condition ... extended stream
properties are optional. The only time this function should return
false is when the buffer overrun checks fail.
author | nicodvb |
---|---|
date | Wed, 18 Jul 2007 22:16:08 +0000 |
parents | 795631068b92 |
children | 13893a33f5ba |
rev | line source |
---|---|
12164 | 1 /* |
2 Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at> | |
3 | |
4 This program is free software; you can redistribute it and/or modify | |
5 it under the terms of the GNU General Public License as published by | |
6 the Free Software Foundation; either version 2 of the License, or | |
7 (at your option) any later version. | |
8 | |
9 This program is distributed in the hope that it will be useful, | |
10 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 GNU General Public License for more details. | |
13 | |
14 You should have received a copy of the GNU General Public License | |
15 along with this program; if not, write to the Free Software | |
17367
401b440a6d76
Update licensing information: The FSF changed postal address.
diego
parents:
17354
diff
changeset
|
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
12164 | 17 */ |
18 | |
19 // #include <stdio.h> | |
20 #include <stdlib.h> | |
21 // #include <unistd.h> | |
19611 | 22 #include <limits.h> |
12164 | 23 |
24 #include "config.h" | |
25 #include "mp_msg.h" | |
23010
74efb0fa8a0b
with -identify show audio and video id; patch by Andrew Savchenko (Bircoph list ru)
nicodvb
parents:
22990
diff
changeset
|
26 #include "help_mp.h" |
12164 | 27 |
22605
4d81dbdf46b9
Add explicit location for headers from the stream/ directory.
diego
parents:
22440
diff
changeset
|
28 #include "stream/stream.h" |
12164 | 29 #include "demuxer.h" |
30 #include "stheader.h" | |
19598 | 31 #include "m_option.h" |
23758 | 32 #include "libvo/sub.h" |
12164 | 33 |
17354 | 34 #ifdef USE_LIBAVFORMAT_SO |
35 #include <ffmpeg/avformat.h> | |
21995
f615c862f862
Remove ff_gcd prototype and include avutil.h instead where it is defined.
reimar
parents:
21966
diff
changeset
|
36 #include <ffmpeg/avutil.h> |
19598 | 37 #include <ffmpeg/opt.h> |
17354 | 38 #else |
12164 | 39 #include "avformat.h" |
21995
f615c862f862
Remove ff_gcd prototype and include avutil.h instead where it is defined.
reimar
parents:
21966
diff
changeset
|
40 #include "avutil.h" |
12164 | 41 #include "avi.h" |
19598 | 42 #include "opt.h" |
17354 | 43 #endif |
21822
fc4ce8a91a2e
Include "internal" libavformat/riff.h also when dynamic libavformat is used
reimar
parents:
21779
diff
changeset
|
44 #include "riff.h" |
12164 | 45 |
46 #define PROBE_BUF_SIZE 2048 | |
47 | |
18775 | 48 extern char *audio_lang; |
19598 | 49 static unsigned int opt_probesize = 0; |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
50 static char *opt_format; |
19598 | 51 |
52 m_option_t lavfdopts_conf[] = { | |
53 {"probesize", &(opt_probesize), CONF_TYPE_INT, CONF_RANGE, 32, INT_MAX, NULL}, | |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
54 {"format", &(opt_format), CONF_TYPE_STRING, 0, 0, 0, NULL}, |
19598 | 55 {NULL, NULL, 0, 0, 0, 0, NULL} |
56 }; | |
57 | |
18775 | 58 |
12164 | 59 typedef struct lavf_priv_t{ |
60 AVInputFormat *avif; | |
61 AVFormatContext *avfc; | |
62 ByteIOContext pb; | |
63 int audio_streams; | |
64 int video_streams; | |
23758 | 65 int sub_streams; |
12168 | 66 int64_t last_pts; |
18762 | 67 int astreams[MAX_A_STREAMS]; |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
68 int vstreams[MAX_V_STREAMS]; |
23758 | 69 int sstreams[MAX_S_STREAMS]; |
12164 | 70 }lavf_priv_t; |
71 | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
72 extern void print_wave_header(WAVEFORMATEX *h, int verbose_level); |
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
73 extern void print_video_header(BITMAPINFOHEADER *h, int verbose_level); |
12164 | 74 |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
75 static const AVCodecTag mp_wav_tags[] = { |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
76 { CODEC_ID_ADPCM_4XM, MKTAG('4', 'X', 'M', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
77 { CODEC_ID_ADPCM_EA, MKTAG('A', 'D', 'E', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
78 { CODEC_ID_ADPCM_IMA_WS, MKTAG('A', 'I', 'W', 'S')}, |
22916 | 79 { CODEC_ID_ADPCM_THP, MKTAG('T', 'H', 'P', 'A')}, |
21779 | 80 { CODEC_ID_AMR_NB, MKTAG('n', 'b', 0, 0)}, |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
81 { CODEC_ID_DSICINAUDIO, MKTAG('D', 'C', 'I', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
82 { CODEC_ID_INTERPLAY_DPCM, MKTAG('I', 'N', 'P', 'A')}, |
21763
43c8f1aa82bb
add support for musepack native decoder from ffmpeg (require -demuxer lavf)
aurel
parents:
21568
diff
changeset
|
83 { CODEC_ID_MUSEPACK7, MKTAG('M', 'P', 'C', ' ')}, |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
84 { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4')}, |
22058
b149aa896f8d
Support 16bit bigendian PCM audio from libavformat
reimar
parents:
21995
diff
changeset
|
85 { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's')}, |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
86 { CODEC_ID_PCM_S8, MKTAG('t', 'w', 'o', 's')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
87 { CODEC_ID_ROQ_DPCM, MKTAG('R', 'o', 'Q', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
88 { CODEC_ID_SHORTEN, MKTAG('s', 'h', 'r', 'n')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
89 { CODEC_ID_TTA, MKTAG('T', 'T', 'A', '1')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
90 { CODEC_ID_WAVPACK, MKTAG('W', 'V', 'P', 'K')}, |
21362 | 91 { CODEC_ID_WESTWOOD_SND1, MKTAG('S', 'N', 'D', '1')}, |
20990 | 92 { CODEC_ID_XAN_DPCM, MKTAG('A', 'x', 'a', 'n')}, |
20733
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
93 { 0, 0 }, |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
94 }; |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
95 |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
96 const struct AVCodecTag *mp_wav_taglists[] = {codec_wav_tags, mp_wav_tags, 0}; |
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
97 |
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
98 static const AVCodecTag mp_bmp_tags[] = { |
23088 | 99 { CODEC_ID_BETHSOFTVID, MKTAG('B', 'E', 'T', 'H')}, |
22918 | 100 { CODEC_ID_C93, MKTAG('C', '9', '3', 'V')}, |
20940 | 101 { CODEC_ID_DSICINVIDEO, MKTAG('D', 'C', 'I', 'V')}, |
22690 | 102 { CODEC_ID_DXA, MKTAG('D', 'X', 'A', '1')}, |
20963 | 103 { CODEC_ID_FLIC, MKTAG('F', 'L', 'I', 'C')}, |
20980
70ca50bcc4a8
support for some more fringe formats, still buggy ..
diego
parents:
20963
diff
changeset
|
104 { CODEC_ID_IDCIN, MKTAG('I', 'D', 'C', 'I')}, |
70ca50bcc4a8
support for some more fringe formats, still buggy ..
diego
parents:
20963
diff
changeset
|
105 { CODEC_ID_INTERPLAY_VIDEO, MKTAG('I', 'N', 'P', 'V')}, |
20942
2093d87ed14b
support for RoQ video and audio through libavformat
diego
parents:
20941
diff
changeset
|
106 { CODEC_ID_ROQ, MKTAG('R', 'o', 'Q', 'V')}, |
22876 | 107 { CODEC_ID_THP, MKTAG('T', 'H', 'P', 'V')}, |
20933 | 108 { CODEC_ID_TIERTEXSEQVIDEO, MKTAG('T', 'S', 'E', 'Q')}, |
23274
f3e72ce8a9fd
add txd codec, works with http://samples.mplayerhq.hu/game-formats/txd/fronten2.txd .
compn
parents:
23088
diff
changeset
|
109 { CODEC_ID_TXD, MKTAG('T', 'X', 'D', 'V')}, |
20935
4a8c67e44c7f
cosmetics: alphabetical order and prettyprinting for the CodecTag table
diego
parents:
20934
diff
changeset
|
110 { CODEC_ID_VMDVIDEO, MKTAG('V', 'M', 'D', 'V')}, |
20980
70ca50bcc4a8
support for some more fringe formats, still buggy ..
diego
parents:
20963
diff
changeset
|
111 { CODEC_ID_WS_VQA, MKTAG('V', 'Q', 'A', 'V')}, |
20935
4a8c67e44c7f
cosmetics: alphabetical order and prettyprinting for the CodecTag table
diego
parents:
20934
diff
changeset
|
112 { CODEC_ID_XAN_WC3, MKTAG('W', 'C', '3', 'V')}, |
20733
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
113 { 0, 0 }, |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
114 }; |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
115 |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
116 const struct AVCodecTag *mp_bmp_taglists[] = {codec_bmp_tags, mp_bmp_tags, 0}; |
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
117 |
12164 | 118 static int mp_open(URLContext *h, const char *filename, int flags){ |
119 return 0; | |
120 } | |
121 | |
122 static int mp_read(URLContext *h, unsigned char *buf, int size){ | |
123 stream_t *stream = (stream_t*)h->priv_data; | |
12165
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
124 int ret; |
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
125 |
12164 | 126 if(stream_eof(stream)) //needed? |
127 return -1; | |
12165
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
128 ret=stream_read(stream, buf, size); |
12166 | 129 |
12165
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
130 mp_msg(MSGT_HEADER,MSGL_DBG2,"%d=mp_read(%p, %p, %d), eof:%d\n", ret, h, buf, size, stream->eof); |
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
131 return ret; |
12164 | 132 } |
133 | |
134 static int mp_write(URLContext *h, unsigned char *buf, int size){ | |
135 return -1; | |
136 } | |
137 | |
138 static offset_t mp_seek(URLContext *h, offset_t pos, int whence){ | |
139 stream_t *stream = (stream_t*)h->priv_data; | |
12165
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
140 |
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
141 mp_msg(MSGT_HEADER,MSGL_DBG2,"mp_seek(%p, %d, %d)\n", h, (int)pos, whence); |
12164 | 142 if(whence == SEEK_CUR) |
143 pos +=stream_tell(stream); | |
144 else if(whence == SEEK_END) | |
145 pos += stream->end_pos; | |
22440
ee6b8e74d727
when seeking consider stream->start_pos instead of 0 as initial position; patch by Zuxy Meng approved by Michael
nicodvb
parents:
22266
diff
changeset
|
146 else if(whence == SEEK_SET) |
ee6b8e74d727
when seeking consider stream->start_pos instead of 0 as initial position; patch by Zuxy Meng approved by Michael
nicodvb
parents:
22266
diff
changeset
|
147 pos += stream->start_pos; |
ee6b8e74d727
when seeking consider stream->start_pos instead of 0 as initial position; patch by Zuxy Meng approved by Michael
nicodvb
parents:
22266
diff
changeset
|
148 else |
12164 | 149 return -1; |
150 | |
12167 | 151 if(pos<stream->end_pos && stream->eof) |
12166 | 152 stream_reset(stream); |
12164 | 153 if(stream_seek(stream, pos)==0) |
154 return -1; | |
12166 | 155 |
22440
ee6b8e74d727
when seeking consider stream->start_pos instead of 0 as initial position; patch by Zuxy Meng approved by Michael
nicodvb
parents:
22266
diff
changeset
|
156 return pos - stream->start_pos; |
12164 | 157 } |
158 | |
159 static int mp_close(URLContext *h){ | |
160 return 0; | |
161 } | |
162 | |
163 static URLProtocol mp_protocol = { | |
164 "mp", | |
165 mp_open, | |
166 mp_read, | |
167 mp_write, | |
168 mp_seek, | |
169 mp_close, | |
170 }; | |
171 | |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
172 static void list_formats(void) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
173 AVInputFormat *fmt; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
174 mp_msg(MSGT_DEMUX, MSGL_INFO, "Available lavf input formats:\n"); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
175 for (fmt = first_iformat; fmt; fmt = fmt->next) |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
176 mp_msg(MSGT_DEMUX, MSGL_INFO, "%15s : %s\n", fmt->name, fmt->long_name); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
177 } |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
178 |
16175 | 179 static int lavf_check_file(demuxer_t *demuxer){ |
12164 | 180 AVProbeData avpd; |
181 uint8_t buf[PROBE_BUF_SIZE]; | |
182 lavf_priv_t *priv; | |
183 | |
184 if(!demuxer->priv) | |
185 demuxer->priv=calloc(sizeof(lavf_priv_t),1); | |
186 priv= demuxer->priv; | |
187 | |
188 av_register_all(); | |
189 | |
15819 | 190 if(stream_read(demuxer->stream, buf, PROBE_BUF_SIZE)!=PROBE_BUF_SIZE) |
191 return 0; | |
12164 | 192 avpd.filename= demuxer->stream->url; |
193 avpd.buf= buf; | |
194 avpd.buf_size= PROBE_BUF_SIZE; | |
195 | |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
196 if (opt_format) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
197 if (strcmp(opt_format, "help") == 0) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
198 list_formats(); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
199 return 0; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
200 } |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
201 priv->avif= av_find_input_format(opt_format); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
202 if (!priv->avif) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
203 mp_msg(MSGT_DEMUX,MSGL_FATAL,"Unknown lavf format %s\n", opt_format); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
204 return 0; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
205 } |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
206 mp_msg(MSGT_DEMUX,MSGL_INFO,"Forced lavf %s demuxer\n", priv->avif->long_name); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
207 return DEMUXER_TYPE_LAVF; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
208 } |
12164 | 209 priv->avif= av_probe_input_format(&avpd, 1); |
210 if(!priv->avif){ | |
211 mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: no clue about this gibberish!\n"); | |
212 return 0; | |
213 }else | |
214 mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: %s\n", priv->avif->long_name); | |
215 | |
16175 | 216 return DEMUXER_TYPE_LAVF; |
12164 | 217 } |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
218 |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
219 static const char *preferred_list[] = { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
220 "dxa", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
221 "wv", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
222 "nuv", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
223 "nut", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
224 "gxf", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
225 "mxf", |
22972
46593cc4aeba
Use lavf_preferred mechanism to replace more extension-based detection hacks
reimar
parents:
22971
diff
changeset
|
226 "flv", |
46593cc4aeba
Use lavf_preferred mechanism to replace more extension-based detection hacks
reimar
parents:
22971
diff
changeset
|
227 "swf", |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
228 NULL |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
229 }; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
230 |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
231 static int lavf_check_preferred_file(demuxer_t *demuxer){ |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
232 if (lavf_check_file(demuxer)) { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
233 char **p = preferred_list; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
234 lavf_priv_t *priv = demuxer->priv; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
235 while (*p) { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
236 if (strcmp(*p, priv->avif->name) == 0) |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
237 return DEMUXER_TYPE_LAVF_PREFERRED; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
238 p++; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
239 } |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
240 } |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
241 return 0; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
242 } |
12164 | 243 |
16175 | 244 static demuxer_t* demux_open_lavf(demuxer_t *demuxer){ |
12164 | 245 AVFormatContext *avfc; |
246 AVFormatParameters ap; | |
19598 | 247 AVOption *opt; |
12164 | 248 lavf_priv_t *priv= demuxer->priv; |
15011 | 249 int i,g; |
12164 | 250 char mp_filename[256]="mp:"; |
251 | |
252 memset(&ap, 0, sizeof(AVFormatParameters)); | |
253 | |
254 stream_seek(demuxer->stream, 0); | |
255 | |
256 register_protocol(&mp_protocol); | |
257 | |
19598 | 258 avfc = av_alloc_format_context(); |
21548 | 259 |
260 if (correct_pts) | |
261 avfc->flags |= AVFMT_FLAG_GENPTS; | |
21568 | 262 if (index_mode == 0) |
263 avfc->flags |= AVFMT_FLAG_IGNIDX; | |
21548 | 264 |
19598 | 265 ap.prealloced_context = 1; |
266 if(opt_probesize) { | |
267 double d = (double) opt_probesize; | |
268 opt = av_set_double(avfc, "probesize", opt_probesize); | |
269 if(!opt) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option probesize to %.3f\r\n", d); | |
270 } | |
271 | |
12463 | 272 if(demuxer->stream->url) |
273 strncpy(mp_filename + 3, demuxer->stream->url, sizeof(mp_filename)-3); | |
274 else | |
275 strncpy(mp_filename + 3, "foobar.dummy", sizeof(mp_filename)-3); | |
12164 | 276 |
277 url_fopen(&priv->pb, mp_filename, URL_RDONLY); | |
278 | |
279 ((URLContext*)(priv->pb.opaque))->priv_data= demuxer->stream; | |
280 | |
281 if(av_open_input_stream(&avfc, &priv->pb, mp_filename, priv->avif, &ap)<0){ | |
282 mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_open_input_stream() failed\n"); | |
16175 | 283 return NULL; |
12164 | 284 } |
285 | |
286 priv->avfc= avfc; | |
287 | |
288 if(av_find_stream_info(avfc) < 0){ | |
289 mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_find_stream_info() failed\n"); | |
16175 | 290 return NULL; |
12164 | 291 } |
292 | |
12167 | 293 if(avfc->title [0]) demux_info_add(demuxer, "name" , avfc->title ); |
294 if(avfc->author [0]) demux_info_add(demuxer, "author" , avfc->author ); | |
295 if(avfc->copyright[0]) demux_info_add(demuxer, "copyright", avfc->copyright); | |
296 if(avfc->comment [0]) demux_info_add(demuxer, "comments" , avfc->comment ); | |
297 if(avfc->album [0]) demux_info_add(demuxer, "album" , avfc->album ); | |
298 // if(avfc->year ) demux_info_add(demuxer, "year" , avfc->year ); | |
299 // if(avfc->track ) demux_info_add(demuxer, "track" , avfc->track ); | |
300 if(avfc->genre [0]) demux_info_add(demuxer, "genre" , avfc->genre ); | |
12164 | 301 |
302 for(i=0; i<avfc->nb_streams; i++){ | |
303 AVStream *st= avfc->streams[i]; | |
16000 | 304 AVCodecContext *codec= st->codec; |
19073
8b52dad54b1d
Remove #if LIBAVCODEC_BUILD >= XXX and #if LIBAVFORMAT_BUILD >= XXX jungle.
diego
parents:
19062
diff
changeset
|
305 |
12164 | 306 switch(codec->codec_type){ |
307 case CODEC_TYPE_AUDIO:{ | |
308 WAVEFORMATEX *wf= calloc(sizeof(WAVEFORMATEX) + codec->extradata_size, 1); | |
18985 | 309 sh_audio_t* sh_audio; |
18762 | 310 if(priv->audio_streams >= MAX_A_STREAMS) |
311 break; | |
18985 | 312 sh_audio=new_sh_audio(demuxer, i); |
23010
74efb0fa8a0b
with -identify show audio and video id; patch by Andrew Savchenko (Bircoph list ru)
nicodvb
parents:
22990
diff
changeset
|
313 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "lavf", i); |
18762 | 314 if(!sh_audio) |
315 break; | |
316 priv->astreams[priv->audio_streams] = i; | |
12164 | 317 priv->audio_streams++; |
22990
a76748e71a18
Ignore mp4a audio tag, it is meaningless since we get it for all mp4 files
reimar
parents:
22972
diff
changeset
|
318 // mp4a tag is used for all mp4 files no matter what they actually contain |
a76748e71a18
Ignore mp4a audio tag, it is meaningless since we get it for all mp4 files
reimar
parents:
22972
diff
changeset
|
319 if(codec->codec_tag == MKTAG('m', 'p', '4', 'a')) |
a76748e71a18
Ignore mp4a audio tag, it is meaningless since we get it for all mp4 files
reimar
parents:
22972
diff
changeset
|
320 codec->codec_tag= 0; |
12164 | 321 if(!codec->codec_tag) |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
322 codec->codec_tag= av_codec_get_tag(mp_wav_taglists, codec->codec_id); |
12164 | 323 wf->wFormatTag= codec->codec_tag; |
324 wf->nChannels= codec->channels; | |
325 wf->nSamplesPerSec= codec->sample_rate; | |
326 wf->nAvgBytesPerSec= codec->bit_rate/8; | |
22266 | 327 wf->nBlockAlign= codec->block_align ? codec->block_align : 1; |
12164 | 328 wf->wBitsPerSample= codec->bits_per_sample; |
329 wf->cbSize= codec->extradata_size; | |
330 if(codec->extradata_size){ | |
331 memcpy( | |
332 wf + 1, | |
333 codec->extradata, | |
334 codec->extradata_size); | |
335 } | |
336 sh_audio->wf= wf; | |
15011 | 337 sh_audio->audio.dwSampleSize= codec->block_align; |
338 if(codec->frame_size && codec->sample_rate){ | |
339 sh_audio->audio.dwScale=codec->frame_size; | |
340 sh_audio->audio.dwRate= codec->sample_rate; | |
341 }else{ | |
342 sh_audio->audio.dwScale= codec->block_align ? codec->block_align*8 : 8; | |
343 sh_audio->audio.dwRate = codec->bit_rate; | |
344 } | |
345 g= ff_gcd(sh_audio->audio.dwScale, sh_audio->audio.dwRate); | |
346 sh_audio->audio.dwScale /= g; | |
347 sh_audio->audio.dwRate /= g; | |
348 // printf("sca:%d rat:%d fs:%d sr:%d ba:%d\n", sh_audio->audio.dwScale, sh_audio->audio.dwRate, codec->frame_size, codec->sample_rate, codec->block_align); | |
12164 | 349 sh_audio->ds= demuxer->audio; |
350 sh_audio->format= codec->codec_tag; | |
351 sh_audio->channels= codec->channels; | |
352 sh_audio->samplerate= codec->sample_rate; | |
15007 | 353 sh_audio->i_bps= codec->bit_rate/8; |
16134
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
354 switch (codec->codec_id) { |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
355 case CODEC_ID_PCM_S8: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
356 case CODEC_ID_PCM_U8: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
357 sh_audio->samplesize = 1; |
16135 | 358 break; |
16134
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
359 case CODEC_ID_PCM_S16LE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
360 case CODEC_ID_PCM_S16BE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
361 case CODEC_ID_PCM_U16LE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
362 case CODEC_ID_PCM_U16BE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
363 sh_audio->samplesize = 2; |
16135 | 364 break; |
365 case CODEC_ID_PCM_ALAW: | |
366 sh_audio->format = 0x6; | |
367 break; | |
368 case CODEC_ID_PCM_MULAW: | |
369 sh_audio->format = 0x7; | |
370 break; | |
16134
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
371 } |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
372 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_wave_header(sh_audio->wf, MSGL_V); |
18775 | 373 if((audio_lang && st->language[0] && !strncmp(audio_lang, st->language, 3)) |
374 || (demuxer->audio->id == i || demuxer->audio->id == -1) | |
375 ) { | |
376 demuxer->audio->id = i; | |
377 demuxer->audio->sh= demuxer->a_streams[i]; | |
378 } | |
379 else | |
15004 | 380 st->discard= AVDISCARD_ALL; |
12164 | 381 break;} |
382 case CODEC_TYPE_VIDEO:{ | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
383 sh_video_t* sh_video; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
384 BITMAPINFOHEADER *bih; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
385 if(priv->video_streams >= MAX_V_STREAMS) |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
386 break; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
387 sh_video=new_sh_video(demuxer, i); |
23010
74efb0fa8a0b
with -identify show audio and video id; patch by Andrew Savchenko (Bircoph list ru)
nicodvb
parents:
22990
diff
changeset
|
388 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_VideoID, "lavf", i); |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
389 if(!sh_video) break; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
390 priv->vstreams[priv->video_streams] = i; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
391 priv->video_streams++; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
392 bih=calloc(sizeof(BITMAPINFOHEADER) + codec->extradata_size,1); |
12164 | 393 |
394 if(!codec->codec_tag) | |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
395 codec->codec_tag= av_codec_get_tag(mp_bmp_taglists, codec->codec_id); |
12164 | 396 bih->biSize= sizeof(BITMAPINFOHEADER) + codec->extradata_size; |
397 bih->biWidth= codec->width; | |
398 bih->biHeight= codec->height; | |
399 bih->biBitCount= codec->bits_per_sample; | |
400 bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8; | |
401 bih->biCompression= codec->codec_tag; | |
402 sh_video->bih= bih; | |
403 sh_video->disp_w= codec->width; | |
404 sh_video->disp_h= codec->height; | |
16718
044260623695
makes demux_lavf (-demuxer 35) use the framerate specified in the container
gpoirier
parents:
16346
diff
changeset
|
405 if (st->time_base.den) { /* if container has time_base, use that */ |
044260623695
makes demux_lavf (-demuxer 35) use the framerate specified in the container
gpoirier
parents:
16346
diff
changeset
|
406 sh_video->video.dwRate= st->time_base.den; |
044260623695
makes demux_lavf (-demuxer 35) use the framerate specified in the container
gpoirier
parents:
16346
diff
changeset
|
407 sh_video->video.dwScale= st->time_base.num; |
044260623695
makes demux_lavf (-demuxer 35) use the framerate specified in the container
gpoirier
parents:
16346
diff
changeset
|
408 } else { |
15308 | 409 sh_video->video.dwRate= codec->time_base.den; |
410 sh_video->video.dwScale= codec->time_base.num; | |
16718
044260623695
makes demux_lavf (-demuxer 35) use the framerate specified in the container
gpoirier
parents:
16346
diff
changeset
|
411 } |
17556 | 412 sh_video->fps=av_q2d(st->r_frame_rate); |
413 sh_video->frametime=1/av_q2d(st->r_frame_rate); | |
12164 | 414 sh_video->format = bih->biCompression; |
12167 | 415 sh_video->aspect= codec->width * codec->sample_aspect_ratio.num |
416 / (float)(codec->height * codec->sample_aspect_ratio.den); | |
15007 | 417 sh_video->i_bps= codec->bit_rate/8; |
12167 | 418 mp_msg(MSGT_DEMUX,MSGL_DBG2,"aspect= %d*%d/(%d*%d)\n", |
419 codec->width, codec->sample_aspect_ratio.num, | |
420 codec->height, codec->sample_aspect_ratio.den); | |
421 | |
12164 | 422 sh_video->ds= demuxer->video; |
423 if(codec->extradata_size) | |
424 memcpy(sh_video->bih + 1, codec->extradata, codec->extradata_size); | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
425 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_video->bih, MSGL_V); |
12164 | 426 /* short biPlanes; |
427 int biXPelsPerMeter; | |
428 int biYPelsPerMeter; | |
429 int biClrUsed; | |
430 int biClrImportant;*/ | |
15004 | 431 if(demuxer->video->id != i && demuxer->video->id != -1) |
432 st->discard= AVDISCARD_ALL; | |
433 else{ | |
434 demuxer->video->id = i; | |
435 demuxer->video->sh= demuxer->v_streams[i]; | |
436 } | |
12164 | 437 break;} |
23758 | 438 case CODEC_TYPE_SUBTITLE:{ |
439 sh_sub_t* sh_sub; | |
440 if(priv->sub_streams >= MAX_S_STREAMS) | |
441 break; | |
442 /* only support text subtitles for now */ | |
443 if(codec->codec_id != CODEC_ID_TEXT) | |
444 break; | |
445 sh_sub = new_sh_sub_sid(demuxer, i, priv->sub_streams); | |
446 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_SubtitleID, "lavf", priv->sub_streams); | |
447 if(!sh_sub) break; | |
448 priv->sstreams[priv->sub_streams] = i; | |
449 sh_sub->type = 't'; | |
450 demuxer->sub->sh = demuxer->s_streams[priv->sub_streams++]; | |
451 break;} | |
15004 | 452 default: |
453 st->discard= AVDISCARD_ALL; | |
12164 | 454 } |
455 } | |
456 | |
457 mp_msg(MSGT_HEADER,MSGL_V,"LAVF: %d audio and %d video streams found\n",priv->audio_streams,priv->video_streams); | |
13749 | 458 mp_msg(MSGT_HEADER,MSGL_V,"LAVF: build %d\n", LIBAVFORMAT_BUILD); |
12164 | 459 if(!priv->audio_streams) demuxer->audio->id=-2; // nosound |
460 // else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio; | |
461 if(!priv->video_streams){ | |
462 if(!priv->audio_streams){ | |
463 mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF: no audio or video headers found - broken file?\n"); | |
16175 | 464 return NULL; |
12164 | 465 } |
466 demuxer->video->id=-2; // audio-only | |
467 } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video; | |
468 | |
16175 | 469 return demuxer; |
12164 | 470 } |
471 | |
16175 | 472 static int demux_lavf_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){ |
12164 | 473 lavf_priv_t *priv= demux->priv; |
474 AVPacket pkt; | |
475 demux_packet_t *dp; | |
476 demux_stream_t *ds; | |
477 int id; | |
478 mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_lavf_fill_buffer()\n"); | |
479 | |
480 demux->filepos=stream_tell(demux->stream); | |
481 | |
482 if(av_read_frame(priv->avfc, &pkt) < 0) | |
483 return 0; | |
484 | |
485 id= pkt.stream_index; | |
486 | |
487 if(id==demux->audio->id){ | |
488 // audio | |
489 ds=demux->audio; | |
490 if(!ds->sh){ | |
491 ds->sh=demux->a_streams[id]; | |
492 mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF audio ID = %d\n",ds->id); | |
493 } | |
494 } else if(id==demux->video->id){ | |
495 // video | |
496 ds=demux->video; | |
497 if(!ds->sh){ | |
498 ds->sh=demux->v_streams[id]; | |
499 mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF video ID = %d\n",ds->id); | |
500 } | |
23758 | 501 } else if(id==demux->sub->id){ |
502 // subtitle | |
503 ds=demux->sub; | |
504 sub_utf8=1; | |
14611 | 505 } else { |
506 av_free_packet(&pkt); | |
507 return 1; | |
508 } | |
12164 | 509 |
510 if(0/*pkt.destruct == av_destruct_packet*/){ | |
511 //ok kids, dont try this at home :) | |
19062
83c3afeab35d
drops casts from void * on malloc/calloc from libmpdemux code
reynaldo
parents:
18985
diff
changeset
|
512 dp=malloc(sizeof(demux_packet_t)); |
12164 | 513 dp->len=pkt.size; |
514 dp->next=NULL; | |
515 dp->refcount=1; | |
516 dp->master=NULL; | |
517 dp->buffer=pkt.data; | |
518 pkt.destruct= NULL; | |
519 }else{ | |
520 dp=new_demux_packet(pkt.size); | |
521 memcpy(dp->buffer, pkt.data, pkt.size); | |
522 av_free_packet(&pkt); | |
523 } | |
524 | |
13747 | 525 if(pkt.pts != AV_NOPTS_VALUE){ |
15308 | 526 dp->pts=pkt.pts * av_q2d(priv->avfc->streams[id]->time_base); |
527 priv->last_pts= dp->pts * AV_TIME_BASE; | |
23758 | 528 if(pkt.duration) |
529 dp->endpts = dp->pts + pkt.duration * av_q2d(priv->avfc->streams[id]->time_base); | |
13747 | 530 } |
12164 | 531 dp->pos=demux->filepos; |
532 dp->flags= !!(pkt.flags&PKT_FLAG_KEY); | |
533 // append packet to DS stream: | |
534 ds_add_packet(ds,dp); | |
535 return 1; | |
536 } | |
537 | |
17636 | 538 static void demux_seek_lavf(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags){ |
12168 | 539 lavf_priv_t *priv = demuxer->priv; |
20070 | 540 int avsflags = 0; |
17636 | 541 mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_seek_lavf(%p, %f, %f, %d)\n", demuxer, rel_seek_secs, audio_delay, flags); |
19073
8b52dad54b1d
Remove #if LIBAVCODEC_BUILD >= XXX and #if LIBAVFORMAT_BUILD >= XXX jungle.
diego
parents:
19062
diff
changeset
|
542 |
20070 | 543 if (flags & 1) // absolute seek |
544 priv->last_pts = priv->avfc->start_time; | |
545 if (flags & 2) { // percent seek | |
546 if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE) | |
547 return; | |
548 priv->last_pts += rel_seek_secs * priv->avfc->duration; | |
549 } else { | |
550 priv->last_pts += rel_seek_secs * AV_TIME_BASE; | |
551 if (rel_seek_secs < 0) avsflags = AVSEEK_FLAG_BACKWARD; | |
552 } | |
553 av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags); | |
12164 | 554 } |
555 | |
16175 | 556 static int demux_lavf_control(demuxer_t *demuxer, int cmd, void *arg) |
12164 | 557 { |
558 lavf_priv_t *priv = demuxer->priv; | |
559 | |
560 switch (cmd) { | |
12168 | 561 case DEMUXER_CTRL_GET_TIME_LENGTH: |
19207
c636a4e9565a
Do not treat AV_NOPTS_VALUE as a valid duration value.
reimar
parents:
19160
diff
changeset
|
562 if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE) |
12164 | 563 return DEMUXER_CTRL_DONTKNOW; |
564 | |
16346
6ff303d2876b
Make -identify's 'ID_LENGTH=' print a float and not an integer.. The
ods15
parents:
16175
diff
changeset
|
565 *((double *)arg) = (double)priv->avfc->duration / AV_TIME_BASE; |
12164 | 566 return DEMUXER_CTRL_OK; |
567 | |
568 case DEMUXER_CTRL_GET_PERCENT_POS: | |
19207
c636a4e9565a
Do not treat AV_NOPTS_VALUE as a valid duration value.
reimar
parents:
19160
diff
changeset
|
569 if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE) |
12164 | 570 return DEMUXER_CTRL_DONTKNOW; |
571 | |
19160
ccb42ce33c23
Take start time into consideration when calculation percentage position
reimar
parents:
19073
diff
changeset
|
572 *((int *)arg) = (int)((priv->last_pts - priv->avfc->start_time)*100 / priv->avfc->duration); |
12168 | 573 return DEMUXER_CTRL_OK; |
18762 | 574 case DEMUXER_CTRL_SWITCH_AUDIO: |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
575 case DEMUXER_CTRL_SWITCH_VIDEO: |
18762 | 576 { |
577 int id = *((int*)arg); | |
578 int newid = -2; | |
579 int i, curridx = -2; | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
580 int nstreams, *pstreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
581 demux_stream_t *ds; |
18762 | 582 |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
583 if(cmd == DEMUXER_CTRL_SWITCH_VIDEO) |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
584 { |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
585 ds = demuxer->video; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
586 nstreams = priv->video_streams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
587 pstreams = priv->vstreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
588 } |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
589 else |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
590 { |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
591 ds = demuxer->audio; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
592 nstreams = priv->audio_streams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
593 pstreams = priv->astreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
594 } |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
595 if(ds->id == -2) |
18762 | 596 return DEMUXER_CTRL_NOTIMPL; |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
597 for(i = 0; i < nstreams; i++) |
18762 | 598 { |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
599 if(pstreams[i] == ds->id) //current stream id |
18762 | 600 { |
601 curridx = i; | |
602 break; | |
603 } | |
604 } | |
605 | |
606 if(id < 0) | |
607 { | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
608 i = (curridx + 1) % nstreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
609 newid = pstreams[i]; |
18762 | 610 } |
611 else | |
612 { | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
613 for(i = 0; i < nstreams; i++) |
18762 | 614 { |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
615 if(pstreams[i] == id) |
18762 | 616 { |
617 newid = id; | |
618 break; | |
619 } | |
620 } | |
621 } | |
622 if(newid == -2 || i == curridx) | |
623 return DEMUXER_CTRL_NOTIMPL; | |
624 else | |
625 { | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
626 ds_free_packs(ds); |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
627 priv->avfc->streams[ds->id]->discard = AVDISCARD_ALL; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
628 *((int*)arg) = ds->id = newid; |
18762 | 629 priv->avfc->streams[newid]->discard = AVDISCARD_NONE; |
630 return DEMUXER_CTRL_OK; | |
631 } | |
632 } | |
12164 | 633 default: |
634 return DEMUXER_CTRL_NOTIMPL; | |
635 } | |
636 } | |
637 | |
23758 | 638 /** \brief Get the language code for a subtitle track. |
639 | |
640 Retrieves the language code for a subtitle track. | |
641 | |
642 \param demuxer The demuxer to work on | |
643 \param track_num The subtitle track number to get the language from | |
644 */ | |
645 char *demux_lavf_sub_lang(demuxer_t *demuxer, int track_num) | |
646 { | |
647 lavf_priv_t *priv = demuxer->priv; | |
648 return priv->avfc->streams[priv->sstreams[track_num]]->language; | |
649 } | |
650 | |
16175 | 651 static void demux_close_lavf(demuxer_t *demuxer) |
12164 | 652 { |
653 lavf_priv_t* priv = demuxer->priv; | |
654 if (priv){ | |
12304
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
655 if(priv->avfc) |
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
656 { |
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
657 av_close_input_file(priv->avfc); priv->avfc= NULL; |
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
658 } |
12164 | 659 free(priv); demuxer->priv= NULL; |
660 } | |
661 } | |
662 | |
16175 | 663 |
664 demuxer_desc_t demuxer_desc_lavf = { | |
665 "libavformat demuxer", | |
666 "lavf", | |
667 "libavformat", | |
668 "Michael Niedermayer", | |
669 "supports many formats, requires libavformat", | |
670 DEMUXER_TYPE_LAVF, | |
671 0, // Check after other demuxer | |
672 lavf_check_file, | |
673 demux_lavf_fill_buffer, | |
674 demux_open_lavf, | |
675 demux_close_lavf, | |
676 demux_seek_lavf, | |
677 demux_lavf_control | |
678 }; | |
679 | |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
680 demuxer_desc_t demuxer_desc_lavf_preferred = { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
681 "libavformat preferred demuxer", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
682 "lavfpref", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
683 "libavformat", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
684 "Michael Niedermayer", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
685 "supports many formats, requires libavformat", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
686 DEMUXER_TYPE_LAVF_PREFERRED, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
687 0, // Check after other demuxer |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
688 lavf_check_preferred_file, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
689 demux_lavf_fill_buffer, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
690 demux_open_lavf, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
691 demux_close_lavf, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
692 demux_seek_lavf, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
693 demux_lavf_control |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
694 }; |