1/* 2 * COOK compatible decoder 3 * Copyright (c) 2003 Sascha Sommer 4 * Copyright (c) 2005 Benjamin Larsson 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 */ 22 23/** 24 * @file 25 * Cook compatible decoder. Bastardization of the G.722.1 standard. 26 * This decoder handles RealNetworks, RealAudio G2 data. 27 * Cook is identified by the codec name cook in RM files. 28 * 29 * To use this decoder, a calling application must supply the extradata 30 * bytes provided from the RM container; 8+ bytes for mono streams and 31 * 16+ for stereo streams (maybe more). 32 * 33 * Codec technicalities (all this assume a buffer length of 1024): 34 * Cook works with several different techniques to achieve its compression. 35 * In the timedomain the buffer is divided into 8 pieces and quantized. If 36 * two neighboring pieces have different quantization index a smooth 37 * quantization curve is used to get a smooth overlap between the different 38 * pieces. 39 * To get to the transformdomain Cook uses a modulated lapped transform. 40 * The transform domain has 50 subbands with 20 elements each. This 41 * means only a maximum of 50*20=1000 coefficients are used out of the 1024 42 * available. 43 */ 44 45#include "libavutil/channel_layout.h" 46#include "libavutil/lfg.h" 47#include "libavutil/mem_internal.h" 48#include "libavutil/thread.h" 49 50#include "audiodsp.h" 51#include "avcodec.h" 52#include "get_bits.h" 53#include "bytestream.h" 54#include "codec_internal.h" 55#include "fft.h" 56#include "internal.h" 57#include "sinewin.h" 58#include "unary.h" 59 60#include "cookdata.h" 61 62/* the different Cook versions */ 63#define MONO 0x1000001 64#define STEREO 0x1000002 65#define JOINT_STEREO 0x1000003 66#define MC_COOK 0x2000000 67 68#define SUBBAND_SIZE 20 69#define MAX_SUBPACKETS 5 70 71#define QUANT_VLC_BITS 9 72#define COUPLING_VLC_BITS 6 73 74typedef struct cook_gains { 75 int *now; 76 int *previous; 77} cook_gains; 78 79typedef struct COOKSubpacket { 80 int ch_idx; 81 int size; 82 int num_channels; 83 int cookversion; 84 int subbands; 85 int js_subband_start; 86 int js_vlc_bits; 87 int samples_per_channel; 88 int log2_numvector_size; 89 unsigned int channel_mask; 90 VLC channel_coupling; 91 int joint_stereo; 92 int bits_per_subpacket; 93 int bits_per_subpdiv; 94 int total_subbands; 95 int numvector_size; // 1 << log2_numvector_size; 96 97 float mono_previous_buffer1[1024]; 98 float mono_previous_buffer2[1024]; 99 100 cook_gains gains1; 101 cook_gains gains2; 102 int gain_1[9]; 103 int gain_2[9]; 104 int gain_3[9]; 105 int gain_4[9]; 106} COOKSubpacket; 107 108typedef struct cook { 109 /* 110 * The following 5 functions provide the lowlevel arithmetic on 111 * the internal audio buffers. 112 */ 113 void (*scalar_dequant)(struct cook *q, int index, int quant_index, 114 int *subband_coef_index, int *subband_coef_sign, 115 float *mlt_p); 116 117 void (*decouple)(struct cook *q, 118 COOKSubpacket *p, 119 int subband, 120 float f1, float f2, 121 float *decode_buffer, 122 float *mlt_buffer1, float *mlt_buffer2); 123 124 void (*imlt_window)(struct cook *q, float *buffer1, 125 cook_gains *gains_ptr, float *previous_buffer); 126 127 void (*interpolate)(struct cook *q, float *buffer, 128 int gain_index, int gain_index_next); 129 130 void (*saturate_output)(struct cook *q, float *out); 131 132 AVCodecContext* avctx; 133 AudioDSPContext adsp; 134 GetBitContext gb; 135 /* stream data */ 136 int num_vectors; 137 int samples_per_channel; 138 /* states */ 139 AVLFG random_state; 140 int discarded_packets; 141 142 /* transform data */ 143 FFTContext mdct_ctx; 144 float* mlt_window; 145 146 /* VLC data */ 147 VLC envelope_quant_index[13]; 148 VLC sqvh[7]; // scalar quantization 149 150 /* generate tables and related variables */ 151 int gain_size_factor; 152 float gain_table[31]; 153 154 /* data buffers */ 155 156 uint8_t* decoded_bytes_buffer; 157 DECLARE_ALIGNED(32, float, mono_mdct_output)[2048]; 158 float decode_buffer_1[1024]; 159 float decode_buffer_2[1024]; 160 float decode_buffer_0[1060]; /* static allocation for joint decode */ 161 162 const float *cplscales[5]; 163 int num_subpackets; 164 COOKSubpacket subpacket[MAX_SUBPACKETS]; 165} COOKContext; 166 167static float pow2tab[127]; 168static float rootpow2tab[127]; 169 170/*************** init functions ***************/ 171 172/* table generator */ 173static av_cold void init_pow2table(void) 174{ 175 /* fast way of computing 2^i and 2^(0.5*i) for -63 <= i < 64 */ 176 int i; 177 static const float exp2_tab[2] = {1, M_SQRT2}; 178 float exp2_val = powf(2, -63); 179 float root_val = powf(2, -32); 180 for (i = -63; i < 64; i++) { 181 if (!(i & 1)) 182 root_val *= 2; 183 pow2tab[63 + i] = exp2_val; 184 rootpow2tab[63 + i] = root_val * exp2_tab[i & 1]; 185 exp2_val *= 2; 186 } 187} 188 189/* table generator */ 190static av_cold void init_gain_table(COOKContext *q) 191{ 192 int i; 193 q->gain_size_factor = q->samples_per_channel / 8; 194 for (i = 0; i < 31; i++) 195 q->gain_table[i] = pow(pow2tab[i + 48], 196 (1.0 / (double) q->gain_size_factor)); 197} 198 199static av_cold int build_vlc(VLC *vlc, int nb_bits, const uint8_t counts[16], 200 const void *syms, int symbol_size, int offset, 201 void *logctx) 202{ 203 uint8_t lens[MAX_COOK_VLC_ENTRIES]; 204 unsigned num = 0; 205 206 for (int i = 0; i < 16; i++) 207 for (unsigned count = num + counts[i]; num < count; num++) 208 lens[num] = i + 1; 209 210 return ff_init_vlc_from_lengths(vlc, nb_bits, num, lens, 1, 211 syms, symbol_size, symbol_size, 212 offset, 0, logctx); 213} 214 215static av_cold int init_cook_vlc_tables(COOKContext *q) 216{ 217 int i, result; 218 219 result = 0; 220 for (i = 0; i < 13; i++) { 221 result |= build_vlc(&q->envelope_quant_index[i], QUANT_VLC_BITS, 222 envelope_quant_index_huffcounts[i], 223 envelope_quant_index_huffsyms[i], 1, -12, q->avctx); 224 } 225 av_log(q->avctx, AV_LOG_DEBUG, "sqvh VLC init\n"); 226 for (i = 0; i < 7; i++) { 227 int sym_size = 1 + (i == 3); 228 result |= build_vlc(&q->sqvh[i], vhvlcsize_tab[i], 229 cvh_huffcounts[i], 230 cvh_huffsyms[i], sym_size, 0, q->avctx); 231 } 232 233 for (i = 0; i < q->num_subpackets; i++) { 234 if (q->subpacket[i].joint_stereo == 1) { 235 result |= build_vlc(&q->subpacket[i].channel_coupling, COUPLING_VLC_BITS, 236 ccpl_huffcounts[q->subpacket[i].js_vlc_bits - 2], 237 ccpl_huffsyms[q->subpacket[i].js_vlc_bits - 2], 1, 238 0, q->avctx); 239 av_log(q->avctx, AV_LOG_DEBUG, "subpacket %i Joint-stereo VLC used.\n", i); 240 } 241 } 242 243 av_log(q->avctx, AV_LOG_DEBUG, "VLC tables initialized.\n"); 244 return result; 245} 246 247static av_cold int init_cook_mlt(COOKContext *q) 248{ 249 int j, ret; 250 int mlt_size = q->samples_per_channel; 251 252 if (!(q->mlt_window = av_malloc_array(mlt_size, sizeof(*q->mlt_window)))) 253 return AVERROR(ENOMEM); 254 255 /* Initialize the MLT window: simple sine window. */ 256 ff_sine_window_init(q->mlt_window, mlt_size); 257 for (j = 0; j < mlt_size; j++) 258 q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel); 259 260 /* Initialize the MDCT. */ 261 ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size) + 1, 1, 1.0 / 32768.0); 262 if (ret < 0) 263 return ret; 264 av_log(q->avctx, AV_LOG_DEBUG, "MDCT initialized, order = %d.\n", 265 av_log2(mlt_size) + 1); 266 267 return 0; 268} 269 270static av_cold void init_cplscales_table(COOKContext *q) 271{ 272 int i; 273 for (i = 0; i < 5; i++) 274 q->cplscales[i] = cplscales[i]; 275} 276 277/*************** init functions end ***********/ 278 279#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes) + 3) % 4) 280#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes))) 281 282/** 283 * Cook indata decoding, every 32 bits are XORed with 0x37c511f2. 284 * Why? No idea, some checksum/error detection method maybe. 285 * 286 * Out buffer size: extra bytes are needed to cope with 287 * padding/misalignment. 288 * Subpackets passed to the decoder can contain two, consecutive 289 * half-subpackets, of identical but arbitrary size. 290 * 1234 1234 1234 1234 extraA extraB 291 * Case 1: AAAA BBBB 0 0 292 * Case 2: AAAA ABBB BB-- 3 3 293 * Case 3: AAAA AABB BBBB 2 2 294 * Case 4: AAAA AAAB BBBB BB-- 1 5 295 * 296 * Nice way to waste CPU cycles. 297 * 298 * @param inbuffer pointer to byte array of indata 299 * @param out pointer to byte array of outdata 300 * @param bytes number of bytes 301 */ 302static inline int decode_bytes(const uint8_t *inbuffer, uint8_t *out, int bytes) 303{ 304 static const uint32_t tab[4] = { 305 AV_BE2NE32C(0x37c511f2u), AV_BE2NE32C(0xf237c511u), 306 AV_BE2NE32C(0x11f237c5u), AV_BE2NE32C(0xc511f237u), 307 }; 308 int i, off; 309 uint32_t c; 310 const uint32_t *buf; 311 uint32_t *obuf = (uint32_t *) out; 312 /* FIXME: 64 bit platforms would be able to do 64 bits at a time. 313 * I'm too lazy though, should be something like 314 * for (i = 0; i < bitamount / 64; i++) 315 * (int64_t) out[i] = 0x37c511f237c511f2 ^ av_be2ne64(int64_t) in[i]); 316 * Buffer alignment needs to be checked. */ 317 318 off = (intptr_t) inbuffer & 3; 319 buf = (const uint32_t *) (inbuffer - off); 320 c = tab[off]; 321 bytes += 3 + off; 322 for (i = 0; i < bytes / 4; i++) 323 obuf[i] = c ^ buf[i]; 324 325 return off; 326} 327 328static av_cold int cook_decode_close(AVCodecContext *avctx) 329{ 330 int i; 331 COOKContext *q = avctx->priv_data; 332 av_log(avctx, AV_LOG_DEBUG, "Deallocating memory.\n"); 333 334 /* Free allocated memory buffers. */ 335 av_freep(&q->mlt_window); 336 av_freep(&q->decoded_bytes_buffer); 337 338 /* Free the transform. */ 339 ff_mdct_end(&q->mdct_ctx); 340 341 /* Free the VLC tables. */ 342 for (i = 0; i < 13; i++) 343 ff_free_vlc(&q->envelope_quant_index[i]); 344 for (i = 0; i < 7; i++) 345 ff_free_vlc(&q->sqvh[i]); 346 for (i = 0; i < q->num_subpackets; i++) 347 ff_free_vlc(&q->subpacket[i].channel_coupling); 348 349 av_log(avctx, AV_LOG_DEBUG, "Memory deallocated.\n"); 350 351 return 0; 352} 353 354/** 355 * Fill the gain array for the timedomain quantization. 356 * 357 * @param gb pointer to the GetBitContext 358 * @param gaininfo array[9] of gain indexes 359 */ 360static void decode_gain_info(GetBitContext *gb, int *gaininfo) 361{ 362 int i, n; 363 364 n = get_unary(gb, 0, get_bits_left(gb)); // amount of elements*2 to update 365 366 i = 0; 367 while (n--) { 368 int index = get_bits(gb, 3); 369 int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1; 370 371 while (i <= index) 372 gaininfo[i++] = gain; 373 } 374 while (i <= 8) 375 gaininfo[i++] = 0; 376} 377 378/** 379 * Create the quant index table needed for the envelope. 380 * 381 * @param q pointer to the COOKContext 382 * @param quant_index_table pointer to the array 383 */ 384static int decode_envelope(COOKContext *q, COOKSubpacket *p, 385 int *quant_index_table) 386{ 387 int i, j, vlc_index; 388 389 quant_index_table[0] = get_bits(&q->gb, 6) - 6; // This is used later in categorize 390 391 for (i = 1; i < p->total_subbands; i++) { 392 vlc_index = i; 393 if (i >= p->js_subband_start * 2) { 394 vlc_index -= p->js_subband_start; 395 } else { 396 vlc_index /= 2; 397 if (vlc_index < 1) 398 vlc_index = 1; 399 } 400 if (vlc_index > 13) 401 vlc_index = 13; // the VLC tables >13 are identical to No. 13 402 403 j = get_vlc2(&q->gb, q->envelope_quant_index[vlc_index - 1].table, 404 QUANT_VLC_BITS, 2); 405 quant_index_table[i] = quant_index_table[i - 1] + j; // differential encoding 406 if (quant_index_table[i] > 63 || quant_index_table[i] < -63) { 407 av_log(q->avctx, AV_LOG_ERROR, 408 "Invalid quantizer %d at position %d, outside [-63, 63] range\n", 409 quant_index_table[i], i); 410 return AVERROR_INVALIDDATA; 411 } 412 } 413 414 return 0; 415} 416 417/** 418 * Calculate the category and category_index vector. 419 * 420 * @param q pointer to the COOKContext 421 * @param quant_index_table pointer to the array 422 * @param category pointer to the category array 423 * @param category_index pointer to the category_index array 424 */ 425static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_table, 426 int *category, int *category_index) 427{ 428 int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j; 429 int exp_index2[102] = { 0 }; 430 int exp_index1[102] = { 0 }; 431 432 int tmp_categorize_array[128 * 2] = { 0 }; 433 int tmp_categorize_array1_idx = p->numvector_size; 434 int tmp_categorize_array2_idx = p->numvector_size; 435 436 bits_left = p->bits_per_subpacket - get_bits_count(&q->gb); 437 438 if (bits_left > q->samples_per_channel) 439 bits_left = q->samples_per_channel + 440 ((bits_left - q->samples_per_channel) * 5) / 8; 441 442 bias = -32; 443 444 /* Estimate bias. */ 445 for (i = 32; i > 0; i = i / 2) { 446 num_bits = 0; 447 index = 0; 448 for (j = p->total_subbands; j > 0; j--) { 449 exp_idx = av_clip_uintp2((i - quant_index_table[index] + bias) / 2, 3); 450 index++; 451 num_bits += expbits_tab[exp_idx]; 452 } 453 if (num_bits >= bits_left - 32) 454 bias += i; 455 } 456 457 /* Calculate total number of bits. */ 458 num_bits = 0; 459 for (i = 0; i < p->total_subbands; i++) { 460 exp_idx = av_clip_uintp2((bias - quant_index_table[i]) / 2, 3); 461 num_bits += expbits_tab[exp_idx]; 462 exp_index1[i] = exp_idx; 463 exp_index2[i] = exp_idx; 464 } 465 tmpbias1 = tmpbias2 = num_bits; 466 467 for (j = 1; j < p->numvector_size; j++) { 468 if (tmpbias1 + tmpbias2 > 2 * bits_left) { /* ---> */ 469 int max = -999999; 470 index = -1; 471 for (i = 0; i < p->total_subbands; i++) { 472 if (exp_index1[i] < 7) { 473 v = (-2 * exp_index1[i]) - quant_index_table[i] + bias; 474 if (v >= max) { 475 max = v; 476 index = i; 477 } 478 } 479 } 480 if (index == -1) 481 break; 482 tmp_categorize_array[tmp_categorize_array1_idx++] = index; 483 tmpbias1 -= expbits_tab[exp_index1[index]] - 484 expbits_tab[exp_index1[index] + 1]; 485 ++exp_index1[index]; 486 } else { /* <--- */ 487 int min = 999999; 488 index = -1; 489 for (i = 0; i < p->total_subbands; i++) { 490 if (exp_index2[i] > 0) { 491 v = (-2 * exp_index2[i]) - quant_index_table[i] + bias; 492 if (v < min) { 493 min = v; 494 index = i; 495 } 496 } 497 } 498 if (index == -1) 499 break; 500 tmp_categorize_array[--tmp_categorize_array2_idx] = index; 501 tmpbias2 -= expbits_tab[exp_index2[index]] - 502 expbits_tab[exp_index2[index] - 1]; 503 --exp_index2[index]; 504 } 505 } 506 507 for (i = 0; i < p->total_subbands; i++) 508 category[i] = exp_index2[i]; 509 510 for (i = 0; i < p->numvector_size - 1; i++) 511 category_index[i] = tmp_categorize_array[tmp_categorize_array2_idx++]; 512} 513 514 515/** 516 * Expand the category vector. 517 * 518 * @param q pointer to the COOKContext 519 * @param category pointer to the category array 520 * @param category_index pointer to the category_index array 521 */ 522static inline void expand_category(COOKContext *q, int *category, 523 int *category_index) 524{ 525 int i; 526 for (i = 0; i < q->num_vectors; i++) 527 { 528 int idx = category_index[i]; 529 if (++category[idx] >= FF_ARRAY_ELEMS(dither_tab)) 530 --category[idx]; 531 } 532} 533 534/** 535 * The real requantization of the mltcoefs 536 * 537 * @param q pointer to the COOKContext 538 * @param index index 539 * @param quant_index quantisation index 540 * @param subband_coef_index array of indexes to quant_centroid_tab 541 * @param subband_coef_sign signs of coefficients 542 * @param mlt_p pointer into the mlt buffer 543 */ 544static void scalar_dequant_float(COOKContext *q, int index, int quant_index, 545 int *subband_coef_index, int *subband_coef_sign, 546 float *mlt_p) 547{ 548 int i; 549 float f1; 550 551 for (i = 0; i < SUBBAND_SIZE; i++) { 552 if (subband_coef_index[i]) { 553 f1 = quant_centroid_tab[index][subband_coef_index[i]]; 554 if (subband_coef_sign[i]) 555 f1 = -f1; 556 } else { 557 /* noise coding if subband_coef_index[i] == 0 */ 558 f1 = dither_tab[index]; 559 if (av_lfg_get(&q->random_state) < 0x80000000) 560 f1 = -f1; 561 } 562 mlt_p[i] = f1 * rootpow2tab[quant_index + 63]; 563 } 564} 565/** 566 * Unpack the subband_coef_index and subband_coef_sign vectors. 567 * 568 * @param q pointer to the COOKContext 569 * @param category pointer to the category array 570 * @param subband_coef_index array of indexes to quant_centroid_tab 571 * @param subband_coef_sign signs of coefficients 572 */ 573static int unpack_SQVH(COOKContext *q, COOKSubpacket *p, int category, 574 int *subband_coef_index, int *subband_coef_sign) 575{ 576 int i, j; 577 int vlc, vd, tmp, result; 578 579 vd = vd_tab[category]; 580 result = 0; 581 for (i = 0; i < vpr_tab[category]; i++) { 582 vlc = get_vlc2(&q->gb, q->sqvh[category].table, q->sqvh[category].bits, 3); 583 if (p->bits_per_subpacket < get_bits_count(&q->gb)) { 584 vlc = 0; 585 result = 1; 586 } 587 for (j = vd - 1; j >= 0; j--) { 588 tmp = (vlc * invradix_tab[category]) / 0x100000; 589 subband_coef_index[vd * i + j] = vlc - tmp * (kmax_tab[category] + 1); 590 vlc = tmp; 591 } 592 for (j = 0; j < vd; j++) { 593 if (subband_coef_index[i * vd + j]) { 594 if (get_bits_count(&q->gb) < p->bits_per_subpacket) { 595 subband_coef_sign[i * vd + j] = get_bits1(&q->gb); 596 } else { 597 result = 1; 598 subband_coef_sign[i * vd + j] = 0; 599 } 600 } else { 601 subband_coef_sign[i * vd + j] = 0; 602 } 603 } 604 } 605 return result; 606} 607 608 609/** 610 * Fill the mlt_buffer with mlt coefficients. 611 * 612 * @param q pointer to the COOKContext 613 * @param category pointer to the category array 614 * @param quant_index_table pointer to the array 615 * @param mlt_buffer pointer to mlt coefficients 616 */ 617static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category, 618 int *quant_index_table, float *mlt_buffer) 619{ 620 /* A zero in this table means that the subband coefficient is 621 random noise coded. */ 622 int subband_coef_index[SUBBAND_SIZE]; 623 /* A zero in this table means that the subband coefficient is a 624 positive multiplicator. */ 625 int subband_coef_sign[SUBBAND_SIZE]; 626 int band, j; 627 int index = 0; 628 629 for (band = 0; band < p->total_subbands; band++) { 630 index = category[band]; 631 if (category[band] < 7) { 632 if (unpack_SQVH(q, p, category[band], subband_coef_index, subband_coef_sign)) { 633 index = 7; 634 for (j = 0; j < p->total_subbands; j++) 635 category[band + j] = 7; 636 } 637 } 638 if (index >= 7) { 639 memset(subband_coef_index, 0, sizeof(subband_coef_index)); 640 memset(subband_coef_sign, 0, sizeof(subband_coef_sign)); 641 } 642 q->scalar_dequant(q, index, quant_index_table[band], 643 subband_coef_index, subband_coef_sign, 644 &mlt_buffer[band * SUBBAND_SIZE]); 645 } 646 647 /* FIXME: should this be removed, or moved into loop above? */ 648 if (p->total_subbands * SUBBAND_SIZE >= q->samples_per_channel) 649 return; 650} 651 652 653static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer) 654{ 655 int category_index[128] = { 0 }; 656 int category[128] = { 0 }; 657 int quant_index_table[102]; 658 int res, i; 659 660 if ((res = decode_envelope(q, p, quant_index_table)) < 0) 661 return res; 662 q->num_vectors = get_bits(&q->gb, p->log2_numvector_size); 663 categorize(q, p, quant_index_table, category, category_index); 664 expand_category(q, category, category_index); 665 for (i=0; i<p->total_subbands; i++) { 666 if (category[i] > 7) 667 return AVERROR_INVALIDDATA; 668 } 669 decode_vectors(q, p, category, quant_index_table, mlt_buffer); 670 671 return 0; 672} 673 674 675/** 676 * the actual requantization of the timedomain samples 677 * 678 * @param q pointer to the COOKContext 679 * @param buffer pointer to the timedomain buffer 680 * @param gain_index index for the block multiplier 681 * @param gain_index_next index for the next block multiplier 682 */ 683static void interpolate_float(COOKContext *q, float *buffer, 684 int gain_index, int gain_index_next) 685{ 686 int i; 687 float fc1, fc2; 688 fc1 = pow2tab[gain_index + 63]; 689 690 if (gain_index == gain_index_next) { // static gain 691 for (i = 0; i < q->gain_size_factor; i++) 692 buffer[i] *= fc1; 693 } else { // smooth gain 694 fc2 = q->gain_table[15 + (gain_index_next - gain_index)]; 695 for (i = 0; i < q->gain_size_factor; i++) { 696 buffer[i] *= fc1; 697 fc1 *= fc2; 698 } 699 } 700} 701 702/** 703 * Apply transform window, overlap buffers. 704 * 705 * @param q pointer to the COOKContext 706 * @param inbuffer pointer to the mltcoefficients 707 * @param gains_ptr current and previous gains 708 * @param previous_buffer pointer to the previous buffer to be used for overlapping 709 */ 710static void imlt_window_float(COOKContext *q, float *inbuffer, 711 cook_gains *gains_ptr, float *previous_buffer) 712{ 713 const float fc = pow2tab[gains_ptr->previous[0] + 63]; 714 int i; 715 /* The weird thing here, is that the two halves of the time domain 716 * buffer are swapped. Also, the newest data, that we save away for 717 * next frame, has the wrong sign. Hence the subtraction below. 718 * Almost sounds like a complex conjugate/reverse data/FFT effect. 719 */ 720 721 /* Apply window and overlap */ 722 for (i = 0; i < q->samples_per_channel; i++) 723 inbuffer[i] = inbuffer[i] * fc * q->mlt_window[i] - 724 previous_buffer[i] * q->mlt_window[q->samples_per_channel - 1 - i]; 725} 726 727/** 728 * The modulated lapped transform, this takes transform coefficients 729 * and transforms them into timedomain samples. 730 * Apply transform window, overlap buffers, apply gain profile 731 * and buffer management. 732 * 733 * @param q pointer to the COOKContext 734 * @param inbuffer pointer to the mltcoefficients 735 * @param gains_ptr current and previous gains 736 * @param previous_buffer pointer to the previous buffer to be used for overlapping 737 */ 738static void imlt_gain(COOKContext *q, float *inbuffer, 739 cook_gains *gains_ptr, float *previous_buffer) 740{ 741 float *buffer0 = q->mono_mdct_output; 742 float *buffer1 = q->mono_mdct_output + q->samples_per_channel; 743 int i; 744 745 /* Inverse modified discrete cosine transform */ 746 q->mdct_ctx.imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer); 747 748 q->imlt_window(q, buffer1, gains_ptr, previous_buffer); 749 750 /* Apply gain profile */ 751 for (i = 0; i < 8; i++) 752 if (gains_ptr->now[i] || gains_ptr->now[i + 1]) 753 q->interpolate(q, &buffer1[q->gain_size_factor * i], 754 gains_ptr->now[i], gains_ptr->now[i + 1]); 755 756 /* Save away the current to be previous block. */ 757 memcpy(previous_buffer, buffer0, 758 q->samples_per_channel * sizeof(*previous_buffer)); 759} 760 761 762/** 763 * function for getting the jointstereo coupling information 764 * 765 * @param q pointer to the COOKContext 766 * @param decouple_tab decoupling array 767 */ 768static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab) 769{ 770 int i; 771 int vlc = get_bits1(&q->gb); 772 int start = cplband[p->js_subband_start]; 773 int end = cplband[p->subbands - 1]; 774 int length = end - start + 1; 775 776 if (start > end) 777 return 0; 778 779 if (vlc) 780 for (i = 0; i < length; i++) 781 decouple_tab[start + i] = get_vlc2(&q->gb, 782 p->channel_coupling.table, 783 COUPLING_VLC_BITS, 3); 784 else 785 for (i = 0; i < length; i++) { 786 int v = get_bits(&q->gb, p->js_vlc_bits); 787 if (v == (1<<p->js_vlc_bits)-1) { 788 av_log(q->avctx, AV_LOG_ERROR, "decouple value too large\n"); 789 return AVERROR_INVALIDDATA; 790 } 791 decouple_tab[start + i] = v; 792 } 793 return 0; 794} 795 796/** 797 * function decouples a pair of signals from a single signal via multiplication. 798 * 799 * @param q pointer to the COOKContext 800 * @param subband index of the current subband 801 * @param f1 multiplier for channel 1 extraction 802 * @param f2 multiplier for channel 2 extraction 803 * @param decode_buffer input buffer 804 * @param mlt_buffer1 pointer to left channel mlt coefficients 805 * @param mlt_buffer2 pointer to right channel mlt coefficients 806 */ 807static void decouple_float(COOKContext *q, 808 COOKSubpacket *p, 809 int subband, 810 float f1, float f2, 811 float *decode_buffer, 812 float *mlt_buffer1, float *mlt_buffer2) 813{ 814 int j, tmp_idx; 815 for (j = 0; j < SUBBAND_SIZE; j++) { 816 tmp_idx = ((p->js_subband_start + subband) * SUBBAND_SIZE) + j; 817 mlt_buffer1[SUBBAND_SIZE * subband + j] = f1 * decode_buffer[tmp_idx]; 818 mlt_buffer2[SUBBAND_SIZE * subband + j] = f2 * decode_buffer[tmp_idx]; 819 } 820} 821 822/** 823 * function for decoding joint stereo data 824 * 825 * @param q pointer to the COOKContext 826 * @param mlt_buffer1 pointer to left channel mlt coefficients 827 * @param mlt_buffer2 pointer to right channel mlt coefficients 828 */ 829static int joint_decode(COOKContext *q, COOKSubpacket *p, 830 float *mlt_buffer_left, float *mlt_buffer_right) 831{ 832 int i, j, res; 833 int decouple_tab[SUBBAND_SIZE] = { 0 }; 834 float *decode_buffer = q->decode_buffer_0; 835 int idx, cpl_tmp; 836 float f1, f2; 837 const float *cplscale; 838 839 memset(decode_buffer, 0, sizeof(q->decode_buffer_0)); 840 841 /* Make sure the buffers are zeroed out. */ 842 memset(mlt_buffer_left, 0, 1024 * sizeof(*mlt_buffer_left)); 843 memset(mlt_buffer_right, 0, 1024 * sizeof(*mlt_buffer_right)); 844 if ((res = decouple_info(q, p, decouple_tab)) < 0) 845 return res; 846 if ((res = mono_decode(q, p, decode_buffer)) < 0) 847 return res; 848 /* The two channels are stored interleaved in decode_buffer. */ 849 for (i = 0; i < p->js_subband_start; i++) { 850 for (j = 0; j < SUBBAND_SIZE; j++) { 851 mlt_buffer_left[i * 20 + j] = decode_buffer[i * 40 + j]; 852 mlt_buffer_right[i * 20 + j] = decode_buffer[i * 40 + 20 + j]; 853 } 854 } 855 856 /* When we reach js_subband_start (the higher frequencies) 857 the coefficients are stored in a coupling scheme. */ 858 idx = (1 << p->js_vlc_bits) - 1; 859 for (i = p->js_subband_start; i < p->subbands; i++) { 860 cpl_tmp = cplband[i]; 861 idx -= decouple_tab[cpl_tmp]; 862 cplscale = q->cplscales[p->js_vlc_bits - 2]; // choose decoupler table 863 f1 = cplscale[decouple_tab[cpl_tmp] + 1]; 864 f2 = cplscale[idx]; 865 q->decouple(q, p, i, f1, f2, decode_buffer, 866 mlt_buffer_left, mlt_buffer_right); 867 idx = (1 << p->js_vlc_bits) - 1; 868 } 869 870 return 0; 871} 872 873/** 874 * First part of subpacket decoding: 875 * decode raw stream bytes and read gain info. 876 * 877 * @param q pointer to the COOKContext 878 * @param inbuffer pointer to raw stream data 879 * @param gains_ptr array of current/prev gain pointers 880 */ 881static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p, 882 const uint8_t *inbuffer, 883 cook_gains *gains_ptr) 884{ 885 int offset; 886 887 offset = decode_bytes(inbuffer, q->decoded_bytes_buffer, 888 p->bits_per_subpacket / 8); 889 init_get_bits(&q->gb, q->decoded_bytes_buffer + offset, 890 p->bits_per_subpacket); 891 decode_gain_info(&q->gb, gains_ptr->now); 892 893 /* Swap current and previous gains */ 894 FFSWAP(int *, gains_ptr->now, gains_ptr->previous); 895} 896 897/** 898 * Saturate the output signal and interleave. 899 * 900 * @param q pointer to the COOKContext 901 * @param out pointer to the output vector 902 */ 903static void saturate_output_float(COOKContext *q, float *out) 904{ 905 q->adsp.vector_clipf(out, q->mono_mdct_output + q->samples_per_channel, 906 FFALIGN(q->samples_per_channel, 8), -1.0f, 1.0f); 907} 908 909 910/** 911 * Final part of subpacket decoding: 912 * Apply modulated lapped transform, gain compensation, 913 * clip and convert to integer. 914 * 915 * @param q pointer to the COOKContext 916 * @param decode_buffer pointer to the mlt coefficients 917 * @param gains_ptr array of current/prev gain pointers 918 * @param previous_buffer pointer to the previous buffer to be used for overlapping 919 * @param out pointer to the output buffer 920 */ 921static inline void mlt_compensate_output(COOKContext *q, float *decode_buffer, 922 cook_gains *gains_ptr, float *previous_buffer, 923 float *out) 924{ 925 imlt_gain(q, decode_buffer, gains_ptr, previous_buffer); 926 if (out) 927 q->saturate_output(q, out); 928} 929 930 931/** 932 * Cook subpacket decoding. This function returns one decoded subpacket, 933 * usually 1024 samples per channel. 934 * 935 * @param q pointer to the COOKContext 936 * @param inbuffer pointer to the inbuffer 937 * @param outbuffer pointer to the outbuffer 938 */ 939static int decode_subpacket(COOKContext *q, COOKSubpacket *p, 940 const uint8_t *inbuffer, float **outbuffer) 941{ 942 int sub_packet_size = p->size; 943 int res; 944 945 memset(q->decode_buffer_1, 0, sizeof(q->decode_buffer_1)); 946 decode_bytes_and_gain(q, p, inbuffer, &p->gains1); 947 948 if (p->joint_stereo) { 949 if ((res = joint_decode(q, p, q->decode_buffer_1, q->decode_buffer_2)) < 0) 950 return res; 951 } else { 952 if ((res = mono_decode(q, p, q->decode_buffer_1)) < 0) 953 return res; 954 955 if (p->num_channels == 2) { 956 decode_bytes_and_gain(q, p, inbuffer + sub_packet_size / 2, &p->gains2); 957 if ((res = mono_decode(q, p, q->decode_buffer_2)) < 0) 958 return res; 959 } 960 } 961 962 mlt_compensate_output(q, q->decode_buffer_1, &p->gains1, 963 p->mono_previous_buffer1, 964 outbuffer ? outbuffer[p->ch_idx] : NULL); 965 966 if (p->num_channels == 2) { 967 if (p->joint_stereo) 968 mlt_compensate_output(q, q->decode_buffer_2, &p->gains1, 969 p->mono_previous_buffer2, 970 outbuffer ? outbuffer[p->ch_idx + 1] : NULL); 971 else 972 mlt_compensate_output(q, q->decode_buffer_2, &p->gains2, 973 p->mono_previous_buffer2, 974 outbuffer ? outbuffer[p->ch_idx + 1] : NULL); 975 } 976 977 return 0; 978} 979 980 981static int cook_decode_frame(AVCodecContext *avctx, AVFrame *frame, 982 int *got_frame_ptr, AVPacket *avpkt) 983{ 984 const uint8_t *buf = avpkt->data; 985 int buf_size = avpkt->size; 986 COOKContext *q = avctx->priv_data; 987 float **samples = NULL; 988 int i, ret; 989 int offset = 0; 990 int chidx = 0; 991 992 if (buf_size < avctx->block_align) 993 return buf_size; 994 995 /* get output buffer */ 996 if (q->discarded_packets >= 2) { 997 frame->nb_samples = q->samples_per_channel; 998 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 999 return ret; 1000 samples = (float **)frame->extended_data; 1001 } 1002 1003 /* estimate subpacket sizes */ 1004 q->subpacket[0].size = avctx->block_align; 1005 1006 for (i = 1; i < q->num_subpackets; i++) { 1007 q->subpacket[i].size = 2 * buf[avctx->block_align - q->num_subpackets + i]; 1008 q->subpacket[0].size -= q->subpacket[i].size + 1; 1009 if (q->subpacket[0].size < 0) { 1010 av_log(avctx, AV_LOG_DEBUG, 1011 "frame subpacket size total > avctx->block_align!\n"); 1012 return AVERROR_INVALIDDATA; 1013 } 1014 } 1015 1016 /* decode supbackets */ 1017 for (i = 0; i < q->num_subpackets; i++) { 1018 q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size * 8) >> 1019 q->subpacket[i].bits_per_subpdiv; 1020 q->subpacket[i].ch_idx = chidx; 1021 av_log(avctx, AV_LOG_DEBUG, 1022 "subpacket[%i] size %i js %i %i block_align %i\n", 1023 i, q->subpacket[i].size, q->subpacket[i].joint_stereo, offset, 1024 avctx->block_align); 1025 1026 if ((ret = decode_subpacket(q, &q->subpacket[i], buf + offset, samples)) < 0) 1027 return ret; 1028 offset += q->subpacket[i].size; 1029 chidx += q->subpacket[i].num_channels; 1030 av_log(avctx, AV_LOG_DEBUG, "subpacket[%i] %i %i\n", 1031 i, q->subpacket[i].size * 8, get_bits_count(&q->gb)); 1032 } 1033 1034 /* Discard the first two frames: no valid audio. */ 1035 if (q->discarded_packets < 2) { 1036 q->discarded_packets++; 1037 *got_frame_ptr = 0; 1038 return avctx->block_align; 1039 } 1040 1041 *got_frame_ptr = 1; 1042 1043 return avctx->block_align; 1044} 1045 1046static void dump_cook_context(COOKContext *q) 1047{ 1048 //int i=0; 1049#define PRINT(a, b) ff_dlog(q->avctx, " %s = %d\n", a, b); 1050 ff_dlog(q->avctx, "COOKextradata\n"); 1051 ff_dlog(q->avctx, "cookversion=%x\n", q->subpacket[0].cookversion); 1052 if (q->subpacket[0].cookversion > STEREO) { 1053 PRINT("js_subband_start", q->subpacket[0].js_subband_start); 1054 PRINT("js_vlc_bits", q->subpacket[0].js_vlc_bits); 1055 } 1056 ff_dlog(q->avctx, "COOKContext\n"); 1057 PRINT("nb_channels", q->avctx->ch_layout.nb_channels); 1058 PRINT("bit_rate", (int)q->avctx->bit_rate); 1059 PRINT("sample_rate", q->avctx->sample_rate); 1060 PRINT("samples_per_channel", q->subpacket[0].samples_per_channel); 1061 PRINT("subbands", q->subpacket[0].subbands); 1062 PRINT("js_subband_start", q->subpacket[0].js_subband_start); 1063 PRINT("log2_numvector_size", q->subpacket[0].log2_numvector_size); 1064 PRINT("numvector_size", q->subpacket[0].numvector_size); 1065 PRINT("total_subbands", q->subpacket[0].total_subbands); 1066} 1067 1068/** 1069 * Cook initialization 1070 * 1071 * @param avctx pointer to the AVCodecContext 1072 */ 1073static av_cold int cook_decode_init(AVCodecContext *avctx) 1074{ 1075 static AVOnce init_static_once = AV_ONCE_INIT; 1076 COOKContext *q = avctx->priv_data; 1077 GetByteContext gb; 1078 int s = 0; 1079 unsigned int channel_mask = 0; 1080 int samples_per_frame = 0; 1081 int ret; 1082 int channels = avctx->ch_layout.nb_channels; 1083 1084 q->avctx = avctx; 1085 1086 /* Take care of the codec specific extradata. */ 1087 if (avctx->extradata_size < 8) { 1088 av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n"); 1089 return AVERROR_INVALIDDATA; 1090 } 1091 av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size); 1092 1093 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size); 1094 1095 /* Take data from the AVCodecContext (RM container). */ 1096 if (!channels) { 1097 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); 1098 return AVERROR_INVALIDDATA; 1099 } 1100 1101 if (avctx->block_align >= INT_MAX / 8) 1102 return AVERROR(EINVAL); 1103 1104 /* Initialize RNG. */ 1105 av_lfg_init(&q->random_state, 0); 1106 1107 ff_audiodsp_init(&q->adsp); 1108 1109 while (bytestream2_get_bytes_left(&gb)) { 1110 if (s >= FFMIN(MAX_SUBPACKETS, avctx->block_align)) { 1111 avpriv_request_sample(avctx, "subpackets > %d", FFMIN(MAX_SUBPACKETS, avctx->block_align)); 1112 return AVERROR_PATCHWELCOME; 1113 } 1114 /* 8 for mono, 16 for stereo, ? for multichannel 1115 Swap to right endianness so we don't need to care later on. */ 1116 q->subpacket[s].cookversion = bytestream2_get_be32(&gb); 1117 samples_per_frame = bytestream2_get_be16(&gb); 1118 q->subpacket[s].subbands = bytestream2_get_be16(&gb); 1119 bytestream2_get_be32(&gb); // Unknown unused 1120 q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb); 1121 if (q->subpacket[s].js_subband_start >= 51) { 1122 av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start); 1123 return AVERROR_INVALIDDATA; 1124 } 1125 q->subpacket[s].js_vlc_bits = bytestream2_get_be16(&gb); 1126 1127 /* Initialize extradata related variables. */ 1128 q->subpacket[s].samples_per_channel = samples_per_frame / channels; 1129 q->subpacket[s].bits_per_subpacket = avctx->block_align * 8; 1130 1131 /* Initialize default data states. */ 1132 q->subpacket[s].log2_numvector_size = 5; 1133 q->subpacket[s].total_subbands = q->subpacket[s].subbands; 1134 q->subpacket[s].num_channels = 1; 1135 1136 /* Initialize version-dependent variables */ 1137 1138 av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s, 1139 q->subpacket[s].cookversion); 1140 q->subpacket[s].joint_stereo = 0; 1141 switch (q->subpacket[s].cookversion) { 1142 case MONO: 1143 if (channels != 1) { 1144 avpriv_request_sample(avctx, "Container channels != 1"); 1145 return AVERROR_PATCHWELCOME; 1146 } 1147 av_log(avctx, AV_LOG_DEBUG, "MONO\n"); 1148 break; 1149 case STEREO: 1150 if (channels != 1) { 1151 q->subpacket[s].bits_per_subpdiv = 1; 1152 q->subpacket[s].num_channels = 2; 1153 } 1154 av_log(avctx, AV_LOG_DEBUG, "STEREO\n"); 1155 break; 1156 case JOINT_STEREO: 1157 if (channels != 2) { 1158 avpriv_request_sample(avctx, "Container channels != 2"); 1159 return AVERROR_PATCHWELCOME; 1160 } 1161 av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n"); 1162 if (avctx->extradata_size >= 16) { 1163 q->subpacket[s].total_subbands = q->subpacket[s].subbands + 1164 q->subpacket[s].js_subband_start; 1165 q->subpacket[s].joint_stereo = 1; 1166 q->subpacket[s].num_channels = 2; 1167 } 1168 if (q->subpacket[s].samples_per_channel > 256) { 1169 q->subpacket[s].log2_numvector_size = 6; 1170 } 1171 if (q->subpacket[s].samples_per_channel > 512) { 1172 q->subpacket[s].log2_numvector_size = 7; 1173 } 1174 break; 1175 case MC_COOK: 1176 av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n"); 1177 channel_mask |= q->subpacket[s].channel_mask = bytestream2_get_be32(&gb); 1178 1179 if (av_popcount64(q->subpacket[s].channel_mask) > 1) { 1180 q->subpacket[s].total_subbands = q->subpacket[s].subbands + 1181 q->subpacket[s].js_subband_start; 1182 q->subpacket[s].joint_stereo = 1; 1183 q->subpacket[s].num_channels = 2; 1184 q->subpacket[s].samples_per_channel = samples_per_frame >> 1; 1185 1186 if (q->subpacket[s].samples_per_channel > 256) { 1187 q->subpacket[s].log2_numvector_size = 6; 1188 } 1189 if (q->subpacket[s].samples_per_channel > 512) { 1190 q->subpacket[s].log2_numvector_size = 7; 1191 } 1192 } else 1193 q->subpacket[s].samples_per_channel = samples_per_frame; 1194 1195 break; 1196 default: 1197 avpriv_request_sample(avctx, "Cook version %d", 1198 q->subpacket[s].cookversion); 1199 return AVERROR_PATCHWELCOME; 1200 } 1201 1202 if (s > 1 && q->subpacket[s].samples_per_channel != q->samples_per_channel) { 1203 av_log(avctx, AV_LOG_ERROR, "different number of samples per channel!\n"); 1204 return AVERROR_INVALIDDATA; 1205 } else 1206 q->samples_per_channel = q->subpacket[0].samples_per_channel; 1207 1208 1209 /* Initialize variable relations */ 1210 q->subpacket[s].numvector_size = (1 << q->subpacket[s].log2_numvector_size); 1211 1212 /* Try to catch some obviously faulty streams, otherwise it might be exploitable */ 1213 if (q->subpacket[s].total_subbands > 53) { 1214 avpriv_request_sample(avctx, "total_subbands > 53"); 1215 return AVERROR_PATCHWELCOME; 1216 } 1217 1218 if ((q->subpacket[s].js_vlc_bits > 6) || 1219 (q->subpacket[s].js_vlc_bits < 2 * q->subpacket[s].joint_stereo)) { 1220 av_log(avctx, AV_LOG_ERROR, "js_vlc_bits = %d, only >= %d and <= 6 allowed!\n", 1221 q->subpacket[s].js_vlc_bits, 2 * q->subpacket[s].joint_stereo); 1222 return AVERROR_INVALIDDATA; 1223 } 1224 1225 if (q->subpacket[s].subbands > 50) { 1226 avpriv_request_sample(avctx, "subbands > 50"); 1227 return AVERROR_PATCHWELCOME; 1228 } 1229 if (q->subpacket[s].subbands == 0) { 1230 avpriv_request_sample(avctx, "subbands = 0"); 1231 return AVERROR_PATCHWELCOME; 1232 } 1233 q->subpacket[s].gains1.now = q->subpacket[s].gain_1; 1234 q->subpacket[s].gains1.previous = q->subpacket[s].gain_2; 1235 q->subpacket[s].gains2.now = q->subpacket[s].gain_3; 1236 q->subpacket[s].gains2.previous = q->subpacket[s].gain_4; 1237 1238 if (q->num_subpackets + q->subpacket[s].num_channels > channels) { 1239 av_log(avctx, AV_LOG_ERROR, "Too many subpackets %d for channels %d\n", q->num_subpackets, channels); 1240 return AVERROR_INVALIDDATA; 1241 } 1242 1243 q->num_subpackets++; 1244 s++; 1245 } 1246 1247 /* Try to catch some obviously faulty streams, otherwise it might be exploitable */ 1248 if (q->samples_per_channel != 256 && q->samples_per_channel != 512 && 1249 q->samples_per_channel != 1024) { 1250 avpriv_request_sample(avctx, "samples_per_channel = %d", 1251 q->samples_per_channel); 1252 return AVERROR_PATCHWELCOME; 1253 } 1254 1255 /* Generate tables */ 1256 ff_thread_once(&init_static_once, init_pow2table); 1257 init_gain_table(q); 1258 init_cplscales_table(q); 1259 1260 if ((ret = init_cook_vlc_tables(q))) 1261 return ret; 1262 1263 /* Pad the databuffer with: 1264 DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(), 1265 AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */ 1266 q->decoded_bytes_buffer = 1267 av_mallocz(avctx->block_align 1268 + DECODE_BYTES_PAD1(avctx->block_align) 1269 + AV_INPUT_BUFFER_PADDING_SIZE); 1270 if (!q->decoded_bytes_buffer) 1271 return AVERROR(ENOMEM); 1272 1273 /* Initialize transform. */ 1274 if ((ret = init_cook_mlt(q))) 1275 return ret; 1276 1277 /* Initialize COOK signal arithmetic handling */ 1278 if (1) { 1279 q->scalar_dequant = scalar_dequant_float; 1280 q->decouple = decouple_float; 1281 q->imlt_window = imlt_window_float; 1282 q->interpolate = interpolate_float; 1283 q->saturate_output = saturate_output_float; 1284 } 1285 1286 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; 1287 av_channel_layout_uninit(&avctx->ch_layout); 1288 if (channel_mask) 1289 av_channel_layout_from_mask(&avctx->ch_layout, channel_mask); 1290 else 1291 av_channel_layout_default(&avctx->ch_layout, channels); 1292 1293 1294 dump_cook_context(q); 1295 1296 return 0; 1297} 1298 1299const FFCodec ff_cook_decoder = { 1300 .p.name = "cook", 1301 .p.long_name = NULL_IF_CONFIG_SMALL("Cook / Cooker / Gecko (RealAudio G2)"), 1302 .p.type = AVMEDIA_TYPE_AUDIO, 1303 .p.id = AV_CODEC_ID_COOK, 1304 .priv_data_size = sizeof(COOKContext), 1305 .init = cook_decode_init, 1306 .close = cook_decode_close, 1307 FF_CODEC_DECODE_CB(cook_decode_frame), 1308 .p.capabilities = AV_CODEC_CAP_DR1, 1309 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, 1310 AV_SAMPLE_FMT_NONE }, 1311 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 1312}; 1313