--- /dev/null
+/*
+ * WavPack shared functions
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "libavutil/common.h"
+#include "libavutil/intreadwrite.h"
+
+#include "wv.h"
+
+int ff_wv_parse_header(WvHeader *wv, const uint8_t *data)
+{
+ memset(wv, 0, sizeof(*wv));
+
+ if (AV_RL32(data) != MKTAG('w', 'v', 'p', 'k'))
+ return AVERROR_INVALIDDATA;
+
+ wv->blocksize = AV_RL32(data + 4);
+ if (wv->blocksize < 24 || wv->blocksize > WV_BLOCK_LIMIT)
+ return AVERROR_INVALIDDATA;
+ wv->blocksize -= 24;
+
+ wv->version = AV_RL16(data + 8);
+ wv->total_samples = AV_RL32(data + 12);
+ wv->block_idx = AV_RL32(data + 16);
+ wv->samples = AV_RL32(data + 20);
+ wv->flags = AV_RL32(data + 24);
+ wv->crc = AV_RL32(data + 28);
+
+ wv->initial = !!(wv->flags & WV_FLAG_INITIAL_BLOCK);
+ wv->final = !!(wv->flags & WV_FLAG_FINAL_BLOCK);
+
+ return 0;
+}
--- /dev/null
+/*
+ * WavPack shared functions
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFORMAT_WV_H
+#define AVFORMAT_WV_H
+
+#include <stdint.h>
+
+#define WV_HEADER_SIZE 32
+
+#define WV_FLAG_INITIAL_BLOCK (1 << 11)
+#define WV_FLAG_FINAL_BLOCK (1 << 12)
+
+// specs say that maximum block size is 1Mb
+#define WV_BLOCK_LIMIT 1048576
+
+typedef struct WvHeader {
+ uint32_t blocksize; //< size of the block data (excluding the header)
+ uint16_t version; //< bitstream version
+ uint32_t total_samples; //< total number of samples in the stream
+ uint32_t block_idx; //< index of the first sample in this block
+ uint32_t samples; //< number of samples in this block
+ uint32_t flags;
+ uint32_t crc;
+
+ int initial, final;
+} WvHeader;
+
+/**
+ * Parse a WavPack block header.
+ *
+ * @param wv this struct will be filled with parse header information
+ * @param data header data, must be WV_HEADER_SIZE bytes long
+ *
+ * @return 0 on success, a negative AVERROR code on failure
+ */
+int ff_wv_parse_header(WvHeader *wv, const uint8_t *data);
+
+#endif /* AVFORMAT_WV_H */
#include "internal.h"
#include "apetag.h"
#include "id3v1.h"
-
-// specs say that maximum block size is 1Mb
-#define WV_BLOCK_LIMIT 1047576
-
-#define WV_HEADER_SIZE 32
-
-#define WV_START_BLOCK 0x0800
-#define WV_END_BLOCK 0x1000
-#define WV_SINGLE_BLOCK (WV_START_BLOCK | WV_END_BLOCK)
+#include "wv.h"
enum WV_FLAGS {
WV_MONO = 0x0004,
typedef struct {
uint8_t block_header[WV_HEADER_SIZE];
- uint32_t blksize, flags;
+ WvHeader header;
int rate, chan, bpp;
uint32_t chmask;
- uint32_t samples, soff;
int multichannel;
int block_parsed;
int64_t pos;
static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb)
{
WVContext *wc = ctx->priv_data;
- uint32_t ver;
- int size, ret;
+ int ret;
int rate, bpp, chan;
- uint32_t chmask;
+ uint32_t chmask, flags;
wc->pos = avio_tell(pb);
if (ret != WV_HEADER_SIZE)
return (ret < 0) ? ret : AVERROR_EOF;
- if (AV_RL32(wc->block_header) != MKTAG('w', 'v', 'p', 'k'))
- return AVERROR_INVALIDDATA;
-
- size = AV_RL32(wc->block_header + 4);
- if (size < 24 || size > WV_BLOCK_LIMIT) {
- av_log(ctx, AV_LOG_ERROR, "Incorrect block size %i\n", size);
- return AVERROR_INVALIDDATA;
+ ret = ff_wv_parse_header(&wc->header, wc->block_header);
+ if (ret < 0) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid block header.\n");
+ return ret;
}
- wc->blksize = size;
- ver = AV_RL32(wc->block_header + 8);
- if (ver < 0x402 || ver > 0x410) {
- av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", ver);
+
+ if (wc->header.version < 0x402 || wc->header.version > 0x410) {
+ av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", wc->header.version);
return AVERROR_PATCHWELCOME;
}
- wc->samples = AV_RL32(wc->block_header + 12); // total samples in file
- wc->soff = AV_RL32(wc->block_header + 16); // offset in samples of current block
- wc->flags = AV_RL32(wc->block_header + 24);
+
/* Blocks with zero samples don't contain actual audio information
* and should be ignored */
- if (!AV_RN32(wc->block_header + 20))
+ if (!wc->header.samples)
return 0;
// parse flags
- bpp = ((wc->flags & 3) + 1) << 3;
- chan = 1 + !(wc->flags & WV_MONO);
- chmask = wc->flags & WV_MONO ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
- rate = wv_rates[(wc->flags >> 23) & 0xF];
- wc->multichannel = !!((wc->flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK);
+ flags = wc->header.flags;
+ bpp = ((flags & 3) + 1) << 3;
+ chan = 1 + !(flags & WV_MONO);
+ chmask = flags & WV_MONO ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
+ rate = wv_rates[(flags >> 23) & 0xF];
+ wc->multichannel = !(wc->header.initial && wc->header.final);
if (wc->multichannel) {
chan = wc->chan;
chmask = wc->chmask;
}
if ((rate == -1 || !chan) && !wc->block_parsed) {
- int64_t block_end = avio_tell(pb) + wc->blksize - 24;
+ int64_t block_end = avio_tell(pb) + wc->header.blocksize;
if (!pb->seekable) {
av_log(ctx, AV_LOG_ERROR,
"Cannot determine additional parameters\n");
"Cannot determine custom sampling rate\n");
return AVERROR_INVALIDDATA;
}
- avio_seek(pb, block_end - wc->blksize + 24, SEEK_SET);
+ avio_seek(pb, block_end - wc->header.blocksize, SEEK_SET);
}
if (!wc->bpp)
wc->bpp = bpp;
if (!wc->rate)
wc->rate = rate;
- if (wc->flags && bpp != wc->bpp) {
+ if (flags && bpp != wc->bpp) {
av_log(ctx, AV_LOG_ERROR,
"Bits per sample differ, this block: %i, header block: %i\n",
bpp, wc->bpp);
return AVERROR_INVALIDDATA;
}
- if (wc->flags && !wc->multichannel && chan != wc->chan) {
+ if (flags && !wc->multichannel && chan != wc->chan) {
av_log(ctx, AV_LOG_ERROR,
"Channels differ, this block: %i, header block: %i\n",
chan, wc->chan);
return AVERROR_INVALIDDATA;
}
- if (wc->flags && rate != -1 && rate != wc->rate) {
+ if (flags && rate != -1 && rate != wc->rate) {
av_log(ctx, AV_LOG_ERROR,
"Sampling rate differ, this block: %i, header block: %i\n",
rate, wc->rate);
return AVERROR_INVALIDDATA;
}
- wc->blksize = size - 24;
return 0;
}
for (;;) {
if ((ret = wv_read_block_header(s, pb)) < 0)
return ret;
- if (!AV_RL32(wc->block_header + 20))
- avio_skip(pb, wc->blksize - 24);
+ if (!wc->header.samples)
+ avio_skip(pb, wc->header.blocksize);
else
break;
}
st->codec->bits_per_coded_sample = wc->bpp;
avpriv_set_pts_info(st, 64, 1, wc->rate);
st->start_time = 0;
- st->duration = wc->samples;
+ st->duration = wc->header.total_samples;
if (s->pb->seekable) {
int64_t cur = avio_tell(s->pb);
}
pos = wc->pos;
- if (av_new_packet(pkt, wc->blksize + WV_HEADER_SIZE) < 0)
+ if (av_new_packet(pkt, wc->header.blocksize + WV_HEADER_SIZE) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE);
- ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->blksize);
- if (ret != wc->blksize) {
+ ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->header.blocksize);
+ if (ret != wc->header.blocksize) {
av_free_packet(pkt);
return AVERROR(EIO);
}
- while (!(wc->flags & WV_END_BLOCK)) {
+ while (!(wc->header.flags & WV_FLAG_FINAL_BLOCK)) {
if ((ret = wv_read_block_header(s, s->pb)) < 0) {
av_free_packet(pkt);
return ret;
}
off = pkt->size;
- if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->blksize)) < 0) {
+ if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->header.blocksize)) < 0) {
av_free_packet(pkt);
return ret;
}
memcpy(pkt->data + off, wc->block_header, WV_HEADER_SIZE);
- ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->blksize);
- if (ret != wc->blksize) {
+ ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->header.blocksize);
+ if (ret != wc->header.blocksize) {
av_free_packet(pkt);
return (ret < 0) ? ret : AVERROR_EOF;
}
}
pkt->stream_index = 0;
wc->block_parsed = 1;
- pkt->pts = wc->soff;
- block_samples = AV_RL32(wc->block_header + 20);
+ pkt->pts = wc->header.block_idx;
+ block_samples = wc->header.samples;
if (block_samples > INT32_MAX)
av_log(s, AV_LOG_WARNING,
"Too many samples in block: %"PRIu32"\n", block_samples);