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