Mercurial > mplayer.hg
annotate libmpdemux/demux_lavf.c @ 24674:f6cf2c01315d
Format 0x01 cannot be used with "AMV IMA ADPCM", because it belongs to normal PCM.
Make lavf demuxer set codec tag to AMVA in this case.
No need to use -ac +ffadpcmimaamva anymore.
author | voroshil |
---|---|
date | Wed, 03 Oct 2007 15:27:02 +0000 |
parents | 46dbc2e8c800 |
children | cc80a9169d90 |
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; |
24635 | 50 static unsigned int opt_analyzeduration = 0; |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
51 static char *opt_format; |
19598 | 52 |
53 m_option_t lavfdopts_conf[] = { | |
54 {"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
|
55 {"format", &(opt_format), CONF_TYPE_STRING, 0, 0, 0, NULL}, |
24635 | 56 {"analyzeduration", &(opt_analyzeduration), CONF_TYPE_INT, CONF_RANGE, 0, INT_MAX, NULL}, |
19598 | 57 {NULL, NULL, 0, 0, 0, 0, NULL} |
58 }; | |
59 | |
18775 | 60 |
12164 | 61 typedef struct lavf_priv_t{ |
62 AVInputFormat *avif; | |
63 AVFormatContext *avfc; | |
64 ByteIOContext pb; | |
65 int audio_streams; | |
66 int video_streams; | |
23758 | 67 int sub_streams; |
12168 | 68 int64_t last_pts; |
18762 | 69 int astreams[MAX_A_STREAMS]; |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
70 int vstreams[MAX_V_STREAMS]; |
23758 | 71 int sstreams[MAX_S_STREAMS]; |
12164 | 72 }lavf_priv_t; |
73 | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
74 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
|
75 extern void print_video_header(BITMAPINFOHEADER *h, int verbose_level); |
12164 | 76 |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
77 static const AVCodecTag mp_wav_tags[] = { |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
78 { CODEC_ID_ADPCM_4XM, MKTAG('4', 'X', 'M', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
79 { CODEC_ID_ADPCM_EA, MKTAG('A', 'D', 'E', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
80 { CODEC_ID_ADPCM_IMA_WS, MKTAG('A', 'I', 'W', 'S')}, |
22916 | 81 { CODEC_ID_ADPCM_THP, MKTAG('T', 'H', 'P', 'A')}, |
21779 | 82 { CODEC_ID_AMR_NB, MKTAG('n', 'b', 0, 0)}, |
24518
8b525df8357a
Add support for cook audio (though most .rm files don't work with lavf
reimar
parents:
24355
diff
changeset
|
83 { CODEC_ID_COOK, MKTAG('c', 'o', 'o', 'k')}, |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
84 { CODEC_ID_DSICINAUDIO, MKTAG('D', 'C', 'I', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
85 { 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
|
86 { CODEC_ID_MUSEPACK7, MKTAG('M', 'P', 'C', ' ')}, |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
87 { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4')}, |
22058
b149aa896f8d
Support 16bit bigendian PCM audio from libavformat
reimar
parents:
21995
diff
changeset
|
88 { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's')}, |
20944
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
89 { CODEC_ID_PCM_S8, MKTAG('t', 'w', 'o', 's')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
90 { CODEC_ID_ROQ_DPCM, MKTAG('R', 'o', 'Q', 'A')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
91 { CODEC_ID_SHORTEN, MKTAG('s', 'h', 'r', 'n')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
92 { CODEC_ID_TTA, MKTAG('T', 'T', 'A', '1')}, |
20910582789d
cosmetics: Restore alphabetical order, align both tables.
diego
parents:
20942
diff
changeset
|
93 { CODEC_ID_WAVPACK, MKTAG('W', 'V', 'P', 'K')}, |
21362 | 94 { CODEC_ID_WESTWOOD_SND1, MKTAG('S', 'N', 'D', '1')}, |
20990 | 95 { 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
|
96 { 0, 0 }, |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
97 }; |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
98 |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
99 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
|
100 |
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
101 static const AVCodecTag mp_bmp_tags[] = { |
24653 | 102 { CODEC_ID_AMV, MKTAG('A', 'M', 'V', 'V')}, |
23088 | 103 { CODEC_ID_BETHSOFTVID, MKTAG('B', 'E', 'T', 'H')}, |
22918 | 104 { CODEC_ID_C93, MKTAG('C', '9', '3', 'V')}, |
20940 | 105 { CODEC_ID_DSICINVIDEO, MKTAG('D', 'C', 'I', 'V')}, |
22690 | 106 { CODEC_ID_DXA, MKTAG('D', 'X', 'A', '1')}, |
20963 | 107 { CODEC_ID_FLIC, MKTAG('F', 'L', 'I', 'C')}, |
20980
70ca50bcc4a8
support for some more fringe formats, still buggy ..
diego
parents:
20963
diff
changeset
|
108 { CODEC_ID_IDCIN, MKTAG('I', 'D', 'C', 'I')}, |
70ca50bcc4a8
support for some more fringe formats, still buggy ..
diego
parents:
20963
diff
changeset
|
109 { CODEC_ID_INTERPLAY_VIDEO, MKTAG('I', 'N', 'P', 'V')}, |
20942
2093d87ed14b
support for RoQ video and audio through libavformat
diego
parents:
20941
diff
changeset
|
110 { CODEC_ID_ROQ, MKTAG('R', 'o', 'Q', 'V')}, |
22876 | 111 { CODEC_ID_THP, MKTAG('T', 'H', 'P', 'V')}, |
20933 | 112 { 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
|
113 { CODEC_ID_TXD, MKTAG('T', 'X', 'D', 'V')}, |
20935
4a8c67e44c7f
cosmetics: alphabetical order and prettyprinting for the CodecTag table
diego
parents:
20934
diff
changeset
|
114 { CODEC_ID_VMDVIDEO, MKTAG('V', 'M', 'D', 'V')}, |
20980
70ca50bcc4a8
support for some more fringe formats, still buggy ..
diego
parents:
20963
diff
changeset
|
115 { 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
|
116 { CODEC_ID_XAN_WC3, MKTAG('W', 'C', '3', 'V')}, |
24355 | 117 { CODEC_ID_NUV, MKTAG('N', 'U', 'V', '1')}, |
20733
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
118 { 0, 0 }, |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
119 }; |
404fb439acba
Add our own CODEC_ID -> fourcc translation tables so we do not need
reimar
parents:
20070
diff
changeset
|
120 |
21966
d9494ca70ca7
Simplify by using av_codec_get_id and include riff.h only in demux_lavf.c
reimar
parents:
21962
diff
changeset
|
121 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
|
122 |
12164 | 123 static int mp_open(URLContext *h, const char *filename, int flags){ |
124 return 0; | |
125 } | |
126 | |
127 static int mp_read(URLContext *h, unsigned char *buf, int size){ | |
128 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
|
129 int ret; |
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
130 |
12164 | 131 if(stream_eof(stream)) //needed? |
132 return -1; | |
12165
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
133 ret=stream_read(stream, buf, size); |
12166 | 134 |
12165
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
135 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
|
136 return ret; |
12164 | 137 } |
138 | |
139 static int mp_write(URLContext *h, unsigned char *buf, int size){ | |
140 return -1; | |
141 } | |
142 | |
143 static offset_t mp_seek(URLContext *h, offset_t pos, int whence){ | |
144 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
|
145 |
6ae21c78ed8d
libavformat really doesnt like it that the streams get stuck if the end is reached
michael
parents:
12164
diff
changeset
|
146 mp_msg(MSGT_HEADER,MSGL_DBG2,"mp_seek(%p, %d, %d)\n", h, (int)pos, whence); |
12164 | 147 if(whence == SEEK_CUR) |
148 pos +=stream_tell(stream); | |
24085
71d17c28f545
We can support SEEK_END seeks only when stream->end_pos is known
reimar
parents:
24084
diff
changeset
|
149 else if(whence == SEEK_END && stream->end_pos > 0) |
12164 | 150 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
|
151 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
|
152 pos += stream->start_pos; |
24084 | 153 else if(whence == AVSEEK_SIZE && stream->end_pos > 0) |
154 return stream->end_pos - stream->start_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
|
155 else |
12164 | 156 return -1; |
157 | |
24082 | 158 if(pos<0) |
159 return -1; | |
12167 | 160 if(pos<stream->end_pos && stream->eof) |
12166 | 161 stream_reset(stream); |
12164 | 162 if(stream_seek(stream, pos)==0) |
163 return -1; | |
12166 | 164 |
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
|
165 return pos - stream->start_pos; |
12164 | 166 } |
167 | |
168 static int mp_close(URLContext *h){ | |
169 return 0; | |
170 } | |
171 | |
172 static URLProtocol mp_protocol = { | |
173 "mp", | |
174 mp_open, | |
175 mp_read, | |
176 mp_write, | |
177 mp_seek, | |
178 mp_close, | |
179 }; | |
180 | |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
181 static void list_formats(void) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
182 AVInputFormat *fmt; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
183 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
|
184 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
|
185 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
|
186 } |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
187 |
16175 | 188 static int lavf_check_file(demuxer_t *demuxer){ |
12164 | 189 AVProbeData avpd; |
190 uint8_t buf[PROBE_BUF_SIZE]; | |
191 lavf_priv_t *priv; | |
192 | |
193 if(!demuxer->priv) | |
194 demuxer->priv=calloc(sizeof(lavf_priv_t),1); | |
195 priv= demuxer->priv; | |
196 | |
197 av_register_all(); | |
198 | |
15819 | 199 if(stream_read(demuxer->stream, buf, PROBE_BUF_SIZE)!=PROBE_BUF_SIZE) |
200 return 0; | |
12164 | 201 avpd.filename= demuxer->stream->url; |
202 avpd.buf= buf; | |
203 avpd.buf_size= PROBE_BUF_SIZE; | |
204 | |
22150
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
205 if (opt_format) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
206 if (strcmp(opt_format, "help") == 0) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
207 list_formats(); |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
208 return 0; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
209 } |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
210 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
|
211 if (!priv->avif) { |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
212 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
|
213 return 0; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
214 } |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
215 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
|
216 return DEMUXER_TYPE_LAVF; |
6d50b08a8bcd
Support selecting a specific lavf demuxer and listing available ones via -lavfdopts
reimar
parents:
22058
diff
changeset
|
217 } |
12164 | 218 priv->avif= av_probe_input_format(&avpd, 1); |
219 if(!priv->avif){ | |
220 mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: no clue about this gibberish!\n"); | |
221 return 0; | |
222 }else | |
223 mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: %s\n", priv->avif->long_name); | |
224 | |
16175 | 225 return DEMUXER_TYPE_LAVF; |
12164 | 226 } |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
227 |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
228 static const char *preferred_list[] = { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
229 "dxa", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
230 "wv", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
231 "nuv", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
232 "nut", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
233 "gxf", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
234 "mxf", |
22972
46593cc4aeba
Use lavf_preferred mechanism to replace more extension-based detection hacks
reimar
parents:
22971
diff
changeset
|
235 "flv", |
46593cc4aeba
Use lavf_preferred mechanism to replace more extension-based detection hacks
reimar
parents:
22971
diff
changeset
|
236 "swf", |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
237 NULL |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
238 }; |
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 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
|
241 if (lavf_check_file(demuxer)) { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
242 char **p = preferred_list; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
243 lavf_priv_t *priv = demuxer->priv; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
244 while (*p) { |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
245 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
|
246 return DEMUXER_TYPE_LAVF_PREFERRED; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
247 p++; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
248 } |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
249 } |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
250 return 0; |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
251 } |
12164 | 252 |
16175 | 253 static demuxer_t* demux_open_lavf(demuxer_t *demuxer){ |
12164 | 254 AVFormatContext *avfc; |
255 AVFormatParameters ap; | |
24633 | 256 const AVOption *opt; |
12164 | 257 lavf_priv_t *priv= demuxer->priv; |
15011 | 258 int i,g; |
12164 | 259 char mp_filename[256]="mp:"; |
260 | |
261 memset(&ap, 0, sizeof(AVFormatParameters)); | |
262 | |
263 stream_seek(demuxer->stream, 0); | |
264 | |
265 register_protocol(&mp_protocol); | |
266 | |
19598 | 267 avfc = av_alloc_format_context(); |
21548 | 268 |
269 if (correct_pts) | |
270 avfc->flags |= AVFMT_FLAG_GENPTS; | |
21568 | 271 if (index_mode == 0) |
272 avfc->flags |= AVFMT_FLAG_IGNIDX; | |
21548 | 273 |
19598 | 274 ap.prealloced_context = 1; |
275 if(opt_probesize) { | |
24634 | 276 opt = av_set_int(avfc, "probesize", opt_probesize); |
277 if(!opt) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option probesize to %u\n", opt_probesize); | |
19598 | 278 } |
24635 | 279 if(opt_analyzeduration) { |
280 opt = av_set_int(avfc, "analyzeduration", opt_analyzeduration * AV_TIME_BASE); | |
281 if(!opt) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option analyzeduration to %u\n", opt_analyzeduration); | |
282 } | |
19598 | 283 |
12463 | 284 if(demuxer->stream->url) |
285 strncpy(mp_filename + 3, demuxer->stream->url, sizeof(mp_filename)-3); | |
286 else | |
287 strncpy(mp_filename + 3, "foobar.dummy", sizeof(mp_filename)-3); | |
12164 | 288 |
289 url_fopen(&priv->pb, mp_filename, URL_RDONLY); | |
290 | |
291 ((URLContext*)(priv->pb.opaque))->priv_data= demuxer->stream; | |
292 | |
293 if(av_open_input_stream(&avfc, &priv->pb, mp_filename, priv->avif, &ap)<0){ | |
294 mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_open_input_stream() failed\n"); | |
16175 | 295 return NULL; |
12164 | 296 } |
297 | |
298 priv->avfc= avfc; | |
299 | |
300 if(av_find_stream_info(avfc) < 0){ | |
301 mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_find_stream_info() failed\n"); | |
16175 | 302 return NULL; |
12164 | 303 } |
304 | |
12167 | 305 if(avfc->title [0]) demux_info_add(demuxer, "name" , avfc->title ); |
306 if(avfc->author [0]) demux_info_add(demuxer, "author" , avfc->author ); | |
307 if(avfc->copyright[0]) demux_info_add(demuxer, "copyright", avfc->copyright); | |
308 if(avfc->comment [0]) demux_info_add(demuxer, "comments" , avfc->comment ); | |
309 if(avfc->album [0]) demux_info_add(demuxer, "album" , avfc->album ); | |
310 // if(avfc->year ) demux_info_add(demuxer, "year" , avfc->year ); | |
311 // if(avfc->track ) demux_info_add(demuxer, "track" , avfc->track ); | |
312 if(avfc->genre [0]) demux_info_add(demuxer, "genre" , avfc->genre ); | |
12164 | 313 |
314 for(i=0; i<avfc->nb_streams; i++){ | |
315 AVStream *st= avfc->streams[i]; | |
16000 | 316 AVCodecContext *codec= st->codec; |
19073
8b52dad54b1d
Remove #if LIBAVCODEC_BUILD >= XXX and #if LIBAVFORMAT_BUILD >= XXX jungle.
diego
parents:
19062
diff
changeset
|
317 |
12164 | 318 switch(codec->codec_type){ |
319 case CODEC_TYPE_AUDIO:{ | |
320 WAVEFORMATEX *wf= calloc(sizeof(WAVEFORMATEX) + codec->extradata_size, 1); | |
18985 | 321 sh_audio_t* sh_audio; |
18762 | 322 if(priv->audio_streams >= MAX_A_STREAMS) |
323 break; | |
18985 | 324 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
|
325 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "lavf", i); |
18762 | 326 if(!sh_audio) |
327 break; | |
328 priv->astreams[priv->audio_streams] = i; | |
12164 | 329 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
|
330 // 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
|
331 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
|
332 codec->codec_tag= 0; |
24674
f6cf2c01315d
Format 0x01 cannot be used with "AMV IMA ADPCM", because it belongs to normal PCM.
voroshil
parents:
24653
diff
changeset
|
333 if(codec->codec_id == CODEC_ID_ADPCM_IMA_AMV) |
f6cf2c01315d
Format 0x01 cannot be used with "AMV IMA ADPCM", because it belongs to normal PCM.
voroshil
parents:
24653
diff
changeset
|
334 codec->codec_tag= MKTAG('A','M','V','A'); |
12164 | 335 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
|
336 codec->codec_tag= av_codec_get_tag(mp_wav_taglists, codec->codec_id); |
12164 | 337 wf->wFormatTag= codec->codec_tag; |
338 wf->nChannels= codec->channels; | |
339 wf->nSamplesPerSec= codec->sample_rate; | |
340 wf->nAvgBytesPerSec= codec->bit_rate/8; | |
22266 | 341 wf->nBlockAlign= codec->block_align ? codec->block_align : 1; |
12164 | 342 wf->wBitsPerSample= codec->bits_per_sample; |
343 wf->cbSize= codec->extradata_size; | |
344 if(codec->extradata_size){ | |
345 memcpy( | |
346 wf + 1, | |
347 codec->extradata, | |
348 codec->extradata_size); | |
349 } | |
350 sh_audio->wf= wf; | |
15011 | 351 sh_audio->audio.dwSampleSize= codec->block_align; |
352 if(codec->frame_size && codec->sample_rate){ | |
353 sh_audio->audio.dwScale=codec->frame_size; | |
354 sh_audio->audio.dwRate= codec->sample_rate; | |
355 }else{ | |
356 sh_audio->audio.dwScale= codec->block_align ? codec->block_align*8 : 8; | |
357 sh_audio->audio.dwRate = codec->bit_rate; | |
358 } | |
359 g= ff_gcd(sh_audio->audio.dwScale, sh_audio->audio.dwRate); | |
360 sh_audio->audio.dwScale /= g; | |
361 sh_audio->audio.dwRate /= g; | |
362 // 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 | 363 sh_audio->ds= demuxer->audio; |
364 sh_audio->format= codec->codec_tag; | |
365 sh_audio->channels= codec->channels; | |
366 sh_audio->samplerate= codec->sample_rate; | |
15007 | 367 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
|
368 switch (codec->codec_id) { |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
369 case CODEC_ID_PCM_S8: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
370 case CODEC_ID_PCM_U8: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
371 sh_audio->samplesize = 1; |
16135 | 372 break; |
16134
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
373 case CODEC_ID_PCM_S16LE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
374 case CODEC_ID_PCM_S16BE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
375 case CODEC_ID_PCM_U16LE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
376 case CODEC_ID_PCM_U16BE: |
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
377 sh_audio->samplesize = 2; |
16135 | 378 break; |
379 case CODEC_ID_PCM_ALAW: | |
380 sh_audio->format = 0x6; | |
381 break; | |
382 case CODEC_ID_PCM_MULAW: | |
383 sh_audio->format = 0x7; | |
384 break; | |
16134
a1fd1a7eeb35
lavf demuxer with raw PCM fix (and a related hang)
reimar
parents:
16000
diff
changeset
|
385 } |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
386 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_wave_header(sh_audio->wf, MSGL_V); |
18775 | 387 if((audio_lang && st->language[0] && !strncmp(audio_lang, st->language, 3)) |
388 || (demuxer->audio->id == i || demuxer->audio->id == -1) | |
389 ) { | |
390 demuxer->audio->id = i; | |
391 demuxer->audio->sh= demuxer->a_streams[i]; | |
392 } | |
393 else | |
15004 | 394 st->discard= AVDISCARD_ALL; |
12164 | 395 break;} |
396 case CODEC_TYPE_VIDEO:{ | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
397 sh_video_t* sh_video; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
398 BITMAPINFOHEADER *bih; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
399 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
|
400 break; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
401 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
|
402 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
|
403 if(!sh_video) break; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
404 priv->vstreams[priv->video_streams] = i; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
405 priv->video_streams++; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
406 bih=calloc(sizeof(BITMAPINFOHEADER) + codec->extradata_size,1); |
12164 | 407 |
408 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
|
409 codec->codec_tag= av_codec_get_tag(mp_bmp_taglists, codec->codec_id); |
12164 | 410 bih->biSize= sizeof(BITMAPINFOHEADER) + codec->extradata_size; |
411 bih->biWidth= codec->width; | |
412 bih->biHeight= codec->height; | |
413 bih->biBitCount= codec->bits_per_sample; | |
414 bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8; | |
415 bih->biCompression= codec->codec_tag; | |
416 sh_video->bih= bih; | |
417 sh_video->disp_w= codec->width; | |
418 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
|
419 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
|
420 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
|
421 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
|
422 } else { |
15308 | 423 sh_video->video.dwRate= codec->time_base.den; |
424 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
|
425 } |
17556 | 426 sh_video->fps=av_q2d(st->r_frame_rate); |
427 sh_video->frametime=1/av_q2d(st->r_frame_rate); | |
12164 | 428 sh_video->format = bih->biCompression; |
12167 | 429 sh_video->aspect= codec->width * codec->sample_aspect_ratio.num |
430 / (float)(codec->height * codec->sample_aspect_ratio.den); | |
15007 | 431 sh_video->i_bps= codec->bit_rate/8; |
12167 | 432 mp_msg(MSGT_DEMUX,MSGL_DBG2,"aspect= %d*%d/(%d*%d)\n", |
433 codec->width, codec->sample_aspect_ratio.num, | |
434 codec->height, codec->sample_aspect_ratio.den); | |
435 | |
12164 | 436 sh_video->ds= demuxer->video; |
437 if(codec->extradata_size) | |
438 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
|
439 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_video->bih, MSGL_V); |
12164 | 440 /* short biPlanes; |
441 int biXPelsPerMeter; | |
442 int biYPelsPerMeter; | |
443 int biClrUsed; | |
444 int biClrImportant;*/ | |
15004 | 445 if(demuxer->video->id != i && demuxer->video->id != -1) |
446 st->discard= AVDISCARD_ALL; | |
447 else{ | |
448 demuxer->video->id = i; | |
449 demuxer->video->sh= demuxer->v_streams[i]; | |
450 } | |
12164 | 451 break;} |
23758 | 452 case CODEC_TYPE_SUBTITLE:{ |
453 sh_sub_t* sh_sub; | |
454 if(priv->sub_streams >= MAX_S_STREAMS) | |
455 break; | |
456 /* only support text subtitles for now */ | |
457 if(codec->codec_id != CODEC_ID_TEXT) | |
458 break; | |
459 sh_sub = new_sh_sub_sid(demuxer, i, priv->sub_streams); | |
460 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_SubtitleID, "lavf", priv->sub_streams); | |
461 if(!sh_sub) break; | |
462 priv->sstreams[priv->sub_streams] = i; | |
463 sh_sub->type = 't'; | |
464 demuxer->sub->sh = demuxer->s_streams[priv->sub_streams++]; | |
465 break;} | |
15004 | 466 default: |
467 st->discard= AVDISCARD_ALL; | |
12164 | 468 } |
469 } | |
470 | |
471 mp_msg(MSGT_HEADER,MSGL_V,"LAVF: %d audio and %d video streams found\n",priv->audio_streams,priv->video_streams); | |
13749 | 472 mp_msg(MSGT_HEADER,MSGL_V,"LAVF: build %d\n", LIBAVFORMAT_BUILD); |
12164 | 473 if(!priv->audio_streams) demuxer->audio->id=-2; // nosound |
474 // else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio; | |
475 if(!priv->video_streams){ | |
476 if(!priv->audio_streams){ | |
477 mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF: no audio or video headers found - broken file?\n"); | |
16175 | 478 return NULL; |
12164 | 479 } |
480 demuxer->video->id=-2; // audio-only | |
481 } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video; | |
482 | |
16175 | 483 return demuxer; |
12164 | 484 } |
485 | |
16175 | 486 static int demux_lavf_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){ |
12164 | 487 lavf_priv_t *priv= demux->priv; |
488 AVPacket pkt; | |
489 demux_packet_t *dp; | |
490 demux_stream_t *ds; | |
491 int id; | |
492 mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_lavf_fill_buffer()\n"); | |
493 | |
494 demux->filepos=stream_tell(demux->stream); | |
495 | |
496 if(av_read_frame(priv->avfc, &pkt) < 0) | |
497 return 0; | |
498 | |
499 id= pkt.stream_index; | |
500 | |
501 if(id==demux->audio->id){ | |
502 // audio | |
503 ds=demux->audio; | |
504 if(!ds->sh){ | |
505 ds->sh=demux->a_streams[id]; | |
506 mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF audio ID = %d\n",ds->id); | |
507 } | |
508 } else if(id==demux->video->id){ | |
509 // video | |
510 ds=demux->video; | |
511 if(!ds->sh){ | |
512 ds->sh=demux->v_streams[id]; | |
513 mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF video ID = %d\n",ds->id); | |
514 } | |
23758 | 515 } else if(id==demux->sub->id){ |
516 // subtitle | |
517 ds=demux->sub; | |
518 sub_utf8=1; | |
14611 | 519 } else { |
520 av_free_packet(&pkt); | |
521 return 1; | |
522 } | |
12164 | 523 |
524 if(0/*pkt.destruct == av_destruct_packet*/){ | |
525 //ok kids, dont try this at home :) | |
19062
83c3afeab35d
drops casts from void * on malloc/calloc from libmpdemux code
reynaldo
parents:
18985
diff
changeset
|
526 dp=malloc(sizeof(demux_packet_t)); |
12164 | 527 dp->len=pkt.size; |
528 dp->next=NULL; | |
529 dp->refcount=1; | |
530 dp->master=NULL; | |
531 dp->buffer=pkt.data; | |
532 pkt.destruct= NULL; | |
533 }else{ | |
534 dp=new_demux_packet(pkt.size); | |
535 memcpy(dp->buffer, pkt.data, pkt.size); | |
536 av_free_packet(&pkt); | |
537 } | |
538 | |
13747 | 539 if(pkt.pts != AV_NOPTS_VALUE){ |
15308 | 540 dp->pts=pkt.pts * av_q2d(priv->avfc->streams[id]->time_base); |
541 priv->last_pts= dp->pts * AV_TIME_BASE; | |
23758 | 542 if(pkt.duration) |
543 dp->endpts = dp->pts + pkt.duration * av_q2d(priv->avfc->streams[id]->time_base); | |
13747 | 544 } |
12164 | 545 dp->pos=demux->filepos; |
546 dp->flags= !!(pkt.flags&PKT_FLAG_KEY); | |
547 // append packet to DS stream: | |
548 ds_add_packet(ds,dp); | |
549 return 1; | |
550 } | |
551 | |
17636 | 552 static void demux_seek_lavf(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags){ |
12168 | 553 lavf_priv_t *priv = demuxer->priv; |
20070 | 554 int avsflags = 0; |
17636 | 555 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
|
556 |
20070 | 557 if (flags & 1) // absolute seek |
558 priv->last_pts = priv->avfc->start_time; | |
559 if (flags & 2) { // percent seek | |
560 if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE) | |
561 return; | |
562 priv->last_pts += rel_seek_secs * priv->avfc->duration; | |
563 } else { | |
564 priv->last_pts += rel_seek_secs * AV_TIME_BASE; | |
565 if (rel_seek_secs < 0) avsflags = AVSEEK_FLAG_BACKWARD; | |
566 } | |
567 av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags); | |
12164 | 568 } |
569 | |
16175 | 570 static int demux_lavf_control(demuxer_t *demuxer, int cmd, void *arg) |
12164 | 571 { |
572 lavf_priv_t *priv = demuxer->priv; | |
573 | |
574 switch (cmd) { | |
12168 | 575 case DEMUXER_CTRL_GET_TIME_LENGTH: |
19207
c636a4e9565a
Do not treat AV_NOPTS_VALUE as a valid duration value.
reimar
parents:
19160
diff
changeset
|
576 if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE) |
12164 | 577 return DEMUXER_CTRL_DONTKNOW; |
578 | |
16346
6ff303d2876b
Make -identify's 'ID_LENGTH=' print a float and not an integer.. The
ods15
parents:
16175
diff
changeset
|
579 *((double *)arg) = (double)priv->avfc->duration / AV_TIME_BASE; |
12164 | 580 return DEMUXER_CTRL_OK; |
581 | |
582 case DEMUXER_CTRL_GET_PERCENT_POS: | |
19207
c636a4e9565a
Do not treat AV_NOPTS_VALUE as a valid duration value.
reimar
parents:
19160
diff
changeset
|
583 if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE) |
12164 | 584 return DEMUXER_CTRL_DONTKNOW; |
585 | |
19160
ccb42ce33c23
Take start time into consideration when calculation percentage position
reimar
parents:
19073
diff
changeset
|
586 *((int *)arg) = (int)((priv->last_pts - priv->avfc->start_time)*100 / priv->avfc->duration); |
12168 | 587 return DEMUXER_CTRL_OK; |
18762 | 588 case DEMUXER_CTRL_SWITCH_AUDIO: |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
589 case DEMUXER_CTRL_SWITCH_VIDEO: |
18762 | 590 { |
591 int id = *((int*)arg); | |
592 int newid = -2; | |
593 int i, curridx = -2; | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
594 int nstreams, *pstreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
595 demux_stream_t *ds; |
18762 | 596 |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
597 if(cmd == DEMUXER_CTRL_SWITCH_VIDEO) |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
598 { |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
599 ds = demuxer->video; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
600 nstreams = priv->video_streams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
601 pstreams = priv->vstreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
602 } |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
603 else |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
604 { |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
605 ds = demuxer->audio; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
606 nstreams = priv->audio_streams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
607 pstreams = priv->astreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
608 } |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
609 if(ds->id == -2) |
18762 | 610 return DEMUXER_CTRL_NOTIMPL; |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
611 for(i = 0; i < nstreams; i++) |
18762 | 612 { |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
613 if(pstreams[i] == ds->id) //current stream id |
18762 | 614 { |
615 curridx = i; | |
616 break; | |
617 } | |
618 } | |
619 | |
620 if(id < 0) | |
621 { | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
622 i = (curridx + 1) % nstreams; |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
623 newid = pstreams[i]; |
18762 | 624 } |
625 else | |
626 { | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
627 for(i = 0; i < nstreams; i++) |
18762 | 628 { |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
629 if(pstreams[i] == id) |
18762 | 630 { |
631 newid = id; | |
632 break; | |
633 } | |
634 } | |
635 } | |
636 if(newid == -2 || i == curridx) | |
637 return DEMUXER_CTRL_NOTIMPL; | |
638 else | |
639 { | |
21100
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
640 ds_free_packs(ds); |
6bc989360c8b
check we aren't short of sh_videos before allocating another one
nicodvb
parents:
20990
diff
changeset
|
641 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
|
642 *((int*)arg) = ds->id = newid; |
18762 | 643 priv->avfc->streams[newid]->discard = AVDISCARD_NONE; |
644 return DEMUXER_CTRL_OK; | |
645 } | |
646 } | |
12164 | 647 default: |
648 return DEMUXER_CTRL_NOTIMPL; | |
649 } | |
650 } | |
651 | |
23758 | 652 /** \brief Get the language code for a subtitle track. |
653 | |
654 Retrieves the language code for a subtitle track. | |
655 | |
656 \param demuxer The demuxer to work on | |
657 \param track_num The subtitle track number to get the language from | |
658 */ | |
659 char *demux_lavf_sub_lang(demuxer_t *demuxer, int track_num) | |
660 { | |
661 lavf_priv_t *priv = demuxer->priv; | |
662 return priv->avfc->streams[priv->sstreams[track_num]]->language; | |
663 } | |
664 | |
16175 | 665 static void demux_close_lavf(demuxer_t *demuxer) |
12164 | 666 { |
667 lavf_priv_t* priv = demuxer->priv; | |
668 if (priv){ | |
12304
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
669 if(priv->avfc) |
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
670 { |
434242b0706c
fix possible segfault on lavf demuxer patch by (adland <adland123 at yahoo dot com>)
michael
parents:
12168
diff
changeset
|
671 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
|
672 } |
12164 | 673 free(priv); demuxer->priv= NULL; |
674 } | |
675 } | |
676 | |
16175 | 677 |
678 demuxer_desc_t demuxer_desc_lavf = { | |
679 "libavformat demuxer", | |
680 "lavf", | |
681 "libavformat", | |
682 "Michael Niedermayer", | |
683 "supports many formats, requires libavformat", | |
684 DEMUXER_TYPE_LAVF, | |
685 0, // Check after other demuxer | |
686 lavf_check_file, | |
687 demux_lavf_fill_buffer, | |
688 demux_open_lavf, | |
689 demux_close_lavf, | |
690 demux_seek_lavf, | |
691 demux_lavf_control | |
692 }; | |
693 | |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
694 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
|
695 "libavformat preferred demuxer", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
696 "lavfpref", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
697 "libavformat", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
698 "Michael Niedermayer", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
699 "supports many formats, requires libavformat", |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
700 DEMUXER_TYPE_LAVF_PREFERRED, |
24354
ae226b882283
Mark lavfpref demuxer as safe, so it that it is actually used for e.g.
reimar
parents:
24085
diff
changeset
|
701 1, |
22971
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
702 lavf_check_preferred_file, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
703 demux_lavf_fill_buffer, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
704 demux_open_lavf, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
705 demux_close_lavf, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
706 demux_seek_lavf, |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
707 demux_lavf_control |
a1b2fbb000fc
Add lavf_preferred demuxer for lavf formats we want to be probed
reimar
parents:
22918
diff
changeset
|
708 }; |