FFmpeg: libavcodec/apedec.c Source File

FFmpeg

[フレーム]

libavcodec

apedec.c

Go to the documentation of this file.

1 /*

2 * Monkey's Audio lossless audio decoder

4 * based upon libdemac from Dave Chapman.

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include <inttypes.h>

25 #include "libavutil/avassert.h"

26 #include "libavutil/channel_layout.h"

27 #include "libavutil/opt.h"

28 #include "lossless_audiodsp.h"

29 #include "avcodec.h"

30 #include "bswapdsp.h"

31 #include "bytestream.h"

32 #include "internal.h"

33 #include "get_bits.h"

34 #include "unary.h"

36 /**

37 * @file

38 * Monkey's Audio lossless audio decoder

39 */

41 #define MAX_CHANNELS 2

42 #define MAX_BYTESPERSAMPLE 3

44 #define APE_FRAMECODE_MONO_SILENCE 1

45 #define APE_FRAMECODE_STEREO_SILENCE 3

46 #define APE_FRAMECODE_PSEUDO_STEREO 4

48 #define HISTORY_SIZE 512

49 #define PREDICTOR_ORDER 8

50 /** Total size of all predictor histories */

51 #define PREDICTOR_SIZE 50

53 #define YDELAYA (18 + PREDICTOR_ORDER*4)

54 #define YDELAYB (18 + PREDICTOR_ORDER*3)

55 #define XDELAYA (18 + PREDICTOR_ORDER*2)

56 #define XDELAYB (18 + PREDICTOR_ORDER)

58 #define YADAPTCOEFFSA 18

59 #define XADAPTCOEFFSA 14

60 #define YADAPTCOEFFSB 10

61 #define XADAPTCOEFFSB 5

63 /**

64 * Possible compression levels

65 * @{

66 */

67 enum APECompressionLevel {

68 COMPRESSION_LEVEL_FAST = 1000,

69 COMPRESSION_LEVEL_NORMAL = 2000,

70 COMPRESSION_LEVEL_HIGH = 3000,

71 COMPRESSION_LEVEL_EXTRA_HIGH = 4000,

72 COMPRESSION_LEVEL_INSANE = 5000

73 };

74 /** @} */

76 #define APE_FILTER_LEVELS 3

78 /** Filter orders depending on compression level */

79 static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS] = {

80 { 0, 0, 0 },

81 { 16, 0, 0 },

82 { 64, 0, 0 },

83 { 32, 256, 0 },

84 { 16, 256, 1280 }

85 };

87 /** Filter fraction bits depending on compression level */

88 static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS] = {

89 { 0, 0, 0 },

90 { 11, 0, 0 },

91 { 11, 0, 0 },

92 { 10, 13, 0 },

93 { 11, 13, 15 }

94 };

97 /** Filters applied to the decoded data */

98 typedef struct APEFilter {

99 int16_t *coeffs; ///< actual coefficients used in filtering

100 int16_t *adaptcoeffs; ///< adaptive filter coefficients used for correcting of actual filter coefficients

101 int16_t *historybuffer; ///< filter memory

102 int16_t *delay; ///< filtered values

103

104 int avg;

105 } APEFilter;

106

107 typedef struct APERice {

108 uint32_t k;

109 uint32_t ksum;

110 } APERice;

111

112 typedef struct APERangecoder {

113 uint32_t low; ///< low end of interval

114 uint32_t range; ///< length of interval

115 uint32_t help; ///< bytes_to_follow resp. intermediate value

116 unsigned int buffer; ///< buffer for input/output

117 } APERangecoder;

118

119 /** Filter histories */

120 typedef struct APEPredictor {

121 int32_t *buf;

122

123 int32_t lastA[2];

124

125 int32_t filterA[2];

126 int32_t filterB[2];

127

128 int32_t coeffsA[2][4]; ///< adaption coefficients

129 int32_t coeffsB[2][5]; ///< adaption coefficients

130 int32_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE];

131

132 unsigned int sample_pos;

133 } APEPredictor;

134

135 /** Decoder context */

136 typedef struct APEContext {

137 AVClass *class; ///< class for AVOptions

138 AVCodecContext *avctx;

139 BswapDSPContext bdsp;

140 LLAudDSPContext adsp;

141 int channels;

142 int samples; ///< samples left to decode in current frame

143 int bps;

144

145 int fileversion; ///< codec version, very important in decoding process

146 int compression_level; ///< compression levels

147 int fset; ///< which filter set to use (calculated from compression level)

148 int flags; ///< global decoder flags

149

150 uint32_t CRC; ///< frame CRC

151 int frameflags; ///< frame flags

152 APEPredictor predictor; ///< predictor used for final reconstruction

153

154 int32_t *decoded_buffer;

155 int decoded_size;

156 int32_t *decoded[MAX_CHANNELS]; ///< decoded data for each channel

157 int blocks_per_loop; ///< maximum number of samples to decode for each call

158

159 int16_t* filterbuf[APE_FILTER_LEVELS]; ///< filter memory

160

161 APERangecoder rc; ///< rangecoder used to decode actual values

162 APERice riceX; ///< rice code parameters for the second channel

163 APERice riceY; ///< rice code parameters for the first channel

164 APEFilter filters[APE_FILTER_LEVELS][2]; ///< filters used for reconstruction

165 GetBitContext gb;

166

167 uint8_t *data; ///< current frame data

168 uint8_t *data_end; ///< frame data end

169 int data_size; ///< frame data allocated size

170 const uint8_t *ptr; ///< current position in frame data

171

172 int error;

173

174 void (*entropy_decode_mono)(struct APEContext *ctx, int blockstodecode);

175 void (*entropy_decode_stereo)(struct APEContext *ctx, int blockstodecode);

176 void (*predictor_decode_mono)(struct APEContext *ctx, int count);

177 void (*predictor_decode_stereo)(struct APEContext *ctx, int count);

178 } APEContext;

179

180 static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,

181 int32_t *decoded1, int count);

182

183 static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode);

184 static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode);

185 static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode);

186 static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode);

187 static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode);

188 static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode);

189 static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode);

190 static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode);

191 static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode);

192

193 static void predictor_decode_mono_3800(APEContext *ctx, int count);

194 static void predictor_decode_stereo_3800(APEContext *ctx, int count);

195 static void predictor_decode_mono_3930(APEContext *ctx, int count);

196 static void predictor_decode_stereo_3930(APEContext *ctx, int count);

197 static void predictor_decode_mono_3950(APEContext *ctx, int count);

198 static void predictor_decode_stereo_3950(APEContext *ctx, int count);

199

200 static av_cold int ape_decode_close(AVCodecContext *avctx)

201 {

202 APEContext *s = avctx->priv_data;

203 int i;

204

205 for (i = 0; i < APE_FILTER_LEVELS; i++)

206 av_freep(&s->filterbuf[i]);

207

208 av_freep(&s->decoded_buffer);

209 av_freep(&s->data);

210 s->decoded_size = s->data_size = 0;

211

212 return 0;

213 }

214

215 static av_cold int ape_decode_init(AVCodecContext *avctx)

216 {

217 APEContext *s = avctx->priv_data;

218 int i;

219

220 if (avctx->extradata_size != 6) {

221 av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n");

222 return AVERROR(EINVAL);

223 }

224 if (avctx->channels > 2) {

225 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n");

226 return AVERROR(EINVAL);

227 }

228 s->bps = avctx->bits_per_coded_sample;

229 switch (s->bps) {

230 case 8:

231 avctx->sample_fmt = AV_SAMPLE_FMT_U8P;

232 break;

233 case 16:

234 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

235 break;

236 case 24:

237 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

238 break;

239 default:

240 avpriv_request_sample(avctx,

241 "%d bits per coded sample", s->bps);

242 return AVERROR_PATCHWELCOME;

243 }

244 s->avctx = avctx;

245 s->channels = avctx->channels;

246 s->fileversion = AV_RL16(avctx->extradata);

247 s->compression_level = AV_RL16(avctx->extradata + 2);

248 s->flags = AV_RL16(avctx->extradata + 4);

249

250 av_log(avctx, AV_LOG_DEBUG, "Compression Level: %d - Flags: %d\n",

251 s->compression_level, s->flags);

252 if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE ||

253 !s->compression_level ||

254 (s->fileversion < 3930 && s->compression_level == COMPRESSION_LEVEL_INSANE)) {

255 av_log(avctx, AV_LOG_ERROR, "Incorrect compression level %d\n",

256 s->compression_level);

257 return AVERROR_INVALIDDATA;

258 }

259 s->fset = s->compression_level / 1000 - 1;

260 for (i = 0; i < APE_FILTER_LEVELS; i++) {

261 if (!ape_filter_orders[s->fset][i])

262 break;

263 FF_ALLOC_OR_GOTO(avctx, s->filterbuf[i],

264 (ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4,

265 filter_alloc_fail);

266 }

267

268 if (s->fileversion < 3860) {

269 s->entropy_decode_mono = entropy_decode_mono_0000;

270 s->entropy_decode_stereo = entropy_decode_stereo_0000;

271 } else if (s->fileversion < 3900) {

272 s->entropy_decode_mono = entropy_decode_mono_3860;

273 s->entropy_decode_stereo = entropy_decode_stereo_3860;

274 } else if (s->fileversion < 3930) {

275 s->entropy_decode_mono = entropy_decode_mono_3900;

276 s->entropy_decode_stereo = entropy_decode_stereo_3900;

277 } else if (s->fileversion < 3990) {

278 s->entropy_decode_mono = entropy_decode_mono_3900;

279 s->entropy_decode_stereo = entropy_decode_stereo_3930;

280 } else {

281 s->entropy_decode_mono = entropy_decode_mono_3990;

282 s->entropy_decode_stereo = entropy_decode_stereo_3990;

283 }

284

285 if (s->fileversion < 3930) {

286 s->predictor_decode_mono = predictor_decode_mono_3800;

287 s->predictor_decode_stereo = predictor_decode_stereo_3800;

288 } else if (s->fileversion < 3950) {

289 s->predictor_decode_mono = predictor_decode_mono_3930;

290 s->predictor_decode_stereo = predictor_decode_stereo_3930;

291 } else {

292 s->predictor_decode_mono = predictor_decode_mono_3950;

293 s->predictor_decode_stereo = predictor_decode_stereo_3950;

294 }

295

296 ff_bswapdsp_init(&s->bdsp);

297 ff_llauddsp_init(&s->adsp);

298 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;

299

300 return 0;

301 filter_alloc_fail:

302 ape_decode_close(avctx);

303 return AVERROR(ENOMEM);

304 }

305

306 /**

307 * @name APE range decoding functions

308 * @{

309 */

310

311 #define CODE_BITS 32

312 #define TOP_VALUE ((unsigned int)1 << (CODE_BITS-1))

313 #define SHIFT_BITS (CODE_BITS - 9)

314 #define EXTRA_BITS ((CODE_BITS-2) % 8 + 1)

315 #define BOTTOM_VALUE (TOP_VALUE >> 8)

316

317 /** Start the decoder */

318 static inline void range_start_decoding(APEContext *ctx)

319 {

320 ctx->rc.buffer = bytestream_get_byte(&ctx->ptr);

321 ctx->rc.low = ctx->rc.buffer >> (8 - EXTRA_BITS);

322 ctx->rc.range = (uint32_t) 1 << EXTRA_BITS;

323 }

324

325 /** Perform normalization */

326 static inline void range_dec_normalize(APEContext *ctx)

327 {

328 while (ctx->rc.range <= BOTTOM_VALUE) {

329 ctx->rc.buffer <<= 8;

330 if(ctx->ptr < ctx->data_end) {

331 ctx->rc.buffer += *ctx->ptr;

332 ctx->ptr++;

333 } else {

334 ctx->error = 1;

335 }

336 ctx->rc.low = (ctx->rc.low << 8) | ((ctx->rc.buffer >> 1) & 0xFF);

337 ctx->rc.range <<= 8;

338 }

339 }

340

341 /**

342 * Calculate culmulative frequency for next symbol. Does NO update!

343 * @param ctx decoder context

344 * @param tot_f is the total frequency or (code_value)1<<shift

345 * @return the culmulative frequency

346 */

347 static inline int range_decode_culfreq(APEContext *ctx, int tot_f)

348 {

349 range_dec_normalize(ctx);

350 ctx->rc.help = ctx->rc.range / tot_f;

351 return ctx->rc.low / ctx->rc.help;

352 }

353

354 /**

355 * Decode value with given size in bits

356 * @param ctx decoder context

357 * @param shift number of bits to decode

358 */

359 static inline int range_decode_culshift(APEContext *ctx, int shift)

360 {

361 range_dec_normalize(ctx);

362 ctx->rc.help = ctx->rc.range >> shift;

363 return ctx->rc.low / ctx->rc.help;

364 }

365

366

367 /**

368 * Update decoding state

369 * @param ctx decoder context

370 * @param sy_f the interval length (frequency of the symbol)

371 * @param lt_f the lower end (frequency sum of < symbols)

372 */

373 static inline void range_decode_update(APEContext *ctx, int sy_f, int lt_f)

374 {

375 ctx->rc.low -= ctx->rc.help * lt_f;

376 ctx->rc.range = ctx->rc.help * sy_f;

377 }

378

379 /** Decode n bits (n <= 16) without modelling */

380 static inline int range_decode_bits(APEContext *ctx, int n)

381 {

382 int sym = range_decode_culshift(ctx, n);

383 range_decode_update(ctx, 1, sym);

384 return sym;

385 }

386

387

388 #define MODEL_ELEMENTS 64

389

390 /**

391 * Fixed probabilities for symbols in Monkey Audio version 3.97

392 */

393 static const uint16_t counts_3970[22] = {

394 0, 14824, 28224, 39348, 47855, 53994, 58171, 60926,

395 62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419,

396 65450, 65469, 65480, 65487, 65491, 65493,

397 };

398

399 /**

400 * Probability ranges for symbols in Monkey Audio version 3.97

401 */

402 static const uint16_t counts_diff_3970[21] = {

403 14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,

404 1104, 677, 415, 248, 150, 89, 54, 31,

405 19, 11, 7, 4, 2,

406 };

407

408 /**

409 * Fixed probabilities for symbols in Monkey Audio version 3.98

410 */

411 static const uint16_t counts_3980[22] = {

412 0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,

413 64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,

414 65485, 65488, 65490, 65491, 65492, 65493,

415 };

416

417 /**

418 * Probability ranges for symbols in Monkey Audio version 3.98

419 */

420 static const uint16_t counts_diff_3980[21] = {

421 19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,

422 261, 119, 65, 31, 19, 10, 6, 3,

423 3, 2, 1, 1, 1,

424 };

425

426 /**

427 * Decode symbol

428 * @param ctx decoder context

429 * @param counts probability range start position

430 * @param counts_diff probability range widths

431 */

432 static inline int range_get_symbol(APEContext *ctx,

433 const uint16_t counts[],

434 const uint16_t counts_diff[])

435 {

436 int symbol, cf;

437

438 cf = range_decode_culshift(ctx, 16);

439

440 if(cf > 65492){

441 symbol= cf - 65535 + 63;

442 range_decode_update(ctx, 1, cf);

443 if(cf > 65535)

444 ctx->error=1;

445 return symbol;

446 }

447 /* figure out the symbol inefficiently; a binary search would be much better */

448 for (symbol = 0; counts[symbol + 1] <= cf; symbol++);

449

450 range_decode_update(ctx, counts_diff[symbol], counts[symbol]);

451

452 return symbol;

453 }

454 /** @} */ // group rangecoder

455

456 static inline void update_rice(APERice *rice, unsigned int x)

457 {

458 int lim = rice->k ? (1 << (rice->k + 4)) : 0;

459 rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5);

460

461 if (rice->ksum < lim)

462 rice->k--;

463 else if (rice->ksum >= (1 << (rice->k + 5)))

464 rice->k++;

465 }

466

467 static inline int get_rice_ook(GetBitContext *gb, int k)

468 {

469 unsigned int x;

470

471 x = get_unary(gb, 1, get_bits_left(gb));

472

473 if (k)

474 x = (x << k) | get_bits(gb, k);

475

476 return x;

477 }

478

479 static inline int ape_decode_value_3860(APEContext *ctx, GetBitContext *gb,

480 APERice *rice)

481 {

482 unsigned int x, overflow;

483

484 overflow = get_unary(gb, 1, get_bits_left(gb));

485

486 if (ctx->fileversion > 3880) {

487 while (overflow >= 16) {

488 overflow -= 16;

489 rice->k += 4;

490 }

491 }

492

493 if (!rice->k)

494 x = overflow;

495 else if(rice->k <= MIN_CACHE_BITS) {

496 x = (overflow << rice->k) + get_bits(gb, rice->k);

497 } else {

498 av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", rice->k);

499 return AVERROR_INVALIDDATA;

500 }

501 rice->ksum += x - (rice->ksum + 8 >> 4);

502 if (rice->ksum < (rice->k ? 1 << (rice->k + 4) : 0))

503 rice->k--;

504 else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)

505 rice->k++;

506

507 /* Convert to signed */

508 return ((x >> 1) ^ ((x & 1) - 1)) + 1;

509 }

510

511 static inline int ape_decode_value_3900(APEContext *ctx, APERice *rice)

512 {

513 unsigned int x, overflow;

514 int tmpk;

515

516 overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);

517

518 if (overflow == (MODEL_ELEMENTS - 1)) {

519 tmpk = range_decode_bits(ctx, 5);

520 overflow = 0;

521 } else

522 tmpk = (rice->k < 1) ? 0 : rice->k - 1;

523

524 if (tmpk <= 16 || ctx->fileversion < 3910) {

525 if (tmpk > 23) {

526 av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);

527 return AVERROR_INVALIDDATA;

528 }

529 x = range_decode_bits(ctx, tmpk);

530 } else if (tmpk <= 31) {

531 x = range_decode_bits(ctx, 16);

532 x |= (range_decode_bits(ctx, tmpk - 16) << 16);

533 } else {

534 av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);

535 return AVERROR_INVALIDDATA;

536 }

537 x += overflow << tmpk;

538

539 update_rice(rice, x);

540

541 /* Convert to signed */

542 return ((x >> 1) ^ ((x & 1) - 1)) + 1;

543 }

544

545 static inline int ape_decode_value_3990(APEContext *ctx, APERice *rice)

546 {

547 unsigned int x, overflow;

548 int base, pivot;

549

550 pivot = rice->ksum >> 5;

551 if (pivot == 0)

552 pivot = 1;

553

554 overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980);

555

556 if (overflow == (MODEL_ELEMENTS - 1)) {

557 overflow = range_decode_bits(ctx, 16) << 16;

558 overflow |= range_decode_bits(ctx, 16);

559 }

560

561 if (pivot < 0x10000) {

562 base = range_decode_culfreq(ctx, pivot);

563 range_decode_update(ctx, 1, base);

564 } else {

565 int base_hi = pivot, base_lo;

566 int bbits = 0;

567

568 while (base_hi & ~0xFFFF) {

569 base_hi >>= 1;

570 bbits++;

571 }

572 base_hi = range_decode_culfreq(ctx, base_hi + 1);

573 range_decode_update(ctx, 1, base_hi);

574 base_lo = range_decode_culfreq(ctx, 1 << bbits);

575 range_decode_update(ctx, 1, base_lo);

576

577 base = (base_hi << bbits) + base_lo;

578 }

579

580 x = base + overflow * pivot;

581

582 update_rice(rice, x);

583

584 /* Convert to signed */

585 return ((x >> 1) ^ ((x & 1) - 1)) + 1;

586 }

587

588 static void decode_array_0000(APEContext *ctx, GetBitContext *gb,

589 int32_t *out, APERice *rice, int blockstodecode)

590 {

591 int i;

592 int ksummax, ksummin;

593

594 rice->ksum = 0;

595 for (i = 0; i < 5; i++) {

596 out[i] = get_rice_ook(&ctx->gb, 10);

597 rice->ksum += out[i];

598 }

599 rice->k = av_log2(rice->ksum / 10) + 1;

600 if (rice->k >= 24)

601 return;

602 for (; i < 64; i++) {

603 out[i] = get_rice_ook(&ctx->gb, rice->k);

604 rice->ksum += out[i];

605 rice->k = av_log2(rice->ksum / ((i + 1) * 2)) + 1;

606 if (rice->k >= 24)

607 return;

608 }

609 ksummax = 1 << rice->k + 7;

610 ksummin = rice->k ? (1 << rice->k + 6) : 0;

611 for (; i < blockstodecode; i++) {

612 out[i] = get_rice_ook(&ctx->gb, rice->k);

613 rice->ksum += out[i] - out[i - 64];

614 while (rice->ksum < ksummin) {

615 rice->k--;

616 ksummin = rice->k ? ksummin >> 1 : 0;

617 ksummax >>= 1;

618 }

619 while (rice->ksum >= ksummax) {

620 rice->k++;

621 if (rice->k > 24)

622 return;

623 ksummax <<= 1;

624 ksummin = ksummin ? ksummin << 1 : 128;

625 }

626 }

627

628 for (i = 0; i < blockstodecode; i++)

629 out[i] = ((out[i] >> 1) ^ ((out[i] & 1) - 1)) + 1;

630 }

631

632 static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode)

633 {

634 decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,

635 blockstodecode);

636 }

637

638 static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode)

639 {

640 decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,

641 blockstodecode);

642 decode_array_0000(ctx, &ctx->gb, ctx->decoded[1], &ctx->riceX,

643 blockstodecode);

644 }

645

646 static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode)

647 {

648 int32_t *decoded0 = ctx->decoded[0];

649

650 while (blockstodecode--)

651 *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);

652 }

653

654 static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode)

655 {

656 int32_t *decoded0 = ctx->decoded[0];

657 int32_t *decoded1 = ctx->decoded[1];

658 int blocks = blockstodecode;

659

660 while (blockstodecode--)

661 *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);

662 while (blocks--)

663 *decoded1++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceX);

664 }

665

666 static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode)

667 {

668 int32_t *decoded0 = ctx->decoded[0];

669

670 while (blockstodecode--)

671 *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);

672 }

673

674 static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode)

675 {

676 int32_t *decoded0 = ctx->decoded[0];

677 int32_t *decoded1 = ctx->decoded[1];

678 int blocks = blockstodecode;

679

680 while (blockstodecode--)

681 *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);

682 range_dec_normalize(ctx);

683 // because of some implementation peculiarities we need to backpedal here

684 ctx->ptr -= 1;

685 range_start_decoding(ctx);

686 while (blocks--)

687 *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);

688 }

689

690 static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode)

691 {

692 int32_t *decoded0 = ctx->decoded[0];

693 int32_t *decoded1 = ctx->decoded[1];

694

695 while (blockstodecode--) {

696 *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);

697 *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);

698 }

699 }

700

701 static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode)

702 {

703 int32_t *decoded0 = ctx->decoded[0];

704

705 while (blockstodecode--)

706 *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);

707 }

708

709 static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode)

710 {

711 int32_t *decoded0 = ctx->decoded[0];

712 int32_t *decoded1 = ctx->decoded[1];

713

714 while (blockstodecode--) {

715 *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);

716 *decoded1++ = ape_decode_value_3990(ctx, &ctx->riceX);

717 }

718 }

719

720 static int init_entropy_decoder(APEContext *ctx)

721 {

722 /* Read the CRC */

723 if (ctx->fileversion >= 3900) {

724 if (ctx->data_end - ctx->ptr < 6)

725 return AVERROR_INVALIDDATA;

726 ctx->CRC = bytestream_get_be32(&ctx->ptr);

727 } else {

728 ctx->CRC = get_bits_long(&ctx->gb, 32);

729 }

730

731 /* Read the frame flags if they exist */

732 ctx->frameflags = 0;

733 if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) {

734 ctx->CRC &= ~0x80000000;

735

736 if (ctx->data_end - ctx->ptr < 6)

737 return AVERROR_INVALIDDATA;

738 ctx->frameflags = bytestream_get_be32(&ctx->ptr);

739 }

740

741 /* Initialize the rice structs */

742 ctx->riceX.k = 10;

743 ctx->riceX.ksum = (1 << ctx->riceX.k) * 16;

744 ctx->riceY.k = 10;

745 ctx->riceY.ksum = (1 << ctx->riceY.k) * 16;

746

747 if (ctx->fileversion >= 3900) {

748 /* The first 8 bits of input are ignored. */

749 ctx->ptr++;

750

751 range_start_decoding(ctx);

752 }

753

754 return 0;

755 }

756

757 static const int32_t initial_coeffs_fast_3320[1] = {

758 375,

759 };

760

761 static const int32_t initial_coeffs_a_3800[3] = {

762 64, 115, 64,

763 };

764

765 static const int32_t initial_coeffs_b_3800[2] = {

766 740, 0

767 };

768

769 static const int32_t initial_coeffs_3930[4] = {

770 360, 317, -109, 98

771 };

772

773 static void init_predictor_decoder(APEContext *ctx)

774 {

775 APEPredictor *p = &ctx->predictor;

776

777 /* Zero the history buffers */

778 memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(*p->historybuffer));

779 p->buf = p->historybuffer;

780

781 /* Initialize and zero the coefficients */

782 if (ctx->fileversion < 3930) {

783 if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {

784 memcpy(p->coeffsA[0], initial_coeffs_fast_3320,

785 sizeof(initial_coeffs_fast_3320));

786 memcpy(p->coeffsA[1], initial_coeffs_fast_3320,

787 sizeof(initial_coeffs_fast_3320));

788 } else {

789 memcpy(p->coeffsA[0], initial_coeffs_a_3800,

790 sizeof(initial_coeffs_a_3800));

791 memcpy(p->coeffsA[1], initial_coeffs_a_3800,

792 sizeof(initial_coeffs_a_3800));

793 }

794 } else {

795 memcpy(p->coeffsA[0], initial_coeffs_3930, sizeof(initial_coeffs_3930));

796 memcpy(p->coeffsA[1], initial_coeffs_3930, sizeof(initial_coeffs_3930));

797 }

798 memset(p->coeffsB, 0, sizeof(p->coeffsB));

799 if (ctx->fileversion < 3930) {

800 memcpy(p->coeffsB[0], initial_coeffs_b_3800,

801 sizeof(initial_coeffs_b_3800));

802 memcpy(p->coeffsB[1], initial_coeffs_b_3800,

803 sizeof(initial_coeffs_b_3800));

804 }

805

806 p->filterA[0] = p->filterA[1] = 0;

807 p->filterB[0] = p->filterB[1] = 0;

808 p->lastA[0] = p->lastA[1] = 0;

809

810 p->sample_pos = 0;

811 }

812

813 /** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */

814 static inline int APESIGN(int32_t x) {

815 return (x < 0) - (x > 0);

816 }

817

818 static av_always_inline int filter_fast_3320(APEPredictor *p,

819 const int decoded, const int filter,

820 const int delayA)

821 {

822 int32_t predictionA;

823

824 p->buf[delayA] = p->lastA[filter];

825 if (p->sample_pos < 3) {

826 p->lastA[filter] = decoded;

827 p->filterA[filter] = decoded;

828 return decoded;

829 }

830

831 predictionA = p->buf[delayA] * 2 - p->buf[delayA - 1];

832 p->lastA[filter] = decoded + (predictionA * p->coeffsA[filter][0] >> 9);

833

834 if ((decoded ^ predictionA) > 0)

835 p->coeffsA[filter][0]++;

836 else

837 p->coeffsA[filter][0]--;

838

839 p->filterA[filter] += p->lastA[filter];

840

841 return p->filterA[filter];

842 }

843

844 static av_always_inline int filter_3800(APEPredictor *p,

845 const int decoded, const int filter,

846 const int delayA, const int delayB,

847 const int start, const int shift)

848 {

849 int32_t predictionA, predictionB, sign;

850 int32_t d0, d1, d2, d3, d4;

851

852 p->buf[delayA] = p->lastA[filter];

853 p->buf[delayB] = p->filterB[filter];

854 if (p->sample_pos < start) {

855 predictionA = decoded + p->filterA[filter];

856 p->lastA[filter] = decoded;

857 p->filterB[filter] = decoded;

858 p->filterA[filter] = predictionA;

859 return predictionA;

860 }

861 d2 = p->buf[delayA];

862 d1 = (p->buf[delayA] - p->buf[delayA - 1]) << 1;

863 d0 = p->buf[delayA] + ((p->buf[delayA - 2] - p->buf[delayA - 1]) << 3);

864 d3 = p->buf[delayB] * 2 - p->buf[delayB - 1];

865 d4 = p->buf[delayB];

866

867 predictionA = d0 * p->coeffsA[filter][0] +

868 d1 * p->coeffsA[filter][1] +

869 d2 * p->coeffsA[filter][2];

870

871 sign = APESIGN(decoded);

872 p->coeffsA[filter][0] += (((d0 >> 30) & 2) - 1) * sign;

873 p->coeffsA[filter][1] += (((d1 >> 28) & 8) - 4) * sign;

874 p->coeffsA[filter][2] += (((d2 >> 28) & 8) - 4) * sign;

875

876 predictionB = d3 * p->coeffsB[filter][0] -

877 d4 * p->coeffsB[filter][1];

878 p->lastA[filter] = decoded + (predictionA >> 11);

879 sign = APESIGN(p->lastA[filter]);

880 p->coeffsB[filter][0] += (((d3 >> 29) & 4) - 2) * sign;

881 p->coeffsB[filter][1] -= (((d4 >> 30) & 2) - 1) * sign;

882

883 p->filterB[filter] = p->lastA[filter] + (predictionB >> shift);

884 p->filterA[filter] = p->filterB[filter] + ((p->filterA[filter] * 31) >> 5);

885

886 return p->filterA[filter];

887 }

888

889 static void long_filter_high_3800(int32_t *buffer, int order, int shift, int length)

890 {

891 int i, j;

892 int32_t dotprod, sign;

893 int32_t coeffs[256], delay[256];

894

895 memset(coeffs, 0, order * sizeof(*coeffs));

896 for (i = 0; i < order; i++)

897 delay[i] = buffer[i];

898 for (i = order; i < length; i++) {

899 dotprod = 0;

900 sign = APESIGN(buffer[i]);

901 for (j = 0; j < order; j++) {

902 dotprod += delay[j] * coeffs[j];

903 coeffs[j] += ((delay[j] >> 31) | 1) * sign;

904 }

905 buffer[i] -= dotprod >> shift;

906 for (j = 0; j < order - 1; j++)

907 delay[j] = delay[j + 1];

908 delay[order - 1] = buffer[i];

909 }

910 }

911

912 static void long_filter_ehigh_3830(int32_t *buffer, int length)

913 {

914 int i, j;

915 int32_t dotprod, sign;

916 int32_t coeffs[8] = { 0 }, delay[8] = { 0 };

917

918 for (i = 0; i < length; i++) {

919 dotprod = 0;

920 sign = APESIGN(buffer[i]);

921 for (j = 7; j >= 0; j--) {

922 dotprod += delay[j] * coeffs[j];

923 coeffs[j] += ((delay[j] >> 31) | 1) * sign;

924 }

925 for (j = 7; j > 0; j--)

926 delay[j] = delay[j - 1];

927 delay[0] = buffer[i];

928 buffer[i] -= dotprod >> 9;

929 }

930 }

931

932 static void predictor_decode_stereo_3800(APEContext *ctx, int count)

933 {

934 APEPredictor *p = &ctx->predictor;

935 int32_t *decoded0 = ctx->decoded[0];

936 int32_t *decoded1 = ctx->decoded[1];

937 int start = 4, shift = 10;

938

939 if (ctx->compression_level == COMPRESSION_LEVEL_HIGH) {

940 start = 16;

941 long_filter_high_3800(decoded0, 16, 9, count);

942 long_filter_high_3800(decoded1, 16, 9, count);

943 } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {

944 int order = 128, shift2 = 11;

945

946 if (ctx->fileversion >= 3830) {

947 order <<= 1;

948 shift++;

949 shift2++;

950 long_filter_ehigh_3830(decoded0 + order, count - order);

951 long_filter_ehigh_3830(decoded1 + order, count - order);

952 }

953 start = order;

954 long_filter_high_3800(decoded0, order, shift2, count);

955 long_filter_high_3800(decoded1, order, shift2, count);

956 }

957

958 while (count--) {

959 int X = *decoded0, Y = *decoded1;

960 if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {

961 *decoded0 = filter_fast_3320(p, Y, 0, YDELAYA);

962 decoded0++;

963 *decoded1 = filter_fast_3320(p, X, 1, XDELAYA);

964 decoded1++;

965 } else {

966 *decoded0 = filter_3800(p, Y, 0, YDELAYA, YDELAYB,

967 start, shift);

968 decoded0++;

969 *decoded1 = filter_3800(p, X, 1, XDELAYA, XDELAYB,

970 start, shift);

971 decoded1++;

972 }

973

974 /* Combined */

975 p->buf++;

976 p->sample_pos++;

977

978 /* Have we filled the history buffer? */

979 if (p->buf == p->historybuffer + HISTORY_SIZE) {

980 memmove(p->historybuffer, p->buf,

981 PREDICTOR_SIZE * sizeof(*p->historybuffer));

982 p->buf = p->historybuffer;

983 }

984 }

985 }

986

987 static void predictor_decode_mono_3800(APEContext *ctx, int count)

988 {

989 APEPredictor *p = &ctx->predictor;

990 int32_t *decoded0 = ctx->decoded[0];

991 int start = 4, shift = 10;

992

993 if (ctx->compression_level == COMPRESSION_LEVEL_HIGH) {

994 start = 16;

995 long_filter_high_3800(decoded0, 16, 9, count);

996 } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {

997 int order = 128, shift2 = 11;

998

999 if (ctx->fileversion >= 3830) {

1000 order <<= 1;

1001 shift++;

1002 shift2++;

1003 long_filter_ehigh_3830(decoded0 + order, count - order);

1004 }

1005 start = order;

1006 long_filter_high_3800(decoded0, order, shift2, count);

1007 }

1008

1009 while (count--) {

1010 if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {

1011 *decoded0 = filter_fast_3320(p, *decoded0, 0, YDELAYA);

1012 decoded0++;

1013 } else {

1014 *decoded0 = filter_3800(p, *decoded0, 0, YDELAYA, YDELAYB,

1015 start, shift);

1016 decoded0++;

1017 }

1018

1019 /* Combined */

1020 p->buf++;

1021 p->sample_pos++;

1022

1023 /* Have we filled the history buffer? */

1024 if (p->buf == p->historybuffer + HISTORY_SIZE) {

1025 memmove(p->historybuffer, p->buf,

1026 PREDICTOR_SIZE * sizeof(*p->historybuffer));

1027 p->buf = p->historybuffer;

1028 }

1029 }

1030 }

1031

1032 static av_always_inline int predictor_update_3930(APEPredictor *p,

1033 const int decoded, const int filter,

1034 const int delayA)

1035 {

1036 int32_t predictionA, sign;

1037 int32_t d0, d1, d2, d3;

1038

1039 p->buf[delayA] = p->lastA[filter];

1040 d0 = p->buf[delayA ];

1041 d1 = p->buf[delayA ] - p->buf[delayA - 1];

1042 d2 = p->buf[delayA - 1] - p->buf[delayA - 2];

1043 d3 = p->buf[delayA - 2] - p->buf[delayA - 3];

1044

1045 predictionA = d0 * p->coeffsA[filter][0] +

1046 d1 * p->coeffsA[filter][1] +

1047 d2 * p->coeffsA[filter][2] +

1048 d3 * p->coeffsA[filter][3];

1049

1050 p->lastA[filter] = decoded + (predictionA >> 9);

1051 p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);

1052

1053 sign = APESIGN(decoded);

1054 p->coeffsA[filter][0] += ((d0 < 0) * 2 - 1) * sign;

1055 p->coeffsA[filter][1] += ((d1 < 0) * 2 - 1) * sign;

1056 p->coeffsA[filter][2] += ((d2 < 0) * 2 - 1) * sign;

1057 p->coeffsA[filter][3] += ((d3 < 0) * 2 - 1) * sign;

1058

1059 return p->filterA[filter];

1060 }

1061

1062 static void predictor_decode_stereo_3930(APEContext *ctx, int count)

1063 {

1064 APEPredictor *p = &ctx->predictor;

1065 int32_t *decoded0 = ctx->decoded[0];

1066 int32_t *decoded1 = ctx->decoded[1];

1067

1068 ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);

1069

1070 while (count--) {

1071 /* Predictor Y */

1072 int Y = *decoded1, X = *decoded0;

1073 *decoded0 = predictor_update_3930(p, Y, 0, YDELAYA);

1074 decoded0++;

1075 *decoded1 = predictor_update_3930(p, X, 1, XDELAYA);

1076 decoded1++;

1077

1078 /* Combined */

1079 p->buf++;

1080

1081 /* Have we filled the history buffer? */

1082 if (p->buf == p->historybuffer + HISTORY_SIZE) {

1083 memmove(p->historybuffer, p->buf,

1084 PREDICTOR_SIZE * sizeof(*p->historybuffer));

1085 p->buf = p->historybuffer;

1086 }

1087 }

1088 }

1089

1090 static void predictor_decode_mono_3930(APEContext *ctx, int count)

1091 {

1092 APEPredictor *p = &ctx->predictor;

1093 int32_t *decoded0 = ctx->decoded[0];

1094

1095 ape_apply_filters(ctx, ctx->decoded[0], NULL, count);

1096

1097 while (count--) {

1098 *decoded0 = predictor_update_3930(p, *decoded0, 0, YDELAYA);

1099 decoded0++;

1100

1101 p->buf++;

1102

1103 /* Have we filled the history buffer? */

1104 if (p->buf == p->historybuffer + HISTORY_SIZE) {

1105 memmove(p->historybuffer, p->buf,

1106 PREDICTOR_SIZE * sizeof(*p->historybuffer));

1107 p->buf = p->historybuffer;

1108 }

1109 }

1110 }

1111

1112 static av_always_inline int predictor_update_filter(APEPredictor *p,

1113 const int decoded, const int filter,

1114 const int delayA, const int delayB,

1115 const int adaptA, const int adaptB)

1116 {

1117 int32_t predictionA, predictionB, sign;

1118

1119 p->buf[delayA] = p->lastA[filter];

1120 p->buf[adaptA] = APESIGN(p->buf[delayA]);

1121 p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1];

1122 p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);

1123

1124 predictionA = p->buf[delayA ] * p->coeffsA[filter][0] +

1125 p->buf[delayA - 1] * p->coeffsA[filter][1] +

1126 p->buf[delayA - 2] * p->coeffsA[filter][2] +

1127 p->buf[delayA - 3] * p->coeffsA[filter][3];

1128

1129 /* Apply a scaled first-order filter compression */

1130 p->buf[delayB] = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5);

1131 p->buf[adaptB] = APESIGN(p->buf[delayB]);

1132 p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1];

1133 p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);

1134 p->filterB[filter] = p->filterA[filter ^ 1];

1135

1136 predictionB = p->buf[delayB ] * p->coeffsB[filter][0] +

1137 p->buf[delayB - 1] * p->coeffsB[filter][1] +

1138 p->buf[delayB - 2] * p->coeffsB[filter][2] +

1139 p->buf[delayB - 3] * p->coeffsB[filter][3] +

1140 p->buf[delayB - 4] * p->coeffsB[filter][4];

1141

1142 p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);

1143 p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);

1144

1145 sign = APESIGN(decoded);

1146 p->coeffsA[filter][0] += p->buf[adaptA ] * sign;

1147 p->coeffsA[filter][1] += p->buf[adaptA - 1] * sign;

1148 p->coeffsA[filter][2] += p->buf[adaptA - 2] * sign;

1149 p->coeffsA[filter][3] += p->buf[adaptA - 3] * sign;

1150 p->coeffsB[filter][0] += p->buf[adaptB ] * sign;

1151 p->coeffsB[filter][1] += p->buf[adaptB - 1] * sign;

1152 p->coeffsB[filter][2] += p->buf[adaptB - 2] * sign;

1153 p->coeffsB[filter][3] += p->buf[adaptB - 3] * sign;

1154 p->coeffsB[filter][4] += p->buf[adaptB - 4] * sign;

1155

1156 return p->filterA[filter];

1157 }

1158

1159 static void predictor_decode_stereo_3950(APEContext *ctx, int count)

1160 {

1161 APEPredictor *p = &ctx->predictor;

1162 int32_t *decoded0 = ctx->decoded[0];

1163 int32_t *decoded1 = ctx->decoded[1];

1164

1165 ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);

1166

1167 while (count--) {

1168 /* Predictor Y */

1169 *decoded0 = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB,

1170 YADAPTCOEFFSA, YADAPTCOEFFSB);

1171 decoded0++;

1172 *decoded1 = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB,

1173 XADAPTCOEFFSA, XADAPTCOEFFSB);

1174 decoded1++;

1175

1176 /* Combined */

1177 p->buf++;

1178

1179 /* Have we filled the history buffer? */

1180 if (p->buf == p->historybuffer + HISTORY_SIZE) {

1181 memmove(p->historybuffer, p->buf,

1182 PREDICTOR_SIZE * sizeof(*p->historybuffer));

1183 p->buf = p->historybuffer;

1184 }

1185 }

1186 }

1187

1188 static void predictor_decode_mono_3950(APEContext *ctx, int count)

1189 {

1190 APEPredictor *p = &ctx->predictor;

1191 int32_t *decoded0 = ctx->decoded[0];

1192 int32_t predictionA, currentA, A, sign;

1193

1194 ape_apply_filters(ctx, ctx->decoded[0], NULL, count);

1195

1196 currentA = p->lastA[0];

1197

1198 while (count--) {

1199 A = *decoded0;

1200

1201 p->buf[YDELAYA] = currentA;

1202 p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];

1203

1204 predictionA = p->buf[YDELAYA ] * p->coeffsA[0][0] +

1205 p->buf[YDELAYA - 1] * p->coeffsA[0][1] +

1206 p->buf[YDELAYA - 2] * p->coeffsA[0][2] +

1207 p->buf[YDELAYA - 3] * p->coeffsA[0][3];

1208

1209 currentA = A + (predictionA >> 10);

1210

1211 p->buf[YADAPTCOEFFSA] = APESIGN(p->buf[YDELAYA ]);

1212 p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);

1213

1214 sign = APESIGN(A);

1215 p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA ] * sign;

1216 p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1] * sign;

1217 p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2] * sign;

1218 p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3] * sign;

1219

1220 p->buf++;

1221

1222 /* Have we filled the history buffer? */

1223 if (p->buf == p->historybuffer + HISTORY_SIZE) {

1224 memmove(p->historybuffer, p->buf,

1225 PREDICTOR_SIZE * sizeof(*p->historybuffer));

1226 p->buf = p->historybuffer;

1227 }

1228

1229 p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5);

1230 *(decoded0++) = p->filterA[0];

1231 }

1232

1233 p->lastA[0] = currentA;

1234 }

1235

1236 static void do_init_filter(APEFilter *f, int16_t *buf, int order)

1237 {

1238 f->coeffs = buf;

1239 f->historybuffer = buf + order;

1240 f->delay = f->historybuffer + order * 2;

1241 f->adaptcoeffs = f->historybuffer + order;

1242

1243 memset(f->historybuffer, 0, (order * 2) * sizeof(*f->historybuffer));

1244 memset(f->coeffs, 0, order * sizeof(*f->coeffs));

1245 f->avg = 0;

1246 }

1247

1248 static void init_filter(APEContext *ctx, APEFilter *f, int16_t *buf, int order)

1249 {

1250 do_init_filter(&f[0], buf, order);

1251 do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order);

1252 }

1253

1254 static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,

1255 int32_t *data, int count, int order, int fracbits)

1256 {

1257 int res;

1258 int absres;

1259

1260 while (count--) {

1261 /* round fixedpoint scalar product */

1262 res = ctx->adsp.scalarproduct_and_madd_int16(f->coeffs,

1263 f->delay - order,

1264 f->adaptcoeffs - order,

1265 order, APESIGN(*data));

1266 res = (res + (1 << (fracbits - 1))) >> fracbits;

1267 res += *data;

1268 *data++ = res;

1269

1270 /* Update the output history */

1271 *f->delay++ = av_clip_int16(res);

1272

1273 if (version < 3980) {

1274 /* Version ??? to < 3.98 files (untested) */

1275 f->adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4;

1276 f->adaptcoeffs[-4] >>= 1;

1277 f->adaptcoeffs[-8] >>= 1;

1278 } else {

1279 /* Version 3.98 and later files */

1280

1281 /* Update the adaption coefficients */

1282 absres = FFABS(res);

1283 if (absres)

1284 *f->adaptcoeffs = ((res & (-1<<31)) ^ (-1<<30)) >>

1285 (25 + (absres <= f->avg*3) + (absres <= f->avg*4/3));

1286 else

1287 *f->adaptcoeffs = 0;

1288

1289 f->avg += (absres - f->avg) / 16;

1290

1291 f->adaptcoeffs[-1] >>= 1;

1292 f->adaptcoeffs[-2] >>= 1;

1293 f->adaptcoeffs[-8] >>= 1;

1294 }

1295

1296 f->adaptcoeffs++;

1297

1298 /* Have we filled the history buffer? */

1299 if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {

1300 memmove(f->historybuffer, f->delay - (order * 2),

1301 (order * 2) * sizeof(*f->historybuffer));

1302 f->delay = f->historybuffer + order * 2;

1303 f->adaptcoeffs = f->historybuffer + order;

1304 }

1305 }

1306 }

1307

1308 static void apply_filter(APEContext *ctx, APEFilter *f,

1309 int32_t *data0, int32_t *data1,

1310 int count, int order, int fracbits)

1311 {

1312 do_apply_filter(ctx, ctx->fileversion, &f[0], data0, count, order, fracbits);

1313 if (data1)

1314 do_apply_filter(ctx, ctx->fileversion, &f[1], data1, count, order, fracbits);

1315 }

1316

1317 static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,

1318 int32_t *decoded1, int count)

1319 {

1320 int i;

1321

1322 for (i = 0; i < APE_FILTER_LEVELS; i++) {

1323 if (!ape_filter_orders[ctx->fset][i])

1324 break;

1325 apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count,

1326 ape_filter_orders[ctx->fset][i],

1327 ape_filter_fracbits[ctx->fset][i]);

1328 }

1329 }

1330

1331 static int init_frame_decoder(APEContext *ctx)

1332 {

1333 int i, ret;

1334 if ((ret = init_entropy_decoder(ctx)) < 0)

1335 return ret;

1336 init_predictor_decoder(ctx);

1337

1338 for (i = 0; i < APE_FILTER_LEVELS; i++) {

1339 if (!ape_filter_orders[ctx->fset][i])

1340 break;

1341 init_filter(ctx, ctx->filters[i], ctx->filterbuf[i],

1342 ape_filter_orders[ctx->fset][i]);

1343 }

1344 return 0;

1345 }

1346

1347 static void ape_unpack_mono(APEContext *ctx, int count)

1348 {

1349 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {

1350 /* We are pure silence, so we're done. */

1351 av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");

1352 return;

1353 }

1354

1355 ctx->entropy_decode_mono(ctx, count);

1356

1357 /* Now apply the predictor decoding */

1358 ctx->predictor_decode_mono(ctx, count);

1359

1360 /* Pseudo-stereo - just copy left channel to right channel */

1361 if (ctx->channels == 2) {

1362 memcpy(ctx->decoded[1], ctx->decoded[0], count * sizeof(*ctx->decoded[1]));

1363 }

1364 }

1365

1366 static void ape_unpack_stereo(APEContext *ctx, int count)

1367 {

1368 int32_t left, right;

1369 int32_t *decoded0 = ctx->decoded[0];

1370 int32_t *decoded1 = ctx->decoded[1];

1371

1372 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {

1373 /* We are pure silence, so we're done. */

1374 av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");

1375 return;

1376 }

1377

1378 ctx->entropy_decode_stereo(ctx, count);

1379

1380 /* Now apply the predictor decoding */

1381 ctx->predictor_decode_stereo(ctx, count);

1382

1383 /* Decorrelate and scale to output depth */

1384 while (count--) {

1385 left = *decoded1 - (*decoded0 / 2);

1386 right = left + *decoded0;

1387

1388 *(decoded0++) = left;

1389 *(decoded1++) = right;

1390 }

1391 }

1392

1393 static int ape_decode_frame(AVCodecContext *avctx, void *data,

1394 int *got_frame_ptr, AVPacket *avpkt)

1395 {

1396 AVFrame *frame = data;

1397 const uint8_t *buf = avpkt->data;

1398 APEContext *s = avctx->priv_data;

1399 uint8_t *sample8;

1400 int16_t *sample16;

1401 int32_t *sample24;

1402 int i, ch, ret;

1403 int blockstodecode;

1404

1405 /* this should never be negative, but bad things will happen if it is, so

1406 check it just to make sure. */

1407 av_assert0(s->samples >= 0);

1408

1409 if(!s->samples){

1410 uint32_t nblocks, offset;

1411 int buf_size;

1412

1413 if (!avpkt->size) {

1414 *got_frame_ptr = 0;

1415 return 0;

1416 }

1417 if (avpkt->size < 8) {

1418 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

1419 return AVERROR_INVALIDDATA;

1420 }

1421 buf_size = avpkt->size & ~3;

1422 if (buf_size != avpkt->size) {

1423 av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. "

1424 "extra bytes at the end will be skipped.\n");

1425 }

1426 if (s->fileversion < 3950) // previous versions overread two bytes

1427 buf_size += 2;

1428 av_fast_padded_malloc(&s->data, &s->data_size, buf_size);

1429 if (!s->data)

1430 return AVERROR(ENOMEM);

1431 s->bdsp.bswap_buf((uint32_t *) s->data, (const uint32_t *) buf,

1432 buf_size >> 2);

1433 memset(s->data + (buf_size & ~3), 0, buf_size & 3);

1434 s->ptr = s->data;

1435 s->data_end = s->data + buf_size;

1436

1437 nblocks = bytestream_get_be32(&s->ptr);

1438 offset = bytestream_get_be32(&s->ptr);

1439 if (s->fileversion >= 3900) {

1440 if (offset > 3) {

1441 av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");

1442 s->data = NULL;

1443 return AVERROR_INVALIDDATA;

1444 }

1445 if (s->data_end - s->ptr < offset) {

1446 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

1447 return AVERROR_INVALIDDATA;

1448 }

1449 s->ptr += offset;

1450 } else {

1451 if ((ret = init_get_bits8(&s->gb, s->ptr, s->data_end - s->ptr)) < 0)

1452 return ret;

1453 if (s->fileversion > 3800)

1454 skip_bits_long(&s->gb, offset * 8);

1455 else

1456 skip_bits_long(&s->gb, offset);

1457 }

1458

1459 if (!nblocks || nblocks > INT_MAX) {

1460 av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",

1461 nblocks);

1462 return AVERROR_INVALIDDATA;

1463 }

1464 s->samples = nblocks;

1465

1466 /* Initialize the frame decoder */

1467 if (init_frame_decoder(s) < 0) {

1468 av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");

1469 return AVERROR_INVALIDDATA;

1470 }

1471 }

1472

1473 if (!s->data) {

1474 *got_frame_ptr = 0;

1475 return avpkt->size;

1476 }

1477

1478 blockstodecode = FFMIN(s->blocks_per_loop, s->samples);

1479 // for old files coefficients were not interleaved,

1480 // so we need to decode all of them at once

1481 if (s->fileversion < 3930)

1482 blockstodecode = s->samples;

1483

1484 /* reallocate decoded sample buffer if needed */

1485 av_fast_malloc(&s->decoded_buffer, &s->decoded_size,

1486 2 * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer));

1487 if (!s->decoded_buffer)

1488 return AVERROR(ENOMEM);

1489 memset(s->decoded_buffer, 0, s->decoded_size);

1490 s->decoded[0] = s->decoded_buffer;

1491 s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);

1492

1493 /* get output buffer */

1494 frame->nb_samples = blockstodecode;

1495 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

1496 return ret;

1497

1498 s->error=0;

1499

1500 if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))

1501 ape_unpack_mono(s, blockstodecode);

1502 else

1503 ape_unpack_stereo(s, blockstodecode);

1504 emms_c();

1505

1506 if (s->error) {

1507 s->samples=0;

1508 av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");

1509 return AVERROR_INVALIDDATA;

1510 }

1511

1512 switch (s->bps) {

1513 case 8:

1514 for (ch = 0; ch < s->channels; ch++) {

1515 sample8 = (uint8_t *)frame->data[ch];

1516 for (i = 0; i < blockstodecode; i++)

1517 *sample8++ = (s->decoded[ch][i] + 0x80) & 0xff;

1518 }

1519 break;

1520 case 16:

1521 for (ch = 0; ch < s->channels; ch++) {

1522 sample16 = (int16_t *)frame->data[ch];

1523 for (i = 0; i < blockstodecode; i++)

1524 *sample16++ = s->decoded[ch][i];

1525 }

1526 break;

1527 case 24:

1528 for (ch = 0; ch < s->channels; ch++) {

1529 sample24 = (int32_t *)frame->data[ch];

1530 for (i = 0; i < blockstodecode; i++)

1531 *sample24++ = s->decoded[ch][i] << 8;

1532 }

1533 break;

1534 }

1535

1536 s->samples -= blockstodecode;

1537

1538 *got_frame_ptr = 1;

1539

1540 return !s->samples ? avpkt->size : 0;

1541 }

1542

1543 static void ape_flush(AVCodecContext *avctx)

1544 {

1545 APEContext *s = avctx->priv_data;

1546 s->samples= 0;

1547 }

1548

1549 #define OFFSET(x) offsetof(APEContext, x)

1550 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)

1551 static const AVOption options[] = {

1552 { "max_samples", "maximum number of samples decoded per call", OFFSET(blocks_per_loop), AV_OPT_TYPE_INT, { .i64 = 4608 }, 1, INT_MAX, PAR, "max_samples" },

1553 { "all", "no maximum. decode all samples for each packet at once", 0, AV_OPT_TYPE_CONST, { .i64 = INT_MAX }, INT_MIN, INT_MAX, PAR, "max_samples" },

1554 { NULL},

1555 };

1556

1557 static const AVClass ape_decoder_class = {

1558 .class_name = "APE decoder",

1559 .item_name = av_default_item_name,

1560 .option = options,

1561 .version = LIBAVUTIL_VERSION_INT,

1562 };

1563

1564 AVCodec ff_ape_decoder = {

1565 .name = "ape",