FFmpeg: libavcodec/wavpack.c Source File

FFmpeg

[フレーム]

libavcodec

wavpack.c

Go to the documentation of this file.

1 /*

2 * WavPack lossless audio decoder

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 */

22 #define BITSTREAM_READER_LE

24 #include "libavutil/channel_layout.h"

25 #include "avcodec.h"

26 #include "get_bits.h"

27 #include "internal.h"

28 #include "thread.h"

29 #include "unary.h"

30 #include "bytestream.h"

32 /**

33 * @file

34 * WavPack lossless audio decoder

35 */

37 #define WV_HEADER_SIZE 32

39 #define WV_MONO 0x00000004

40 #define WV_JOINT_STEREO 0x00000010

41 #define WV_FALSE_STEREO 0x40000000

43 #define WV_HYBRID_MODE 0x00000008

44 #define WV_HYBRID_SHAPE 0x00000008

45 #define WV_HYBRID_BITRATE 0x00000200

46 #define WV_HYBRID_BALANCE 0x00000400

47 #define WV_INITIAL_BLOCK 0x00000800

48 #define WV_FINAL_BLOCK 0x00001000

50 #define WV_SINGLE_BLOCK (WV_INITIAL_BLOCK | WV_FINAL_BLOCK)

52 #define WV_FLT_SHIFT_ONES 0x01

53 #define WV_FLT_SHIFT_SAME 0x02

54 #define WV_FLT_SHIFT_SENT 0x04

55 #define WV_FLT_ZERO_SENT 0x08

56 #define WV_FLT_ZERO_SIGN 0x10

58 #define WV_MAX_SAMPLES 131072

60 enum WP_ID_Flags {

61 WP_IDF_MASK = 0x3F,

62 WP_IDF_IGNORE = 0x20,

63 WP_IDF_ODD = 0x40,

64 WP_IDF_LONG = 0x80

65 };

67 enum WP_ID {

68 WP_ID_DUMMY = 0,

69 WP_ID_ENCINFO,

70 WP_ID_DECTERMS,

71 WP_ID_DECWEIGHTS,

72 WP_ID_DECSAMPLES,

73 WP_ID_ENTROPY,

74 WP_ID_HYBRID,

75 WP_ID_SHAPING,

76 WP_ID_FLOATINFO,

77 WP_ID_INT32INFO,

78 WP_ID_DATA,

79 WP_ID_CORR,

80 WP_ID_EXTRABITS,

81 WP_ID_CHANINFO,

82 WP_ID_SAMPLE_RATE = 0x27,

83 };

85 typedef struct SavedContext {

86 int offset;

87 int size;

88 int bits_used;

89 uint32_t crc;

90 } SavedContext;

92 #define MAX_TERMS 16

94 typedef struct Decorr {

95 int delta;

96 int value;

97 int weightA;

98 int weightB;

99 int samplesA[8];

100 int samplesB[8];

101 } Decorr;

102

103 typedef struct WvChannel {

104 int median[3];

105 int slow_level, error_limit;

106 int bitrate_acc, bitrate_delta;

107 } WvChannel;

108

109 typedef struct WavpackFrameContext {

110 AVCodecContext *avctx;

111 int frame_flags;

112 int stereo, stereo_in;

113 int joint;

114 uint32_t CRC;

115 GetBitContext gb;

116 int got_extra_bits;

117 uint32_t crc_extra_bits;

118 GetBitContext gb_extra_bits;

119 int data_size; // in bits

120 int samples;

121 int terms;

122 Decorr decorr[MAX_TERMS];

123 int zero, one, zeroes;

124 int extra_bits;

125 int and, or, shift;

126 int post_shift;

127 int hybrid, hybrid_bitrate;

128 int hybrid_maxclip, hybrid_minclip;

129 int float_flag;

130 int float_shift;

131 int float_max_exp;

132 WvChannel ch[2];

133 int pos;

134 SavedContext sc, extra_sc;

135 } WavpackFrameContext;

136

137 #define WV_MAX_FRAME_DECODERS 14

138

139 typedef struct WavpackContext {

140 AVCodecContext *avctx;

141

142 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];

143 int fdec_num;

144

145 int block;

146 int samples;

147 int ch_offset;

148 } WavpackContext;

149

150 static const int wv_rates[16] = {

151 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,

152 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0

153 };

154

155 // exponent table copied from WavPack source

156 static const uint8_t wp_exp2_table[256] = {

157 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,

158 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,

159 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,

160 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,

161 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,

162 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,

163 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,

164 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,

165 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,

166 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,

167 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,

168 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,

169 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,

170 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,

171 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,

172 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff

173 };

174

175 static const uint8_t wp_log2_table [] = {

176 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,

177 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,

178 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,

179 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,

180 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,

181 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,

182 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,

183 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,

184 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,

185 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,

186 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,

187 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,

188 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,

189 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,

190 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,

191 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff

192 };

193

194 static av_always_inline int wp_exp2(int16_t val)

195 {

196 int res, neg = 0;

197

198 if (val < 0) {

199 val = -val;

200 neg = 1;

201 }

202

203 res = wp_exp2_table[val & 0xFF] | 0x100;

204 val >>= 8;

205 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));

206 return neg ? -res : res;

207 }

208

209 static av_always_inline int wp_log2(int32_t val)

210 {

211 int bits;

212

213 if (!val)

214 return 0;

215 if (val == 1)

216 return 256;

217 val += val >> 9;

218 bits = av_log2(val) + 1;

219 if (bits < 9)

220 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];

221 else

222 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];

223 }

224

225 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)

226

227 // macros for manipulating median values

228 #define GET_MED(n) ((c->median[n] >> 4) + 1)

229 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2

230 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5

231

232 // macros for applying weight

233 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \

234 if (samples && in) { \

235 if ((samples ^ in) < 0) { \

236 weight -= delta; \

237 if (weight < -1024) \

238 weight = -1024; \

239 } else { \

240 weight += delta; \

241 if (weight > 1024) \

242 weight = 1024; \

243 } \

244 }

245

246 static av_always_inline int get_tail(GetBitContext *gb, int k)

247 {

248 int p, e, res;

249

250 if (k < 1)

251 return 0;

252 p = av_log2(k);

253 e = (1 << (p + 1)) - k - 1;

254 res = p ? get_bits(gb, p) : 0;

255 if (res >= e)

256 res = (res << 1) - e + get_bits1(gb);

257 return res;

258 }

259

260 static void update_error_limit(WavpackFrameContext *ctx)

261 {

262 int i, br[2], sl[2];

263

264 for (i = 0; i <= ctx->stereo_in; i++) {

265 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;

266 br[i] = ctx->ch[i].bitrate_acc >> 16;

267 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);

268 }

269 if (ctx->stereo_in && ctx->hybrid_bitrate) {

270 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;

271 if (balance > br[0]) {

272 br[1] = br[0] << 1;

273 br[0] = 0;

274 } else if (-balance > br[0]) {

275 br[0] <<= 1;

276 br[1] = 0;

277 } else {

278 br[1] = br[0] + balance;

279 br[0] = br[0] - balance;

280 }

281 }

282 for (i = 0; i <= ctx->stereo_in; i++) {

283 if (ctx->hybrid_bitrate) {

284 if (sl[i] - br[i] > -0x100)

285 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);

286 else

287 ctx->ch[i].error_limit = 0;

288 } else {

289 ctx->ch[i].error_limit = wp_exp2(br[i]);

290 }

291 }

292 }

293

294 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,

295 int channel, int *last)

296 {

297 int t, t2;

298 int sign, base, add, ret;

299 WvChannel *c = &ctx->ch[channel];

300

301 *last = 0;

302

303 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&

304 !ctx->zero && !ctx->one) {

305 if (ctx->zeroes) {

306 ctx->zeroes--;

307 if (ctx->zeroes) {

308 c->slow_level -= LEVEL_DECAY(c->slow_level);

309 return 0;

310 }

311 } else {

312 t = get_unary_0_33(gb);

313 if (t >= 2) {

314 if (get_bits_left(gb) < t - 1)

315 goto error;

316 t = get_bits(gb, t - 1) | (1 << (t - 1));

317 } else {

318 if (get_bits_left(gb) < 0)

319 goto error;

320 }

321 ctx->zeroes = t;

322 if (ctx->zeroes) {

323 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));

324 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));

325 c->slow_level -= LEVEL_DECAY(c->slow_level);

326 return 0;

327 }

328 }

329 }

330

331 if (ctx->zero) {

332 t = 0;

333 ctx->zero = 0;

334 } else {

335 t = get_unary_0_33(gb);

336 if (get_bits_left(gb) < 0)

337 goto error;

338 if (t == 16) {

339 t2 = get_unary_0_33(gb);

340 if (t2 < 2) {

341 if (get_bits_left(gb) < 0)

342 goto error;

343 t += t2;

344 } else {

345 if (get_bits_left(gb) < t2 - 1)

346 goto error;

347 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));

348 }

349 }

350

351 if (ctx->one) {

352 ctx->one = t & 1;

353 t = (t >> 1) + 1;

354 } else {

355 ctx->one = t & 1;

356 t >>= 1;

357 }

358 ctx->zero = !ctx->one;

359 }

360

361 if (ctx->hybrid && !channel)

362 update_error_limit(ctx);

363

364 if (!t) {

365 base = 0;

366 add = GET_MED(0) - 1;

367 DEC_MED(0);

368 } else if (t == 1) {

369 base = GET_MED(0);

370 add = GET_MED(1) - 1;

371 INC_MED(0);

372 DEC_MED(1);

373 } else if (t == 2) {

374 base = GET_MED(0) + GET_MED(1);

375 add = GET_MED(2) - 1;

376 INC_MED(0);

377 INC_MED(1);

378 DEC_MED(2);

379 } else {

380 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);

381 add = GET_MED(2) - 1;

382 INC_MED(0);

383 INC_MED(1);

384 INC_MED(2);

385 }

386 if (!c->error_limit) {

387 if (add >= 0x2000000U) {

388 av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);

389 goto error;

390 }

391 ret = base + get_tail(gb, add);

392 if (get_bits_left(gb) <= 0)

393 goto error;

394 } else {

395 int mid = (base * 2 + add + 1) >> 1;

396 while (add > c->error_limit) {

397 if (get_bits_left(gb) <= 0)

398 goto error;

399 if (get_bits1(gb)) {

400 add -= (mid - base);

401 base = mid;

402 } else

403 add = mid - base - 1;

404 mid = (base * 2 + add + 1) >> 1;

405 }

406 ret = mid;

407 }

408 sign = get_bits1(gb);

409 if (ctx->hybrid_bitrate)

410 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);

411 return sign ? ~ret : ret;

412

413 error:

414 *last = 1;

415 return 0;

416 }

417

418 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,

419 int S)

420 {

421 int bit;

422

423 if (s->extra_bits) {

424 S <<= s->extra_bits;

425

426 if (s->got_extra_bits &&

427 get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {

428 S |= get_bits(&s->gb_extra_bits, s->extra_bits);

429 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);

430 }

431 }

432

433 bit = (S & s->and) | s->or;

434 bit = ((S + bit) << s->shift) - bit;

435

436 if (s->hybrid)

437 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);

438

439 return bit << s->post_shift;

440 }

441

442 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)

443 {

444 union {

445 float f;

446 uint32_t u;

447 } value;

448

449 unsigned int sign;

450 int exp = s->float_max_exp;

451

452 if (s->got_extra_bits) {

453 const int max_bits = 1 + 23 + 8 + 1;

454 const int left_bits = get_bits_left(&s->gb_extra_bits);

455

456 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)

457 return 0.0;

458 }

459

460 if (S) {

461 S <<= s->float_shift;

462 sign = S < 0;

463 if (sign)

464 S = -S;

465 if (S >= 0x1000000) {

466 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))

467 S = get_bits(&s->gb_extra_bits, 23);

468 else

469 S = 0;

470 exp = 255;

471 } else if (exp) {

472 int shift = 23 - av_log2(S);

473 exp = s->float_max_exp;

474 if (exp <= shift)

475 shift = --exp;

476 exp -= shift;

477

478 if (shift) {

479 S <<= shift;

480 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||

481 (s->got_extra_bits &&

482 (s->float_flag & WV_FLT_SHIFT_SAME) &&

483 get_bits1(&s->gb_extra_bits))) {

484 S |= (1 << shift) - 1;

485 } else if (s->got_extra_bits &&

486 (s->float_flag & WV_FLT_SHIFT_SENT)) {

487 S |= get_bits(&s->gb_extra_bits, shift);

488 }

489 }

490 } else {

491 exp = s->float_max_exp;

492 }

493 S &= 0x7fffff;

494 } else {

495 sign = 0;

496 exp = 0;

497 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {

498 if (get_bits1(&s->gb_extra_bits)) {

499 S = get_bits(&s->gb_extra_bits, 23);

500 if (s->float_max_exp >= 25)

501 exp = get_bits(&s->gb_extra_bits, 8);

502 sign = get_bits1(&s->gb_extra_bits);

503 } else {

504 if (s->float_flag & WV_FLT_ZERO_SIGN)

505 sign = get_bits1(&s->gb_extra_bits);

506 }

507 }

508 }

509

510 *crc = *crc * 27 + S * 9 + exp * 3 + sign;

511

512 value.u = (sign << 31) | (exp << 23) | S;

513 return value.f;

514 }

515

516 static void wv_reset_saved_context(WavpackFrameContext *s)

517 {

518 s->pos = 0;

519 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;

520 }

521

522 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,

523 uint32_t crc_extra_bits)

524 {

525 if (crc != s->CRC) {

526 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");

527 return AVERROR_INVALIDDATA;

528 }

529 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {

530 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");

531 return AVERROR_INVALIDDATA;

532 }

533

534 return 0;

535 }

536

537 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,

538 void *dst_l, void *dst_r, const int type)

539 {

540 int i, j, count = 0;

541 int last, t;

542 int A, B, L, L2, R, R2;

543 int pos = s->pos;

544 uint32_t crc = s->sc.crc;

545 uint32_t crc_extra_bits = s->extra_sc.crc;

546 int16_t *dst16_l = dst_l;

547 int16_t *dst16_r = dst_r;

548 int32_t *dst32_l = dst_l;

549 int32_t *dst32_r = dst_r;

550 float *dstfl_l = dst_l;

551 float *dstfl_r = dst_r;

552

553 s->one = s->zero = s->zeroes = 0;

554 do {

555 L = wv_get_value(s, gb, 0, &last);

556 if (last)

557 break;

558 R = wv_get_value(s, gb, 1, &last);

559 if (last)

560 break;

561 for (i = 0; i < s->terms; i++) {

562 t = s->decorr[i].value;

563 if (t > 0) {

564 if (t > 8) {

565 if (t & 1) {

566 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];

567 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];

568 } else {

569 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;

570 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;

571 }

572 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];

573 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];

574 j = 0;

575 } else {

576 A = s->decorr[i].samplesA[pos];

577 B = s->decorr[i].samplesB[pos];

578 j = (pos + t) & 7;

579 }

580 if (type != AV_SAMPLE_FMT_S16P) {

581 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);

582 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);

583 } else {

584 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);

585 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);

586 }

587 if (A && L)

588 s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;

589 if (B && R)

590 s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;

591 s->decorr[i].samplesA[j] = L = L2;

592 s->decorr[i].samplesB[j] = R = R2;

593 } else if (t == -1) {

594 if (type != AV_SAMPLE_FMT_S16P)

595 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);

596 else

597 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);

598 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);

599 L = L2;

600 if (type != AV_SAMPLE_FMT_S16P)

601 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);

602 else

603 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);

604 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);

605 R = R2;

606 s->decorr[i].samplesA[0] = R;

607 } else {

608 if (type != AV_SAMPLE_FMT_S16P)

609 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);

610 else

611 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);

612 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);

613 R = R2;

614

615 if (t == -3) {

616 R2 = s->decorr[i].samplesA[0];

617 s->decorr[i].samplesA[0] = R;

618 }

619

620 if (type != AV_SAMPLE_FMT_S16P)

621 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);

622 else

623 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);

624 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);

625 L = L2;

626 s->decorr[i].samplesB[0] = L;

627 }

628 }

629 pos = (pos + 1) & 7;

630 if (s->joint)

631 L += (R -= (L >> 1));

632 crc = (crc * 3 + L) * 3 + R;

633

634 if (type == AV_SAMPLE_FMT_FLTP) {

635 *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);

636 *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);

637 } else if (type == AV_SAMPLE_FMT_S32P) {

638 *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);

639 *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);

640 } else {

641 *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);

642 *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);

643 }

644 count++;

645 } while (!last && count < s->samples);

646

647 wv_reset_saved_context(s);

648 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&

649 wv_check_crc(s, crc, crc_extra_bits))

650 return AVERROR_INVALIDDATA;

651

652 return 0;

653 }

654

655 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,

656 void *dst, const int type)

657 {

658 int i, j, count = 0;

659 int last, t;

660 int A, S, T;

661 int pos = s->pos;

662 uint32_t crc = s->sc.crc;

663 uint32_t crc_extra_bits = s->extra_sc.crc;

664 int16_t *dst16 = dst;

665 int32_t *dst32 = dst;

666 float *dstfl = dst;

667

668 s->one = s->zero = s->zeroes = 0;

669 do {

670 T = wv_get_value(s, gb, 0, &last);

671 S = 0;

672 if (last)

673 break;

674 for (i = 0; i < s->terms; i++) {

675 t = s->decorr[i].value;

676 if (t > 8) {

677 if (t & 1)

678 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];

679 else

680 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;

681 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];

682 j = 0;

683 } else {

684 A = s->decorr[i].samplesA[pos];

685 j = (pos + t) & 7;

686 }

687 if (type != AV_SAMPLE_FMT_S16P)

688 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);

689 else

690 S = T + ((s->decorr[i].weightA * A + 512) >> 10);

691 if (A && T)

692 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;

693 s->decorr[i].samplesA[j] = T = S;

694 }

695 pos = (pos + 1) & 7;

696 crc = crc * 3 + S;

697

698 if (type == AV_SAMPLE_FMT_FLTP) {

699 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);

700 } else if (type == AV_SAMPLE_FMT_S32P) {

701 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);

702 } else {

703 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);

704 }

705 count++;

706 } while (!last && count < s->samples);

707

708 wv_reset_saved_context(s);

709 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&

710 wv_check_crc(s, crc, crc_extra_bits))

711 return AVERROR_INVALIDDATA;

712

713 return 0;

714 }

715

716 static av_cold int wv_alloc_frame_context(WavpackContext *c)

717 {

718 if (c->fdec_num == WV_MAX_FRAME_DECODERS)

719 return -1;

720

721 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));

722 if (!c->fdec[c->fdec_num])

723 return -1;

724 c->fdec_num++;

725 c->fdec[c->fdec_num - 1]->avctx = c->avctx;

726 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);

727

728 return 0;

729 }

730

731 static int init_thread_copy(AVCodecContext *avctx)

732 {

733 WavpackContext *s = avctx->priv_data;

734 s->avctx = avctx;

735 return 0;

736 }

737

738 static av_cold int wavpack_decode_init(AVCodecContext *avctx)

739 {

740 WavpackContext *s = avctx->priv_data;

741

742 s->avctx = avctx;

743

744 s->fdec_num = 0;

745

746 return 0;

747 }

748

749 static av_cold int wavpack_decode_end(AVCodecContext *avctx)

750 {

751 WavpackContext *s = avctx->priv_data;

752 int i;

753

754 for (i = 0; i < s->fdec_num; i++)

755 av_freep(&s->fdec[i]);

756 s->fdec_num = 0;

757

758 return 0;

759 }

760

761 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,

762 AVFrame *frame, const uint8_t *buf, int buf_size)

763 {

764 WavpackContext *wc = avctx->priv_data;

765 ThreadFrame tframe = { .f = frame };

766 WavpackFrameContext *s;

767 GetByteContext gb;

768 void *samples_l, *samples_r;

769 int ret;

770 int got_terms = 0, got_weights = 0, got_samples = 0,

771 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;

772 int i, j, id, size, ssize, weights, t;

773 int bpp, chan = 0, chmask = 0, orig_bpp, sample_rate = 0;

774 int multiblock;

775

776 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {

777 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");

778 return AVERROR_INVALIDDATA;

779 }

780

781 s = wc->fdec[block_no];

782 if (!s) {

783 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",

784 block_no);

785 return AVERROR_INVALIDDATA;

786 }

787

788 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));

789 memset(s->ch, 0, sizeof(s->ch));

790 s->extra_bits = 0;

791 s->and = s->or = s->shift = 0;

792 s->got_extra_bits = 0;

793

794 bytestream2_init(&gb, buf, buf_size);

795

796 s->samples = bytestream2_get_le32(&gb);

797 if (s->samples != wc->samples) {

798 av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "

799 "a sequence: %d and %d\n", wc->samples, s->samples);

800 return AVERROR_INVALIDDATA;

801 }

802 s->frame_flags = bytestream2_get_le32(&gb);

803 bpp = av_get_bytes_per_sample(avctx->sample_fmt);

804 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;

805 multiblock = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;

806

807 s->stereo = !(s->frame_flags & WV_MONO);

808 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;

809 s->joint = s->frame_flags & WV_JOINT_STEREO;

810 s->hybrid = s->frame_flags & WV_HYBRID_MODE;

811 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;

812 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);

813 s->hybrid_maxclip = ((1LL << (orig_bpp - 1)) - 1);

814 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));

815 s->CRC = bytestream2_get_le32(&gb);

816

817 // parse metadata blocks

818 while (bytestream2_get_bytes_left(&gb)) {

819 id = bytestream2_get_byte(&gb);

820 size = bytestream2_get_byte(&gb);

821 if (id & WP_IDF_LONG) {

822 size |= (bytestream2_get_byte(&gb)) << 8;

823 size |= (bytestream2_get_byte(&gb)) << 16;

824 }

825 size <<= 1; // size is specified in words

826 ssize = size;

827 if (id & WP_IDF_ODD)

828 size--;

829 if (size < 0) {

830 av_log(avctx, AV_LOG_ERROR,

831 "Got incorrect block %02X with size %i\n", id, size);

832 break;

833 }

834 if (bytestream2_get_bytes_left(&gb) < ssize) {

835 av_log(avctx, AV_LOG_ERROR,

836 "Block size %i is out of bounds\n", size);

837 break;

838 }

839 switch (id & WP_IDF_MASK) {

840 case WP_ID_DECTERMS:

841 if (size > MAX_TERMS) {

842 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");

843 s->terms = 0;

844 bytestream2_skip(&gb, ssize);

845 continue;

846 }

847 s->terms = size;

848 for (i = 0; i < s->terms; i++) {

849 uint8_t val = bytestream2_get_byte(&gb);

850 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;

851 s->decorr[s->terms - i - 1].delta = val >> 5;

852 }

853 got_terms = 1;

854 break;

855 case WP_ID_DECWEIGHTS:

856 if (!got_terms) {

857 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");

858 continue;

859 }

860 weights = size >> s->stereo_in;

861 if (weights > MAX_TERMS || weights > s->terms) {

862 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");

863 bytestream2_skip(&gb, ssize);

864 continue;

865 }

866 for (i = 0; i < weights; i++) {

867 t = (int8_t)bytestream2_get_byte(&gb);

868 s->decorr[s->terms - i - 1].weightA = t << 3;

869 if (s->decorr[s->terms - i - 1].weightA > 0)

870 s->decorr[s->terms - i - 1].weightA +=

871 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;

872 if (s->stereo_in) {

873 t = (int8_t)bytestream2_get_byte(&gb);

874 s->decorr[s->terms - i - 1].weightB = t << 3;

875 if (s->decorr[s->terms - i - 1].weightB > 0)

876 s->decorr[s->terms - i - 1].weightB +=

877 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;

878 }

879 }

880 got_weights = 1;

881 break;

882 case WP_ID_DECSAMPLES:

883 if (!got_terms) {

884 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");

885 continue;

886 }

887 t = 0;

888 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {

889 if (s->decorr[i].value > 8) {

890 s->decorr[i].samplesA[0] =

891 wp_exp2(bytestream2_get_le16(&gb));

892 s->decorr[i].samplesA[1] =

893 wp_exp2(bytestream2_get_le16(&gb));

894

895 if (s->stereo_in) {

896 s->decorr[i].samplesB[0] =

897 wp_exp2(bytestream2_get_le16(&gb));

898 s->decorr[i].samplesB[1] =

899 wp_exp2(bytestream2_get_le16(&gb));

900 t += 4;

901 }

902 t += 4;

903 } else if (s->decorr[i].value < 0) {

904 s->decorr[i].samplesA[0] =

905 wp_exp2(bytestream2_get_le16(&gb));

906 s->decorr[i].samplesB[0] =

907 wp_exp2(bytestream2_get_le16(&gb));

908 t += 4;

909 } else {

910 for (j = 0; j < s->decorr[i].value; j++) {

911 s->decorr[i].samplesA[j] =

912 wp_exp2(bytestream2_get_le16(&gb));

913 if (s->stereo_in) {

914 s->decorr[i].samplesB[j] =

915 wp_exp2(bytestream2_get_le16(&gb));

916 }

917 }

918 t += s->decorr[i].value * 2 * (s->stereo_in + 1);

919 }

920 }

921 got_samples = 1;

922 break;

923 case WP_ID_ENTROPY:

924 if (size != 6 * (s->stereo_in + 1)) {

925 av_log(avctx, AV_LOG_ERROR,

926 "Entropy vars size should be %i, got %i.\n",

927 6 * (s->stereo_in + 1), size);

928 bytestream2_skip(&gb, ssize);

929 continue;

930 }

931 for (j = 0; j <= s->stereo_in; j++)

932 for (i = 0; i < 3; i++) {

933 s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));

934 }

935 got_entropy = 1;

936 break;

937 case WP_ID_HYBRID:

938 if (s->hybrid_bitrate) {

939 for (i = 0; i <= s->stereo_in; i++) {

940 s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));

941 size -= 2;

942 }

943 }

944 for (i = 0; i < (s->stereo_in + 1); i++) {

945 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;

946 size -= 2;

947 }

948 if (size > 0) {

949 for (i = 0; i < (s->stereo_in + 1); i++) {

950 s->ch[i].bitrate_delta =

951 wp_exp2((int16_t)bytestream2_get_le16(&gb));

952 }

953 } else {

954 for (i = 0; i < (s->stereo_in + 1); i++)

955 s->ch[i].bitrate_delta = 0;

956 }

957 got_hybrid = 1;

958 break;

959 case WP_ID_INT32INFO: {

960 uint8_t val[4];

961 if (size != 4) {

962 av_log(avctx, AV_LOG_ERROR,

963 "Invalid INT32INFO, size = %i\n",

964 size);

965 bytestream2_skip(&gb, ssize - 4);

966 continue;

967 }

968 bytestream2_get_buffer(&gb, val, 4);

969 if (val[0]) {

970 s->extra_bits = val[0];

971 } else if (val[1]) {

972 s->shift = val[1];

973 } else if (val[2]) {

974 s->and = s->or = 1;

975 s->shift = val[2];

976 } else if (val[3]) {

977 s->and = 1;

978 s->shift = val[3];

979 }

980 /* original WavPack decoder forces 32-bit lossy sound to be treated

981 * as 24-bit one in order to have proper clipping */

982 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {

983 s->post_shift += 8;

984 s->shift -= 8;

985 s->hybrid_maxclip >>= 8;

986 s->hybrid_minclip >>= 8;

987 }

988 break;

989 }

990 case WP_ID_FLOATINFO:

991 if (size != 4) {

992 av_log(avctx, AV_LOG_ERROR,

993 "Invalid FLOATINFO, size = %i\n", size);

994 bytestream2_skip(&gb, ssize);

995 continue;

996 }

997 s->float_flag = bytestream2_get_byte(&gb);

998 s->float_shift = bytestream2_get_byte(&gb);

999 s->float_max_exp = bytestream2_get_byte(&gb);

1000 got_float = 1;

1001 bytestream2_skip(&gb, 1);

1002 break;

1003 case WP_ID_DATA:

1004 s->sc.offset = bytestream2_tell(&gb);

1005 s->sc.size = size * 8;

1006 init_get_bits(&s->gb, gb.buffer, size * 8);

1007 s->data_size = size * 8;

1008 bytestream2_skip(&gb, size);

1009 got_bs = 1;

1010 break;

1011 case WP_ID_EXTRABITS:

1012 if (size <= 4) {

1013 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",

1014 size);

1015 bytestream2_skip(&gb, size);

1016 continue;

1017 }

1018 s->extra_sc.offset = bytestream2_tell(&gb);

1019 s->extra_sc.size = size * 8;

1020 init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8);

1021 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);

1022 bytestream2_skip(&gb, size);

1023 s->got_extra_bits = 1;

1024 break;

1025 case WP_ID_CHANINFO:

1026 if (size <= 1) {

1027 av_log(avctx, AV_LOG_ERROR,

1028 "Insufficient channel information\n");

1029 return AVERROR_INVALIDDATA;

1030 }

1031 chan = bytestream2_get_byte(&gb);

1032 switch (size - 2) {

1033 case 0:

1034 chmask = bytestream2_get_byte(&gb);

1035 break;

1036 case 1:

1037 chmask = bytestream2_get_le16(&gb);

1038 break;

1039 case 2:

1040 chmask = bytestream2_get_le24(&gb);

1041 break;

1042 case 3:

1043 chmask = bytestream2_get_le32(&gb);

1044 break;

1045 case 5:

1046 bytestream2_skip(&gb, 1);

1047 chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;

1048 chmask = bytestream2_get_le16(&gb);

1049 break;

1050 default:

1051 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",

1052 size);

1053 chan = avctx->channels;

1054 chmask = avctx->channel_layout;

1055 }

1056 break;

1057 case WP_ID_SAMPLE_RATE:

1058 if (size != 3) {

1059 av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");

1060 return AVERROR_INVALIDDATA;

1061 }

1062 sample_rate = bytestream2_get_le24(&gb);

1063 break;

1064 default:

1065 bytestream2_skip(&gb, size);

1066 }

1067 if (id & WP_IDF_ODD)

1068 bytestream2_skip(&gb, 1);

1069 }

1070

1071 if (!got_terms) {

1072 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");

1073 return AVERROR_INVALIDDATA;

1074 }

1075 if (!got_weights) {

1076 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");

1077 return AVERROR_INVALIDDATA;

1078 }

1079 if (!got_samples) {

1080 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");

1081 return AVERROR_INVALIDDATA;

1082 }

1083 if (!got_entropy) {

1084 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");

1085 return AVERROR_INVALIDDATA;

1086 }

1087 if (s->hybrid && !got_hybrid) {

1088 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");

1089 return AVERROR_INVALIDDATA;

1090 }

1091 if (!got_bs) {

1092 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");

1093 return AVERROR_INVALIDDATA;

1094 }

1095 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {

1096 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");

1097 return AVERROR_INVALIDDATA;

1098 }

1099 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {

1100 const int size = get_bits_left(&s->gb_extra_bits);

1101 const int wanted = s->samples * s->extra_bits << s->stereo_in;

1102 if (size < wanted) {

1103 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");

1104 s->got_extra_bits = 0;

1105 }

1106 }

1107

1108 if (!wc->ch_offset) {

1109 int sr = (s->frame_flags >> 23) & 0xf;

1110 if (sr == 0xf) {

1111 if (!sample_rate) {

1112 av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");

1113 return AVERROR_INVALIDDATA;

1114 }

1115 avctx->sample_rate = sample_rate;

1116 } else

1117 avctx->sample_rate = wv_rates[sr];

1118

1119 if (multiblock) {

1120 if (chan)

1121 avctx->channels = chan;

1122 if (chmask)

1123 avctx->channel_layout = chmask;

1124 } else {

1125 avctx->channels = s->stereo ? 2 : 1;

1126 avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :

1127 AV_CH_LAYOUT_MONO;

1128 }

1129

1130 /* get output buffer */

1131 frame->nb_samples = s->samples + 1;

1132 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)

1133 return ret;

1134 frame->nb_samples = s->samples;

1135 }

1136

1137 if (wc->ch_offset + s->stereo >= avctx->channels) {

1138 av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");

1139 return (avctx->err_recognition & AV_EF_EXPLODE) ? AVERROR_INVALIDDATA : 0;

1140 }

1141

1142 samples_l = frame->extended_data[wc->ch_offset];

1143 if (s->stereo)

1144 samples_r = frame->extended_data[wc->ch_offset + 1];

1145

1146 wc->ch_offset += 1 + s->stereo;

1147

1148 if (s->stereo_in) {

1149 ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);

1150 if (ret < 0)

1151 return ret;

1152 } else {

1153 ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);

1154 if (ret < 0)

1155 return ret;

1156

1157 if (s->stereo)

1158 memcpy(samples_r, samples_l, bpp * s->samples);

1159 }

1160

1161 return 0;

1162 }

1163

1164 static void wavpack_decode_flush(AVCodecContext *avctx)

1165 {

1166 WavpackContext *s = avctx->priv_data;

1167 int i;

1168

1169 for (i = 0; i < s->fdec_num; i++)

1170 wv_reset_saved_context(s->fdec[i]);

1171 }

1172

1173 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,

1174 int *got_frame_ptr, AVPacket *avpkt)

1175 {

1176 WavpackContext *s = avctx->priv_data;

1177 const uint8_t *buf = avpkt->data;

1178 int buf_size = avpkt->size;

1179 AVFrame *frame = data;

1180 int frame_size, ret, frame_flags;

1181

1182 if (avpkt->size <= WV_HEADER_SIZE)

1183 return AVERROR_INVALIDDATA;

1184

1185 s->block = 0;

1186 s->ch_offset = 0;

1187

1188 /* determine number of samples */

1189 s->samples = AV_RL32(buf + 20);

1190 frame_flags = AV_RL32(buf + 24);

1191 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {

1192 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",

1193 s->samples);

1194 return AVERROR_INVALIDDATA;

1195 }

1196

1197 if (frame_flags & 0x80) {

1198 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

1199 } else if ((frame_flags & 0x03) <= 1) {

1200 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

1201 } else {

1202 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

1203 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;

1204 }

1205

1206 while (buf_size > 0) {

1207 if (buf_size <= WV_HEADER_SIZE)

1208 break;

1209 frame_size = AV_RL32(buf + 4) - 12;

1210 buf += 20;

1211 buf_size -= 20;

1212 if (frame_size <= 0 || frame_size > buf_size) {

1213 av_log(avctx, AV_LOG_ERROR,

1214 "Block %d has invalid size (size %d vs. %d bytes left)\n",

1215 s->block, frame_size, buf_size);

1216 wavpack_decode_flush(avctx);

1217 return AVERROR_INVALIDDATA;

1218 }

1219 if ((ret = wavpack_decode_block(avctx, s->block,

1220 frame, buf, frame_size)) < 0) {

1221 wavpack_decode_flush(avctx);

1222 return ret;

1223 }

1224 s->block++;

1225 buf += frame_size;

1226 buf_size -= frame_size;

1227 }

1228

1229 if (s->ch_offset != avctx->channels) {

1230 av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");

1231 return AVERROR_INVALIDDATA;

1232 }

1233

1234 *got_frame_ptr = 1;

1235

1236 return avpkt->size;

1237 }

1238

1239 AVCodec ff_wavpack_decoder = {

1240 .name = "wavpack",

1241 .type = AVMEDIA_TYPE_AUDIO,

1242 .id = AV_CODEC_ID_WAVPACK,

1243 .priv_data_size = sizeof(WavpackContext),

1244 .init = wavpack_decode_init,

1245 .close = wavpack_decode_end,

1246 .decode = wavpack_decode_frame,

1247 .flush = wavpack_decode_flush,

1248 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

1249 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

1250 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),

1251 };

Generated on Wed Jul 10 2013 23:48:07 for FFmpeg by doxygen 1.8.2