1/* 2 * WavPack demuxer 3 * Copyright (c) 2006,2011 Konstantin Shishkov 4 * 5 * This file is part of FFmpeg. 6 * 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. 11 * 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. 16 * 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 20 */ 21 22#include "libavutil/channel_layout.h" 23#include "libavutil/intreadwrite.h" 24#include "libavutil/dict.h" 25#include "avformat.h" 26#include "internal.h" 27#include "apetag.h" 28#include "id3v1.h" 29#include "wv.h" 30 31enum WV_FLAGS { 32 WV_MONO = 0x0004, 33 WV_HYBRID = 0x0008, 34 WV_JOINT = 0x0010, 35 WV_CROSSD = 0x0020, 36 WV_HSHAPE = 0x0040, 37 WV_FLOAT = 0x0080, 38 WV_INT32 = 0x0100, 39 WV_HBR = 0x0200, 40 WV_HBAL = 0x0400, 41 WV_MCINIT = 0x0800, 42 WV_MCEND = 0x1000, 43 WV_DSD = 0x80000000, 44}; 45 46static const int wv_rates[16] = { 47 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, 48 32000, 44100, 48000, 64000, 88200, 96000, 192000, -1 49}; 50 51typedef struct WVContext { 52 uint8_t block_header[WV_HEADER_SIZE]; 53 WvHeader header; 54 int rate, chan, bpp; 55 uint32_t chmask; 56 int multichannel; 57 int block_parsed; 58 int64_t pos; 59 60 int64_t apetag_start; 61} WVContext; 62 63static int wv_probe(const AVProbeData *p) 64{ 65 /* check file header */ 66 if (p->buf_size <= 32) 67 return 0; 68 if (AV_RL32(&p->buf[0]) == MKTAG('w', 'v', 'p', 'k') && 69 AV_RL32(&p->buf[4]) >= 24 && 70 AV_RL32(&p->buf[4]) <= WV_BLOCK_LIMIT && 71 AV_RL16(&p->buf[8]) >= 0x402 && 72 AV_RL16(&p->buf[8]) <= 0x410) 73 return AVPROBE_SCORE_MAX; 74 else 75 return 0; 76} 77 78static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb) 79{ 80 WVContext *wc = ctx->priv_data; 81 int ret; 82 int rate, bpp, chan; 83 uint32_t chmask, flags; 84 unsigned rate_x; 85 86 wc->pos = avio_tell(pb); 87 88 /* don't return bogus packets with the ape tag data */ 89 if (wc->apetag_start && wc->pos >= wc->apetag_start) 90 return AVERROR_EOF; 91 92 ret = avio_read(pb, wc->block_header, WV_HEADER_SIZE); 93 if (ret != WV_HEADER_SIZE) 94 return (ret < 0) ? ret : AVERROR_EOF; 95 96 ret = ff_wv_parse_header(&wc->header, wc->block_header); 97 if (ret < 0) { 98 av_log(ctx, AV_LOG_ERROR, "Invalid block header.\n"); 99 return ret; 100 } 101 102 if (wc->header.version < 0x402 || wc->header.version > 0x410) { 103 avpriv_report_missing_feature(ctx, "WV version 0x%03X", 104 wc->header.version); 105 return AVERROR_PATCHWELCOME; 106 } 107 108 /* Blocks with zero samples don't contain actual audio information 109 * and should be ignored */ 110 if (!wc->header.samples) 111 return 0; 112 // parse flags 113 flags = wc->header.flags; 114 rate_x = (flags & WV_DSD) ? 4 : 1; 115 bpp = (flags & WV_DSD) ? 0 : ((flags & 3) + 1) << 3; 116 chan = 1 + !(flags & WV_MONO); 117 chmask = flags & WV_MONO ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO; 118 rate = wv_rates[(flags >> 23) & 0xF]; 119 wc->multichannel = !(wc->header.initial && wc->header.final); 120 if (wc->multichannel) { 121 chan = wc->chan; 122 chmask = wc->chmask; 123 } 124 if ((rate == -1 || !chan || flags & WV_DSD) && !wc->block_parsed) { 125 int64_t block_end = avio_tell(pb) + wc->header.blocksize; 126 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) { 127 av_log(ctx, AV_LOG_ERROR, 128 "Cannot determine additional parameters\n"); 129 return AVERROR_INVALIDDATA; 130 } 131 while (avio_tell(pb) < block_end && !avio_feof(pb)) { 132 int id, size; 133 id = avio_r8(pb); 134 size = (id & 0x80) ? avio_rl24(pb) : avio_r8(pb); 135 size <<= 1; 136 if (id & 0x40) 137 size--; 138 switch (id & 0x3F) { 139 case 0xD: 140 if (size <= 1) { 141 av_log(ctx, AV_LOG_ERROR, 142 "Insufficient channel information\n"); 143 return AVERROR_INVALIDDATA; 144 } 145 chan = avio_r8(pb); 146 switch (size - 2) { 147 case 0: 148 chmask = avio_r8(pb); 149 break; 150 case 1: 151 chmask = avio_rl16(pb); 152 break; 153 case 2: 154 chmask = avio_rl24(pb); 155 break; 156 case 3: 157 chmask = avio_rl32(pb); 158 break; 159 case 4: 160 avio_skip(pb, 1); 161 chan |= (avio_r8(pb) & 0xF) << 8; 162 chan += 1; 163 chmask = avio_rl24(pb); 164 break; 165 case 5: 166 avio_skip(pb, 1); 167 chan |= (avio_r8(pb) & 0xF) << 8; 168 chan += 1; 169 chmask = avio_rl32(pb); 170 break; 171 default: 172 av_log(ctx, AV_LOG_ERROR, 173 "Invalid channel info size %d\n", size); 174 return AVERROR_INVALIDDATA; 175 } 176 break; 177 case 0xE: 178 if (size <= 1) { 179 av_log(ctx, AV_LOG_ERROR, 180 "Invalid DSD block\n"); 181 return AVERROR_INVALIDDATA; 182 } 183 rate_x = 1U << (avio_r8(pb) & 0x1f); 184 if (size) 185 avio_skip(pb, size-1); 186 break; 187 case 0x27: 188 rate = avio_rl24(pb); 189 break; 190 default: 191 avio_skip(pb, size); 192 } 193 if (id & 0x40) 194 avio_skip(pb, 1); 195 } 196 if (rate == -1 || rate * (uint64_t)rate_x >= INT_MAX) { 197 av_log(ctx, AV_LOG_ERROR, 198 "Cannot determine custom sampling rate\n"); 199 return AVERROR_INVALIDDATA; 200 } 201 avio_seek(pb, block_end - wc->header.blocksize, SEEK_SET); 202 } 203 if (!wc->bpp) 204 wc->bpp = bpp; 205 if (!wc->chan) 206 wc->chan = chan; 207 if (!wc->chmask) 208 wc->chmask = chmask; 209 if (!wc->rate) 210 wc->rate = rate * rate_x; 211 212 if (flags && bpp != wc->bpp) { 213 av_log(ctx, AV_LOG_ERROR, 214 "Bits per sample differ, this block: %i, header block: %i\n", 215 bpp, wc->bpp); 216 return AVERROR_INVALIDDATA; 217 } 218 if (flags && !wc->multichannel && chan != wc->chan) { 219 av_log(ctx, AV_LOG_ERROR, 220 "Channels differ, this block: %i, header block: %i\n", 221 chan, wc->chan); 222 return AVERROR_INVALIDDATA; 223 } 224 if (flags && rate != -1 && !(flags & WV_DSD) && rate * rate_x != wc->rate) { 225 av_log(ctx, AV_LOG_ERROR, 226 "Sampling rate differ, this block: %i, header block: %i\n", 227 rate * rate_x, wc->rate); 228 return AVERROR_INVALIDDATA; 229 } 230 return 0; 231} 232 233static int wv_read_header(AVFormatContext *s) 234{ 235 AVIOContext *pb = s->pb; 236 WVContext *wc = s->priv_data; 237 AVStream *st; 238 int ret; 239 240 wc->block_parsed = 0; 241 for (;;) { 242 if ((ret = wv_read_block_header(s, pb)) < 0) 243 return ret; 244 if (!wc->header.samples) 245 avio_skip(pb, wc->header.blocksize); 246 else 247 break; 248 } 249 250 /* now we are ready: build format streams */ 251 st = avformat_new_stream(s, NULL); 252 if (!st) 253 return AVERROR(ENOMEM); 254 if ((ret = ff_alloc_extradata(st->codecpar, 2)) < 0) 255 return ret; 256 AV_WL16(st->codecpar->extradata, wc->header.version); 257 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; 258 st->codecpar->codec_id = AV_CODEC_ID_WAVPACK; 259 av_channel_layout_from_mask(&st->codecpar->ch_layout, wc->chmask); 260 st->codecpar->sample_rate = wc->rate; 261 st->codecpar->bits_per_coded_sample = wc->bpp; 262 avpriv_set_pts_info(st, 64, 1, wc->rate); 263 st->start_time = 0; 264 if (wc->header.total_samples != 0xFFFFFFFFu) 265 st->duration = wc->header.total_samples; 266 267 if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) { 268 int64_t cur = avio_tell(s->pb); 269 wc->apetag_start = ff_ape_parse_tag(s); 270 if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) 271 ff_id3v1_read(s); 272 avio_seek(s->pb, cur, SEEK_SET); 273 } 274 275 return 0; 276} 277 278static int wv_read_packet(AVFormatContext *s, AVPacket *pkt) 279{ 280 WVContext *wc = s->priv_data; 281 int ret; 282 int off; 283 int64_t pos; 284 uint32_t block_samples; 285 286 if (avio_feof(s->pb)) 287 return AVERROR_EOF; 288 if (wc->block_parsed) { 289 if ((ret = wv_read_block_header(s, s->pb)) < 0) 290 return ret; 291 } 292 293 pos = wc->pos; 294 if ((ret = av_new_packet(pkt, wc->header.blocksize + WV_HEADER_SIZE)) < 0) 295 return ret; 296 memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE); 297 ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->header.blocksize); 298 if (ret != wc->header.blocksize) { 299 return AVERROR(EIO); 300 } 301 while (!(wc->header.flags & WV_FLAG_FINAL_BLOCK)) { 302 if ((ret = wv_read_block_header(s, s->pb)) < 0) { 303 return ret; 304 } 305 306 off = pkt->size; 307 if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->header.blocksize)) < 0) { 308 return ret; 309 } 310 memcpy(pkt->data + off, wc->block_header, WV_HEADER_SIZE); 311 312 ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->header.blocksize); 313 if (ret != wc->header.blocksize) { 314 return (ret < 0) ? ret : AVERROR_EOF; 315 } 316 } 317 pkt->stream_index = 0; 318 pkt->pos = pos; 319 wc->block_parsed = 1; 320 pkt->pts = wc->header.block_idx; 321 block_samples = wc->header.samples; 322 if (block_samples > INT32_MAX) 323 av_log(s, AV_LOG_WARNING, 324 "Too many samples in block: %"PRIu32"\n", block_samples); 325 else 326 pkt->duration = block_samples; 327 328 return 0; 329} 330 331const AVInputFormat ff_wv_demuxer = { 332 .name = "wv", 333 .long_name = NULL_IF_CONFIG_SMALL("WavPack"), 334 .priv_data_size = sizeof(WVContext), 335 .read_probe = wv_probe, 336 .read_header = wv_read_header, 337 .read_packet = wv_read_packet, 338 .flags = AVFMT_GENERIC_INDEX, 339}; 340