3 * Copyright (c) 2006,2011 Konstantin Shishkov
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/channel_layout.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/dict.h"
45 static const int wv_rates
[16] = {
46 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,
47 32000, 44100, 48000, 64000, 88200, 96000, 192000, -1
51 uint8_t block_header
[WV_HEADER_SIZE
];
62 static int wv_probe(AVProbeData
*p
)
64 /* check file header */
65 if (p
->buf_size
<= 32)
67 if (AV_RL32(&p
->buf
[0]) == MKTAG('w', 'v', 'p', 'k') &&
68 AV_RL32(&p
->buf
[4]) >= 24 &&
69 AV_RL32(&p
->buf
[4]) <= WV_BLOCK_LIMIT
&&
70 AV_RL16(&p
->buf
[8]) >= 0x402 &&
71 AV_RL16(&p
->buf
[8]) <= 0x410)
72 return AVPROBE_SCORE_MAX
;
77 static int wv_read_block_header(AVFormatContext
*ctx
, AVIOContext
*pb
)
79 WVContext
*wc
= ctx
->priv_data
;
82 uint32_t chmask
, flags
;
84 wc
->pos
= avio_tell(pb
);
86 /* don't return bogus packets with the ape tag data */
87 if (wc
->apetag_start
&& wc
->pos
>= wc
->apetag_start
)
90 ret
= avio_read(pb
, wc
->block_header
, WV_HEADER_SIZE
);
91 if (ret
!= WV_HEADER_SIZE
)
92 return (ret
< 0) ? ret
: AVERROR_EOF
;
94 ret
= ff_wv_parse_header(&wc
->header
, wc
->block_header
);
96 av_log(ctx
, AV_LOG_ERROR
, "Invalid block header.\n");
100 if (wc
->header
.version
< 0x402 || wc
->header
.version
> 0x410) {
101 av_log(ctx
, AV_LOG_ERROR
, "Unsupported version %03X\n", wc
->header
.version
);
102 return AVERROR_PATCHWELCOME
;
105 /* Blocks with zero samples don't contain actual audio information
106 * and should be ignored */
107 if (!wc
->header
.samples
)
110 flags
= wc
->header
.flags
;
111 bpp
= ((flags
& 3) + 1) << 3;
112 chan
= 1 + !(flags
& WV_MONO
);
113 chmask
= flags
& WV_MONO
? AV_CH_LAYOUT_MONO
: AV_CH_LAYOUT_STEREO
;
114 rate
= wv_rates
[(flags
>> 23) & 0xF];
115 wc
->multichannel
= !(wc
->header
.initial
&& wc
->header
.final
);
116 if (wc
->multichannel
) {
120 if ((rate
== -1 || !chan
) && !wc
->block_parsed
) {
121 int64_t block_end
= avio_tell(pb
) + wc
->header
.blocksize
;
123 av_log(ctx
, AV_LOG_ERROR
,
124 "Cannot determine additional parameters\n");
125 return AVERROR_INVALIDDATA
;
127 while (avio_tell(pb
) < block_end
&& !avio_feof(pb
)) {
130 size
= (id
& 0x80) ? avio_rl24(pb
) : avio_r8(pb
);
137 av_log(ctx
, AV_LOG_ERROR
,
138 "Insufficient channel information\n");
139 return AVERROR_INVALIDDATA
;
144 chmask
= avio_r8(pb
);
147 chmask
= avio_rl16(pb
);
150 chmask
= avio_rl24(pb
);
153 chmask
= avio_rl32(pb
);
157 chan
|= (avio_r8(pb
) & 0xF) << 8;
158 chmask
= avio_rl24(pb
);
161 av_log(ctx
, AV_LOG_ERROR
,
162 "Invalid channel info size %d\n", size
);
163 return AVERROR_INVALIDDATA
;
167 rate
= avio_rl24(pb
);
176 av_log(ctx
, AV_LOG_ERROR
,
177 "Cannot determine custom sampling rate\n");
178 return AVERROR_INVALIDDATA
;
180 avio_seek(pb
, block_end
- wc
->header
.blocksize
, SEEK_SET
);
191 if (flags
&& bpp
!= wc
->bpp
) {
192 av_log(ctx
, AV_LOG_ERROR
,
193 "Bits per sample differ, this block: %i, header block: %i\n",
195 return AVERROR_INVALIDDATA
;
197 if (flags
&& !wc
->multichannel
&& chan
!= wc
->chan
) {
198 av_log(ctx
, AV_LOG_ERROR
,
199 "Channels differ, this block: %i, header block: %i\n",
201 return AVERROR_INVALIDDATA
;
203 if (flags
&& rate
!= -1 && rate
!= wc
->rate
) {
204 av_log(ctx
, AV_LOG_ERROR
,
205 "Sampling rate differ, this block: %i, header block: %i\n",
207 return AVERROR_INVALIDDATA
;
212 static int wv_read_header(AVFormatContext
*s
)
214 AVIOContext
*pb
= s
->pb
;
215 WVContext
*wc
= s
->priv_data
;
219 wc
->block_parsed
= 0;
221 if ((ret
= wv_read_block_header(s
, pb
)) < 0)
223 if (!wc
->header
.samples
)
224 avio_skip(pb
, wc
->header
.blocksize
);
229 /* now we are ready: build format streams */
230 st
= avformat_new_stream(s
, NULL
);
232 return AVERROR(ENOMEM
);
233 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
234 st
->codec
->codec_id
= AV_CODEC_ID_WAVPACK
;
235 st
->codec
->channels
= wc
->chan
;
236 st
->codec
->channel_layout
= wc
->chmask
;
237 st
->codec
->sample_rate
= wc
->rate
;
238 st
->codec
->bits_per_coded_sample
= wc
->bpp
;
239 avpriv_set_pts_info(st
, 64, 1, wc
->rate
);
241 if (wc
->header
.total_samples
!= 0xFFFFFFFFu
)
242 st
->duration
= wc
->header
.total_samples
;
244 if (s
->pb
->seekable
) {
245 int64_t cur
= avio_tell(s
->pb
);
246 wc
->apetag_start
= ff_ape_parse_tag(s
);
247 if (!av_dict_get(s
->metadata
, "", NULL
, AV_DICT_IGNORE_SUFFIX
))
249 avio_seek(s
->pb
, cur
, SEEK_SET
);
255 static int wv_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
257 WVContext
*wc
= s
->priv_data
;
261 uint32_t block_samples
;
263 if (avio_feof(s
->pb
))
265 if (wc
->block_parsed
) {
266 if ((ret
= wv_read_block_header(s
, s
->pb
)) < 0)
271 if (av_new_packet(pkt
, wc
->header
.blocksize
+ WV_HEADER_SIZE
) < 0)
272 return AVERROR(ENOMEM
);
273 memcpy(pkt
->data
, wc
->block_header
, WV_HEADER_SIZE
);
274 ret
= avio_read(s
->pb
, pkt
->data
+ WV_HEADER_SIZE
, wc
->header
.blocksize
);
275 if (ret
!= wc
->header
.blocksize
) {
279 while (!(wc
->header
.flags
& WV_FLAG_FINAL_BLOCK
)) {
280 if ((ret
= wv_read_block_header(s
, s
->pb
)) < 0) {
286 if ((ret
= av_grow_packet(pkt
, WV_HEADER_SIZE
+ wc
->header
.blocksize
)) < 0) {
290 memcpy(pkt
->data
+ off
, wc
->block_header
, WV_HEADER_SIZE
);
292 ret
= avio_read(s
->pb
, pkt
->data
+ off
+ WV_HEADER_SIZE
, wc
->header
.blocksize
);
293 if (ret
!= wc
->header
.blocksize
) {
295 return (ret
< 0) ? ret
: AVERROR_EOF
;
298 pkt
->stream_index
= 0;
299 wc
->block_parsed
= 1;
300 pkt
->pts
= wc
->header
.block_idx
;
301 block_samples
= wc
->header
.samples
;
302 if (block_samples
> INT32_MAX
)
303 av_log(s
, AV_LOG_WARNING
,
304 "Too many samples in block: %"PRIu32
"\n", block_samples
);
306 pkt
->duration
= block_samples
;
308 av_add_index_entry(s
->streams
[0], pos
, pkt
->pts
, 0, 0, AVINDEX_KEYFRAME
);
312 static int wv_read_seek(AVFormatContext
*s
, int stream_index
,
313 int64_t timestamp
, int flags
)
315 AVStream
*st
= s
->streams
[stream_index
];
316 WVContext
*wc
= s
->priv_data
;
317 AVPacket pkt1
, *pkt
= &pkt1
;
319 int index
= av_index_search_timestamp(st
, timestamp
, flags
);
322 /* if found, seek there */
324 timestamp
<= st
->index_entries
[st
->nb_index_entries
- 1].timestamp
) {
325 wc
->block_parsed
= 1;
326 avio_seek(s
->pb
, st
->index_entries
[index
].pos
, SEEK_SET
);
329 /* if timestamp is out of bounds, return error */
330 if (timestamp
< 0 || timestamp
>= s
->duration
)
331 return AVERROR(EINVAL
);
333 pos
= avio_tell(s
->pb
);
335 ret
= av_read_frame(s
, pkt
);
337 avio_seek(s
->pb
, pos
, SEEK_SET
);
342 } while(pts
< timestamp
);
346 AVInputFormat ff_wv_demuxer
= {
348 .long_name
= NULL_IF_CONFIG_SMALL("WavPack"),
349 .priv_data_size
= sizeof(WVContext
),
350 .read_probe
= wv_probe
,
351 .read_header
= wv_read_header
,
352 .read_packet
= wv_read_packet
,
353 .read_seek
= wv_read_seek
,