1/* 2 * ATRAC3+ compatible decoder 3 * 4 * Copyright (c) 2010-2013 Maxim Poliakovski 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 * Bitstream parser for ATRAC3+ decoder. 26 */ 27 28#include "libavutil/avassert.h" 29#include "avcodec.h" 30#include "get_bits.h" 31#include "atrac3plus.h" 32#include "atrac3plus_data.h" 33 34static VLCElem tables_data[154276]; 35static VLC wl_vlc_tabs[4]; 36static VLC sf_vlc_tabs[8]; 37static VLC ct_vlc_tabs[4]; 38static VLC spec_vlc_tabs[112]; 39static VLC gain_vlc_tabs[11]; 40static VLC tone_vlc_tabs[7]; 41 42/** 43 * Generate canonical VLC table from given descriptor. 44 * 45 * @param[in] cb ptr to codebook descriptor 46 * @param[in,out] xlat ptr to ptr to translation table 47 * @param[in,out] tab_offset starting offset to the generated vlc table 48 * @param[out] out_vlc ptr to vlc table to be generated 49 */ 50static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t **xlat, 51 int *tab_offset, VLC *out_vlc) 52{ 53 int i, max_len; 54 uint8_t bits[256]; 55 int index = 0; 56 57 for (int b = 1; b <= 12; b++) { 58 for (i = *cb++; i > 0; i--) { 59 av_assert0(index < 256); 60 bits[index] = b; 61 index++; 62 } 63 } 64 max_len = bits[index - 1]; 65 66 out_vlc->table = &tables_data[*tab_offset]; 67 out_vlc->table_allocated = 1 << max_len; 68 69 ff_init_vlc_from_lengths(out_vlc, max_len, index, bits, 1, 70 *xlat, 1, 1, 0, INIT_VLC_USE_NEW_STATIC, NULL); 71 72 *tab_offset += 1 << max_len; 73 *xlat += index; 74} 75 76av_cold void ff_atrac3p_init_vlcs(void) 77{ 78 int i, tab_offset = 0; 79 const uint8_t *xlats; 80 81 xlats = atrac3p_wl_ct_xlats; 82 for (int i = 0; i < 4; i++) { 83 build_canonical_huff(atrac3p_wl_cbs[i], &xlats, 84 &tab_offset, &wl_vlc_tabs[i]); 85 build_canonical_huff(atrac3p_ct_cbs[i], &xlats, 86 &tab_offset, &ct_vlc_tabs[i]); 87 } 88 89 xlats = atrac3p_sf_xlats; 90 for (int i = 0; i < 8; i++) 91 build_canonical_huff(atrac3p_sf_cbs[i], &xlats, 92 &tab_offset, &sf_vlc_tabs[i]); 93 94 /* build huffman tables for spectrum decoding */ 95 xlats = atrac3p_spectra_xlats; 96 for (i = 0; i < 112; i++) { 97 if (atrac3p_spectra_cbs[i][0] >= 0) 98 build_canonical_huff(atrac3p_spectra_cbs[i], 99 &xlats, &tab_offset, &spec_vlc_tabs[i]); 100 else /* Reuse already initialized VLC table */ 101 spec_vlc_tabs[i] = spec_vlc_tabs[-atrac3p_spectra_cbs[i][0]]; 102 } 103 104 /* build huffman tables for gain data decoding */ 105 xlats = atrac3p_gain_xlats; 106 for (i = 0; i < 11; i++) 107 build_canonical_huff(atrac3p_gain_cbs[i], &xlats, 108 &tab_offset, &gain_vlc_tabs[i]); 109 110 /* build huffman tables for tone decoding */ 111 xlats = atrac3p_tone_xlats; 112 for (i = 0; i < 7; i++) 113 build_canonical_huff(atrac3p_tone_cbs[i], &xlats, 114 &tab_offset, &tone_vlc_tabs[i]); 115} 116 117/** 118 * Decode number of coded quantization units. 119 * 120 * @param[in] gb the GetBit context 121 * @param[in,out] chan ptr to the channel parameters 122 * @param[in,out] ctx ptr to the channel unit context 123 * @param[in] avctx ptr to the AVCodecContext 124 * @return result code: 0 = OK, otherwise - error code 125 */ 126static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan, 127 Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx) 128{ 129 chan->fill_mode = get_bits(gb, 2); 130 if (!chan->fill_mode) { 131 chan->num_coded_vals = ctx->num_quant_units; 132 } else { 133 chan->num_coded_vals = get_bits(gb, 5); 134 if (chan->num_coded_vals > ctx->num_quant_units) { 135 av_log(avctx, AV_LOG_ERROR, 136 "Invalid number of transmitted units!\n"); 137 return AVERROR_INVALIDDATA; 138 } 139 140 if (chan->fill_mode == 3) 141 chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1; 142 } 143 144 return 0; 145} 146 147/** 148 * Add weighting coefficients to the decoded word-length information. 149 * 150 * @param[in,out] ctx ptr to the channel unit context 151 * @param[in,out] chan ptr to the channel parameters 152 * @param[in] wtab_idx index of the table of weights 153 * @param[in] avctx ptr to the AVCodecContext 154 * @return result code: 0 = OK, otherwise - error code 155 */ 156static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx, 157 Atrac3pChanParams *chan, int wtab_idx, 158 AVCodecContext *avctx) 159{ 160 int i; 161 const int8_t *weights_tab = 162 &atrac3p_wl_weights[chan->ch_num * 3 + wtab_idx - 1][0]; 163 164 for (i = 0; i < ctx->num_quant_units; i++) { 165 chan->qu_wordlen[i] += weights_tab[i]; 166 if (chan->qu_wordlen[i] < 0 || chan->qu_wordlen[i] > 7) { 167 av_log(avctx, AV_LOG_ERROR, 168 "WL index out of range: pos=%d, val=%d!\n", 169 i, chan->qu_wordlen[i]); 170 return AVERROR_INVALIDDATA; 171 } 172 } 173 174 return 0; 175} 176 177/** 178 * Subtract weighting coefficients from decoded scalefactors. 179 * 180 * @param[in,out] ctx ptr to the channel unit context 181 * @param[in,out] chan ptr to the channel parameters 182 * @param[in] wtab_idx index of table of weights 183 * @param[in] avctx ptr to the AVCodecContext 184 * @return result code: 0 = OK, otherwise - error code 185 */ 186static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx, 187 Atrac3pChanParams *chan, int wtab_idx, 188 AVCodecContext *avctx) 189{ 190 int i; 191 const int8_t *weights_tab = &atrac3p_sf_weights[wtab_idx - 1][0]; 192 193 for (i = 0; i < ctx->used_quant_units; i++) { 194 chan->qu_sf_idx[i] -= weights_tab[i]; 195 if (chan->qu_sf_idx[i] < 0 || chan->qu_sf_idx[i] > 63) { 196 av_log(avctx, AV_LOG_ERROR, 197 "SF index out of range: pos=%d, val=%d!\n", 198 i, chan->qu_sf_idx[i]); 199 return AVERROR_INVALIDDATA; 200 } 201 } 202 203 return 0; 204} 205 206/** 207 * Unpack vector quantization tables. 208 * 209 * @param[in] start_val start value for the unpacked table 210 * @param[in] shape_vec ptr to table to unpack 211 * @param[out] dst ptr to output array 212 * @param[in] num_values number of values to unpack 213 */ 214static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec, 215 int *dst, int num_values) 216{ 217 int i; 218 219 if (num_values) { 220 dst[0] = dst[1] = dst[2] = start_val; 221 for (i = 3; i < num_values; i++) 222 dst[i] = start_val - shape_vec[atrac3p_qu_num_to_seg[i] - 1]; 223 } 224} 225 226#define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals) \ 227 start_val = get_bits((gb), 6); \ 228 unpack_vq_shape(start_val, &atrac3p_sf_shapes[get_bits((gb), 6)][0], \ 229 (dst), (num_vals)) 230 231/** 232 * Decode word length for each quantization unit of a channel. 233 * 234 * @param[in] gb the GetBit context 235 * @param[in,out] ctx ptr to the channel unit context 236 * @param[in] ch_num channel to process 237 * @param[in] avctx ptr to the AVCodecContext 238 * @return result code: 0 = OK, otherwise - error code 239 */ 240static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 241 int ch_num, AVCodecContext *avctx) 242{ 243 int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag, 244 ret, start_val; 245 VLC *vlc_tab; 246 Atrac3pChanParams *chan = &ctx->channels[ch_num]; 247 Atrac3pChanParams *ref_chan = &ctx->channels[0]; 248 249 chan->fill_mode = 0; 250 251 switch (get_bits(gb, 2)) { /* switch according to coding mode */ 252 case 0: /* coded using constant number of bits */ 253 for (i = 0; i < ctx->num_quant_units; i++) 254 chan->qu_wordlen[i] = get_bits(gb, 3); 255 break; 256 case 1: 257 if (ch_num) { 258 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) 259 return ret; 260 261 if (chan->num_coded_vals) { 262 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)]; 263 264 for (i = 0; i < chan->num_coded_vals; i++) { 265 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 266 chan->qu_wordlen[i] = (ref_chan->qu_wordlen[i] + delta) & 7; 267 } 268 } 269 } else { 270 weight_idx = get_bits(gb, 2); 271 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) 272 return ret; 273 274 if (chan->num_coded_vals) { 275 pos = get_bits(gb, 5); 276 if (pos > chan->num_coded_vals) { 277 av_log(avctx, AV_LOG_ERROR, 278 "WL mode 1: invalid position!\n"); 279 return AVERROR_INVALIDDATA; 280 } 281 282 delta_bits = get_bits(gb, 2); 283 min_val = get_bits(gb, 3); 284 285 for (i = 0; i < pos; i++) 286 chan->qu_wordlen[i] = get_bits(gb, 3); 287 288 for (i = pos; i < chan->num_coded_vals; i++) 289 chan->qu_wordlen[i] = (min_val + get_bitsz(gb, delta_bits)) & 7; 290 } 291 } 292 break; 293 case 2: 294 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) 295 return ret; 296 297 if (ch_num && chan->num_coded_vals) { 298 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)]; 299 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 300 chan->qu_wordlen[0] = (ref_chan->qu_wordlen[0] + delta) & 7; 301 302 for (i = 1; i < chan->num_coded_vals; i++) { 303 diff = ref_chan->qu_wordlen[i] - ref_chan->qu_wordlen[i - 1]; 304 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 305 chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + diff + delta) & 7; 306 } 307 } else if (chan->num_coded_vals) { 308 flag = get_bits(gb, 1); 309 vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)]; 310 311 start_val = get_bits(gb, 3); 312 unpack_vq_shape(start_val, 313 &atrac3p_wl_shapes[start_val][get_bits(gb, 4)][0], 314 chan->qu_wordlen, chan->num_coded_vals); 315 316 if (!flag) { 317 for (i = 0; i < chan->num_coded_vals; i++) { 318 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 319 chan->qu_wordlen[i] = (chan->qu_wordlen[i] + delta) & 7; 320 } 321 } else { 322 for (i = 0; i < (chan->num_coded_vals & - 2); i += 2) 323 if (!get_bits1(gb)) { 324 chan->qu_wordlen[i] = (chan->qu_wordlen[i] + 325 get_vlc2(gb, vlc_tab->table, 326 vlc_tab->bits, 1)) & 7; 327 chan->qu_wordlen[i + 1] = (chan->qu_wordlen[i + 1] + 328 get_vlc2(gb, vlc_tab->table, 329 vlc_tab->bits, 1)) & 7; 330 } 331 332 if (chan->num_coded_vals & 1) 333 chan->qu_wordlen[i] = (chan->qu_wordlen[i] + 334 get_vlc2(gb, vlc_tab->table, 335 vlc_tab->bits, 1)) & 7; 336 } 337 } 338 break; 339 case 3: 340 weight_idx = get_bits(gb, 2); 341 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0) 342 return ret; 343 344 if (chan->num_coded_vals) { 345 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)]; 346 347 /* first coefficient is coded directly */ 348 chan->qu_wordlen[0] = get_bits(gb, 3); 349 350 for (i = 1; i < chan->num_coded_vals; i++) { 351 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 352 chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + delta) & 7; 353 } 354 } 355 break; 356 } 357 358 if (chan->fill_mode == 2) { 359 for (i = chan->num_coded_vals; i < ctx->num_quant_units; i++) 360 chan->qu_wordlen[i] = ch_num ? get_bits1(gb) : 1; 361 } else if (chan->fill_mode == 3) { 362 pos = ch_num ? chan->num_coded_vals + chan->split_point 363 : ctx->num_quant_units - chan->split_point; 364 if (pos > FF_ARRAY_ELEMS(chan->qu_wordlen)) { 365 av_log(avctx, AV_LOG_ERROR, "Split point beyond array\n"); 366 pos = FF_ARRAY_ELEMS(chan->qu_wordlen); 367 } 368 for (i = chan->num_coded_vals; i < pos; i++) 369 chan->qu_wordlen[i] = 1; 370 } 371 372 if (weight_idx) 373 return add_wordlen_weights(ctx, chan, weight_idx, avctx); 374 375 return 0; 376} 377 378/** 379 * Decode scale factor indexes for each quant unit of a channel. 380 * 381 * @param[in] gb the GetBit context 382 * @param[in,out] ctx ptr to the channel unit context 383 * @param[in] ch_num channel to process 384 * @param[in] avctx ptr to the AVCodecContext 385 * @return result code: 0 = OK, otherwise - error code 386 */ 387static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 388 int ch_num, AVCodecContext *avctx) 389{ 390 int i, weight_idx = 0, delta, diff, num_long_vals, 391 delta_bits, min_val, vlc_sel, start_val; 392 VLC *vlc_tab; 393 Atrac3pChanParams *chan = &ctx->channels[ch_num]; 394 Atrac3pChanParams *ref_chan = &ctx->channels[0]; 395 396 switch (get_bits(gb, 2)) { /* switch according to coding mode */ 397 case 0: /* coded using constant number of bits */ 398 for (i = 0; i < ctx->used_quant_units; i++) 399 chan->qu_sf_idx[i] = get_bits(gb, 6); 400 break; 401 case 1: 402 if (ch_num) { 403 vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)]; 404 405 for (i = 0; i < ctx->used_quant_units; i++) { 406 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 407 chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F; 408 } 409 } else { 410 weight_idx = get_bits(gb, 2); 411 if (weight_idx == 3) { 412 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units); 413 414 num_long_vals = get_bits(gb, 5); 415 delta_bits = get_bits(gb, 2); 416 min_val = get_bits(gb, 4) - 7; 417 418 for (i = 0; i < num_long_vals; i++) 419 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + 420 get_bits(gb, 4) - 7) & 0x3F; 421 422 /* all others are: min_val + delta */ 423 for (i = num_long_vals; i < ctx->used_quant_units; i++) 424 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val + 425 get_bitsz(gb, delta_bits)) & 0x3F; 426 } else { 427 num_long_vals = get_bits(gb, 5); 428 delta_bits = get_bits(gb, 3); 429 min_val = get_bits(gb, 6); 430 if (num_long_vals > ctx->used_quant_units || delta_bits == 7) { 431 av_log(avctx, AV_LOG_ERROR, 432 "SF mode 1: invalid parameters!\n"); 433 return AVERROR_INVALIDDATA; 434 } 435 436 /* read full-precision SF indexes */ 437 for (i = 0; i < num_long_vals; i++) 438 chan->qu_sf_idx[i] = get_bits(gb, 6); 439 440 /* all others are: min_val + delta */ 441 for (i = num_long_vals; i < ctx->used_quant_units; i++) 442 chan->qu_sf_idx[i] = (min_val + 443 get_bitsz(gb, delta_bits)) & 0x3F; 444 } 445 } 446 break; 447 case 2: 448 if (ch_num) { 449 vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)]; 450 451 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 452 chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F; 453 454 for (i = 1; i < ctx->used_quant_units; i++) { 455 diff = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1]; 456 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 457 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F; 458 } 459 } else { 460 vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4]; 461 462 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units); 463 464 for (i = 0; i < ctx->used_quant_units; i++) { 465 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 466 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + 467 sign_extend(delta, 4)) & 0x3F; 468 } 469 } 470 break; 471 case 3: 472 if (ch_num) { 473 /* copy coefficients from reference channel */ 474 for (i = 0; i < ctx->used_quant_units; i++) 475 chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i]; 476 } else { 477 weight_idx = get_bits(gb, 2); 478 vlc_sel = get_bits(gb, 2); 479 vlc_tab = &sf_vlc_tabs[vlc_sel]; 480 481 if (weight_idx == 3) { 482 vlc_tab = &sf_vlc_tabs[vlc_sel + 4]; 483 484 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units); 485 486 diff = (get_bits(gb, 4) + 56) & 0x3F; 487 chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F; 488 489 for (i = 1; i < ctx->used_quant_units; i++) { 490 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 491 diff = (diff + sign_extend(delta, 4)) & 0x3F; 492 chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i]) & 0x3F; 493 } 494 } else { 495 /* 1st coefficient is coded directly */ 496 chan->qu_sf_idx[0] = get_bits(gb, 6); 497 498 for (i = 1; i < ctx->used_quant_units; i++) { 499 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 500 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F; 501 } 502 } 503 } 504 break; 505 } 506 507 if (weight_idx && weight_idx < 3) 508 return subtract_sf_weights(ctx, chan, weight_idx, avctx); 509 510 return 0; 511} 512 513/** 514 * Decode word length information for each channel. 515 * 516 * @param[in] gb the GetBit context 517 * @param[in,out] ctx ptr to the channel unit context 518 * @param[in] num_channels number of channels to process 519 * @param[in] avctx ptr to the AVCodecContext 520 * @return result code: 0 = OK, otherwise - error code 521 */ 522static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 523 int num_channels, AVCodecContext *avctx) 524{ 525 int ch_num, i, ret; 526 527 for (ch_num = 0; ch_num < num_channels; ch_num++) { 528 memset(ctx->channels[ch_num].qu_wordlen, 0, 529 sizeof(ctx->channels[ch_num].qu_wordlen)); 530 531 if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0) 532 return ret; 533 } 534 535 /* scan for last non-zero coeff in both channels and 536 * set number of quant units having coded spectrum */ 537 for (i = ctx->num_quant_units - 1; i >= 0; i--) 538 if (ctx->channels[0].qu_wordlen[i] || 539 (num_channels == 2 && ctx->channels[1].qu_wordlen[i])) 540 break; 541 ctx->used_quant_units = i + 1; 542 543 return 0; 544} 545 546/** 547 * Decode scale factor indexes for each channel. 548 * 549 * @param[in] gb the GetBit context 550 * @param[in,out] ctx ptr to the channel unit context 551 * @param[in] num_channels number of channels to process 552 * @param[in] avctx ptr to the AVCodecContext 553 * @return result code: 0 = OK, otherwise - error code 554 */ 555static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 556 int num_channels, AVCodecContext *avctx) 557{ 558 int ch_num, ret; 559 560 if (!ctx->used_quant_units) 561 return 0; 562 563 for (ch_num = 0; ch_num < num_channels; ch_num++) { 564 memset(ctx->channels[ch_num].qu_sf_idx, 0, 565 sizeof(ctx->channels[ch_num].qu_sf_idx)); 566 567 if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0) 568 return ret; 569 } 570 571 return 0; 572} 573 574/** 575 * Decode number of code table values. 576 * 577 * @param[in] gb the GetBit context 578 * @param[in,out] ctx ptr to the channel unit context 579 * @param[in] avctx ptr to the AVCodecContext 580 * @return result code: 0 = OK, otherwise - error code 581 */ 582static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 583 AVCodecContext *avctx) 584{ 585 int num_coded_vals; 586 587 if (get_bits1(gb)) { 588 num_coded_vals = get_bits(gb, 5); 589 if (num_coded_vals > ctx->used_quant_units) { 590 av_log(avctx, AV_LOG_ERROR, 591 "Invalid number of code table indexes: %d!\n", num_coded_vals); 592 return AVERROR_INVALIDDATA; 593 } 594 return num_coded_vals; 595 } else 596 return ctx->used_quant_units; 597} 598 599#define DEC_CT_IDX_COMMON(OP) \ 600 num_vals = get_num_ct_values(gb, ctx, avctx); \ 601 if (num_vals < 0) \ 602 return num_vals; \ 603 \ 604 for (i = 0; i < num_vals; i++) { \ 605 if (chan->qu_wordlen[i]) { \ 606 chan->qu_tab_idx[i] = OP; \ 607 } else if (ch_num && ref_chan->qu_wordlen[i]) \ 608 /* get clone master flag */ \ 609 chan->qu_tab_idx[i] = get_bits1(gb); \ 610 } 611 612#define CODING_DIRECT get_bits(gb, num_bits) 613 614#define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1) 615 616#define CODING_VLC_DELTA \ 617 (!i) ? CODING_VLC \ 618 : (pred + get_vlc2(gb, delta_vlc->table, \ 619 delta_vlc->bits, 1)) & mask; \ 620 pred = chan->qu_tab_idx[i] 621 622#define CODING_VLC_DIFF \ 623 (ref_chan->qu_tab_idx[i] + \ 624 get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask 625 626/** 627 * Decode code table indexes for each quant unit of a channel. 628 * 629 * @param[in] gb the GetBit context 630 * @param[in,out] ctx ptr to the channel unit context 631 * @param[in] ch_num channel to process 632 * @param[in] avctx ptr to the AVCodecContext 633 * @return result code: 0 = OK, otherwise - error code 634 */ 635static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 636 int ch_num, AVCodecContext *avctx) 637{ 638 int i, num_vals, num_bits, pred; 639 int mask = ctx->use_full_table ? 7 : 3; /* mask for modular arithmetic */ 640 VLC *vlc_tab, *delta_vlc; 641 Atrac3pChanParams *chan = &ctx->channels[ch_num]; 642 Atrac3pChanParams *ref_chan = &ctx->channels[0]; 643 644 chan->table_type = get_bits1(gb); 645 646 switch (get_bits(gb, 2)) { /* switch according to coding mode */ 647 case 0: /* directly coded */ 648 num_bits = ctx->use_full_table + 2; 649 DEC_CT_IDX_COMMON(CODING_DIRECT); 650 break; 651 case 1: /* entropy-coded */ 652 vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1] 653 : ct_vlc_tabs; 654 DEC_CT_IDX_COMMON(CODING_VLC); 655 break; 656 case 2: /* entropy-coded delta */ 657 if (ctx->use_full_table) { 658 vlc_tab = &ct_vlc_tabs[1]; 659 delta_vlc = &ct_vlc_tabs[2]; 660 } else { 661 vlc_tab = ct_vlc_tabs; 662 delta_vlc = ct_vlc_tabs; 663 } 664 pred = 0; 665 DEC_CT_IDX_COMMON(CODING_VLC_DELTA); 666 break; 667 case 3: /* entropy-coded difference to master */ 668 if (ch_num) { 669 vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[3] 670 : ct_vlc_tabs; 671 DEC_CT_IDX_COMMON(CODING_VLC_DIFF); 672 } 673 break; 674 } 675 676 return 0; 677} 678 679/** 680 * Decode code table indexes for each channel. 681 * 682 * @param[in] gb the GetBit context 683 * @param[in,out] ctx ptr to the channel unit context 684 * @param[in] num_channels number of channels to process 685 * @param[in] avctx ptr to the AVCodecContext 686 * @return result code: 0 = OK, otherwise - error code 687 */ 688static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 689 int num_channels, AVCodecContext *avctx) 690{ 691 int ch_num, ret; 692 693 if (!ctx->used_quant_units) 694 return 0; 695 696 ctx->use_full_table = get_bits1(gb); 697 698 for (ch_num = 0; ch_num < num_channels; ch_num++) { 699 memset(ctx->channels[ch_num].qu_tab_idx, 0, 700 sizeof(ctx->channels[ch_num].qu_tab_idx)); 701 702 if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0) 703 return ret; 704 } 705 706 return 0; 707} 708 709/** 710 * Decode huffman-coded spectral lines for a given quant unit. 711 * 712 * This is a generalized version for all known coding modes. 713 * Its speed can be improved by creating separate functions for each mode. 714 * 715 * @param[in] gb the GetBit context 716 * @param[in] tab code table telling how to decode spectral lines 717 * @param[in] vlc_tab ptr to the huffman table associated with the code table 718 * @param[out] out pointer to buffer where decoded data should be stored 719 * @param[in] num_specs number of spectral lines to decode 720 */ 721static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab, 722 VLC *vlc_tab, int16_t *out, const int num_specs) 723{ 724 int i, j, pos, cf; 725 int group_size = tab->group_size; 726 int num_coeffs = tab->num_coeffs; 727 int bits = tab->bits; 728 int is_signed = tab->is_signed; 729 unsigned val; 730 731 for (pos = 0; pos < num_specs;) { 732 if (group_size == 1 || get_bits1(gb)) { 733 for (j = 0; j < group_size; j++) { 734 val = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1); 735 736 for (i = 0; i < num_coeffs; i++) { 737 cf = av_mod_uintp2(val, bits); 738 if (is_signed) 739 cf = sign_extend(cf, bits); 740 else if (cf && get_bits1(gb)) 741 cf = -cf; 742 743 out[pos++] = cf; 744 val >>= bits; 745 } 746 } 747 } else /* group skipped */ 748 pos += group_size * num_coeffs; 749 } 750} 751 752/** 753 * Decode huffman-coded IMDCT spectrum for all channels. 754 * 755 * @param[in] gb the GetBit context 756 * @param[in,out] ctx ptr to the channel unit context 757 * @param[in] num_channels number of channels to process 758 * @param[in] avctx ptr to the AVCodecContext 759 */ 760static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 761 int num_channels, AVCodecContext *avctx) 762{ 763 int i, ch_num, qu, wordlen, codetab, tab_index, num_specs; 764 const Atrac3pSpecCodeTab *tab; 765 Atrac3pChanParams *chan; 766 767 for (ch_num = 0; ch_num < num_channels; ch_num++) { 768 chan = &ctx->channels[ch_num]; 769 770 memset(chan->spectrum, 0, sizeof(chan->spectrum)); 771 772 /* set power compensation level to disabled */ 773 memset(chan->power_levs, ATRAC3P_POWER_COMP_OFF, sizeof(chan->power_levs)); 774 775 for (qu = 0; qu < ctx->used_quant_units; qu++) { 776 num_specs = ff_atrac3p_qu_to_spec_pos[qu + 1] - 777 ff_atrac3p_qu_to_spec_pos[qu]; 778 779 wordlen = chan->qu_wordlen[qu]; 780 codetab = chan->qu_tab_idx[qu]; 781 if (wordlen) { 782 if (!ctx->use_full_table) 783 codetab = atrac3p_ct_restricted_to_full[chan->table_type][wordlen - 1][codetab]; 784 785 tab_index = (chan->table_type * 8 + codetab) * 7 + wordlen - 1; 786 tab = &atrac3p_spectra_tabs[tab_index]; 787 788 decode_qu_spectra(gb, tab, &spec_vlc_tabs[tab_index], 789 &chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]], 790 num_specs); 791 } else if (ch_num && ctx->channels[0].qu_wordlen[qu] && !codetab) { 792 /* copy coefficients from master */ 793 memcpy(&chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]], 794 &ctx->channels[0].spectrum[ff_atrac3p_qu_to_spec_pos[qu]], 795 num_specs * 796 sizeof(chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]])); 797 chan->qu_wordlen[qu] = ctx->channels[0].qu_wordlen[qu]; 798 } 799 } 800 801 /* Power compensation levels only present in the bitstream 802 * if there are more than 2 quant units. The lowest two units 803 * correspond to the frequencies 0...351 Hz, whose shouldn't 804 * be affected by the power compensation. */ 805 if (ctx->used_quant_units > 2) { 806 num_specs = atrac3p_subband_to_num_powgrps[ctx->num_coded_subbands - 1]; 807 for (i = 0; i < num_specs; i++) 808 chan->power_levs[i] = get_bits(gb, 4); 809 } 810 } 811} 812 813/** 814 * Retrieve specified amount of flag bits from the input bitstream. 815 * The data can be shortened in the case of the following two common conditions: 816 * if all bits are zero then only one signal bit = 0 will be stored, 817 * if all bits are ones then two signal bits = 1,0 will be stored. 818 * Otherwise, all necessary bits will be directly stored 819 * prefixed by two signal bits = 1,1. 820 * 821 * @param[in] gb ptr to the GetBitContext 822 * @param[out] out where to place decoded flags 823 * @param[in] num_flags number of flags to process 824 * @return: 0 = all flag bits are zero, 1 = there is at least one non-zero flag bit 825 */ 826static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags) 827{ 828 int i, result; 829 830 memset(out, 0, num_flags); 831 832 result = get_bits1(gb); 833 if (result) { 834 if (get_bits1(gb)) 835 for (i = 0; i < num_flags; i++) 836 out[i] = get_bits1(gb); 837 else 838 memset(out, 1, num_flags); 839 } 840 841 return result; 842} 843 844/** 845 * Decode mdct window shape flags for all channels. 846 * 847 * @param[in] gb the GetBit context 848 * @param[in,out] ctx ptr to the channel unit context 849 * @param[in] num_channels number of channels to process 850 */ 851static void decode_window_shape(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 852 int num_channels) 853{ 854 int ch_num; 855 856 for (ch_num = 0; ch_num < num_channels; ch_num++) 857 get_subband_flags(gb, ctx->channels[ch_num].wnd_shape, 858 ctx->num_subbands); 859} 860 861/** 862 * Decode number of gain control points. 863 * 864 * @param[in] gb the GetBit context 865 * @param[in,out] ctx ptr to the channel unit context 866 * @param[in] ch_num channel to process 867 * @param[in] coded_subbands number of subbands to process 868 * @return result code: 0 = OK, otherwise - error code 869 */ 870static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 871 int ch_num, int coded_subbands) 872{ 873 int i, delta, delta_bits, min_val; 874 Atrac3pChanParams *chan = &ctx->channels[ch_num]; 875 Atrac3pChanParams *ref_chan = &ctx->channels[0]; 876 877 switch (get_bits(gb, 2)) { /* switch according to coding mode */ 878 case 0: /* fixed-length coding */ 879 for (i = 0; i < coded_subbands; i++) 880 chan->gain_data[i].num_points = get_bits(gb, 3); 881 break; 882 case 1: /* variable-length coding */ 883 for (i = 0; i < coded_subbands; i++) 884 chan->gain_data[i].num_points = 885 get_vlc2(gb, gain_vlc_tabs[0].table, 886 gain_vlc_tabs[0].bits, 1); 887 break; 888 case 2: 889 if (ch_num) { /* VLC modulo delta to master channel */ 890 for (i = 0; i < coded_subbands; i++) { 891 delta = get_vlc2(gb, gain_vlc_tabs[1].table, 892 gain_vlc_tabs[1].bits, 1); 893 chan->gain_data[i].num_points = 894 (ref_chan->gain_data[i].num_points + delta) & 7; 895 } 896 } else { /* VLC modulo delta to previous */ 897 chan->gain_data[0].num_points = 898 get_vlc2(gb, gain_vlc_tabs[0].table, 899 gain_vlc_tabs[0].bits, 1); 900 901 for (i = 1; i < coded_subbands; i++) { 902 delta = get_vlc2(gb, gain_vlc_tabs[1].table, 903 gain_vlc_tabs[1].bits, 1); 904 chan->gain_data[i].num_points = 905 (chan->gain_data[i - 1].num_points + delta) & 7; 906 } 907 } 908 break; 909 case 3: 910 if (ch_num) { /* copy data from master channel */ 911 for (i = 0; i < coded_subbands; i++) 912 chan->gain_data[i].num_points = 913 ref_chan->gain_data[i].num_points; 914 } else { /* shorter delta to min */ 915 delta_bits = get_bits(gb, 2); 916 min_val = get_bits(gb, 3); 917 918 for (i = 0; i < coded_subbands; i++) { 919 chan->gain_data[i].num_points = min_val + get_bitsz(gb, delta_bits); 920 if (chan->gain_data[i].num_points > 7) 921 return AVERROR_INVALIDDATA; 922 } 923 } 924 } 925 926 return 0; 927} 928 929/** 930 * Implements coding mode 3 (slave) for gain compensation levels. 931 * 932 * @param[out] dst ptr to the output array 933 * @param[in] ref ptr to the reference channel 934 */ 935static inline void gainc_level_mode3s(AtracGainInfo *dst, AtracGainInfo *ref) 936{ 937 int i; 938 939 for (i = 0; i < dst->num_points; i++) 940 dst->lev_code[i] = (i >= ref->num_points) ? 7 : ref->lev_code[i]; 941} 942 943/** 944 * Implements coding mode 1 (master) for gain compensation levels. 945 * 946 * @param[in] gb the GetBit context 947 * @param[in] ctx ptr to the channel unit context 948 * @param[out] dst ptr to the output array 949 */ 950static inline void gainc_level_mode1m(GetBitContext *gb, 951 Atrac3pChanUnitCtx *ctx, 952 AtracGainInfo *dst) 953{ 954 int i, delta; 955 956 if (dst->num_points > 0) 957 dst->lev_code[0] = get_vlc2(gb, gain_vlc_tabs[2].table, 958 gain_vlc_tabs[2].bits, 1); 959 960 for (i = 1; i < dst->num_points; i++) { 961 delta = get_vlc2(gb, gain_vlc_tabs[3].table, 962 gain_vlc_tabs[3].bits, 1); 963 dst->lev_code[i] = (dst->lev_code[i - 1] + delta) & 0xF; 964 } 965} 966 967/** 968 * Decode level code for each gain control point. 969 * 970 * @param[in] gb the GetBit context 971 * @param[in,out] ctx ptr to the channel unit context 972 * @param[in] ch_num channel to process 973 * @param[in] coded_subbands number of subbands to process 974 * @return result code: 0 = OK, otherwise - error code 975 */ 976static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 977 int ch_num, int coded_subbands) 978{ 979 int sb, i, delta, delta_bits, min_val, pred; 980 Atrac3pChanParams *chan = &ctx->channels[ch_num]; 981 Atrac3pChanParams *ref_chan = &ctx->channels[0]; 982 983 switch (get_bits(gb, 2)) { /* switch according to coding mode */ 984 case 0: /* fixed-length coding */ 985 for (sb = 0; sb < coded_subbands; sb++) 986 for (i = 0; i < chan->gain_data[sb].num_points; i++) 987 chan->gain_data[sb].lev_code[i] = get_bits(gb, 4); 988 break; 989 case 1: 990 if (ch_num) { /* VLC modulo delta to master channel */ 991 for (sb = 0; sb < coded_subbands; sb++) 992 for (i = 0; i < chan->gain_data[sb].num_points; i++) { 993 delta = get_vlc2(gb, gain_vlc_tabs[5].table, 994 gain_vlc_tabs[5].bits, 1); 995 pred = (i >= ref_chan->gain_data[sb].num_points) 996 ? 7 : ref_chan->gain_data[sb].lev_code[i]; 997 chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF; 998 } 999 } else { /* VLC modulo delta to previous */ 1000 for (sb = 0; sb < coded_subbands; sb++) 1001 gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]); 1002 } 1003 break; 1004 case 2: 1005 if (ch_num) { /* VLC modulo delta to previous or clone master */ 1006 for (sb = 0; sb < coded_subbands; sb++) 1007 if (chan->gain_data[sb].num_points > 0) { 1008 if (get_bits1(gb)) 1009 gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]); 1010 else 1011 gainc_level_mode3s(&chan->gain_data[sb], 1012 &ref_chan->gain_data[sb]); 1013 } 1014 } else { /* VLC modulo delta to lev_codes of previous subband */ 1015 if (chan->gain_data[0].num_points > 0) 1016 gainc_level_mode1m(gb, ctx, &chan->gain_data[0]); 1017 1018 for (sb = 1; sb < coded_subbands; sb++) 1019 for (i = 0; i < chan->gain_data[sb].num_points; i++) { 1020 delta = get_vlc2(gb, gain_vlc_tabs[4].table, 1021 gain_vlc_tabs[4].bits, 1); 1022 pred = (i >= chan->gain_data[sb - 1].num_points) 1023 ? 7 : chan->gain_data[sb - 1].lev_code[i]; 1024 chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF; 1025 } 1026 } 1027 break; 1028 case 3: 1029 if (ch_num) { /* clone master */ 1030 for (sb = 0; sb < coded_subbands; sb++) 1031 gainc_level_mode3s(&chan->gain_data[sb], 1032 &ref_chan->gain_data[sb]); 1033 } else { /* shorter delta to min */ 1034 delta_bits = get_bits(gb, 2); 1035 min_val = get_bits(gb, 4); 1036 1037 for (sb = 0; sb < coded_subbands; sb++) 1038 for (i = 0; i < chan->gain_data[sb].num_points; i++) { 1039 chan->gain_data[sb].lev_code[i] = min_val + get_bitsz(gb, delta_bits); 1040 if (chan->gain_data[sb].lev_code[i] > 15) 1041 return AVERROR_INVALIDDATA; 1042 } 1043 } 1044 break; 1045 } 1046 1047 return 0; 1048} 1049 1050/** 1051 * Implements coding mode 0 for gain compensation locations. 1052 * 1053 * @param[in] gb the GetBit context 1054 * @param[in] ctx ptr to the channel unit context 1055 * @param[out] dst ptr to the output array 1056 * @param[in] pos position of the value to be processed 1057 */ 1058static inline void gainc_loc_mode0(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1059 AtracGainInfo *dst, int pos) 1060{ 1061 int delta_bits; 1062 1063 if (!pos || dst->loc_code[pos - 1] < 15) 1064 dst->loc_code[pos] = get_bits(gb, 5); 1065 else if (dst->loc_code[pos - 1] >= 30) 1066 dst->loc_code[pos] = 31; 1067 else { 1068 delta_bits = av_log2(30 - dst->loc_code[pos - 1]) + 1; 1069 dst->loc_code[pos] = dst->loc_code[pos - 1] + 1070 get_bits(gb, delta_bits) + 1; 1071 } 1072} 1073 1074/** 1075 * Implements coding mode 1 for gain compensation locations. 1076 * 1077 * @param[in] gb the GetBit context 1078 * @param[in] ctx ptr to the channel unit context 1079 * @param[out] dst ptr to the output array 1080 */ 1081static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1082 AtracGainInfo *dst) 1083{ 1084 int i; 1085 VLC *tab; 1086 1087 if (dst->num_points > 0) { 1088 /* 1st coefficient is stored directly */ 1089 dst->loc_code[0] = get_bits(gb, 5); 1090 1091 for (i = 1; i < dst->num_points; i++) { 1092 /* switch VLC according to the curve direction 1093 * (ascending/descending) */ 1094 tab = (dst->lev_code[i] <= dst->lev_code[i - 1]) 1095 ? &gain_vlc_tabs[7] 1096 : &gain_vlc_tabs[9]; 1097 dst->loc_code[i] = dst->loc_code[i - 1] + 1098 get_vlc2(gb, tab->table, tab->bits, 1); 1099 } 1100 } 1101} 1102 1103/** 1104 * Decode location code for each gain control point. 1105 * 1106 * @param[in] gb the GetBit context 1107 * @param[in,out] ctx ptr to the channel unit context 1108 * @param[in] ch_num channel to process 1109 * @param[in] coded_subbands number of subbands to process 1110 * @param[in] avctx ptr to the AVCodecContext 1111 * @return result code: 0 = OK, otherwise - error code 1112 */ 1113static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1114 int ch_num, int coded_subbands, 1115 AVCodecContext *avctx) 1116{ 1117 int sb, i, delta, delta_bits, min_val, pred, more_than_ref; 1118 AtracGainInfo *dst, *ref; 1119 VLC *tab; 1120 Atrac3pChanParams *chan = &ctx->channels[ch_num]; 1121 Atrac3pChanParams *ref_chan = &ctx->channels[0]; 1122 1123 switch (get_bits(gb, 2)) { /* switch according to coding mode */ 1124 case 0: /* sequence of numbers in ascending order */ 1125 for (sb = 0; sb < coded_subbands; sb++) 1126 for (i = 0; i < chan->gain_data[sb].num_points; i++) 1127 gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i); 1128 break; 1129 case 1: 1130 if (ch_num) { 1131 for (sb = 0; sb < coded_subbands; sb++) { 1132 if (chan->gain_data[sb].num_points <= 0) 1133 continue; 1134 dst = &chan->gain_data[sb]; 1135 ref = &ref_chan->gain_data[sb]; 1136 1137 /* 1st value is vlc-coded modulo delta to master */ 1138 delta = get_vlc2(gb, gain_vlc_tabs[10].table, 1139 gain_vlc_tabs[10].bits, 1); 1140 pred = ref->num_points > 0 ? ref->loc_code[0] : 0; 1141 dst->loc_code[0] = (pred + delta) & 0x1F; 1142 1143 for (i = 1; i < dst->num_points; i++) { 1144 more_than_ref = i >= ref->num_points; 1145 if (dst->lev_code[i] > dst->lev_code[i - 1]) { 1146 /* ascending curve */ 1147 if (more_than_ref) { 1148 delta = 1149 get_vlc2(gb, gain_vlc_tabs[9].table, 1150 gain_vlc_tabs[9].bits, 1); 1151 dst->loc_code[i] = dst->loc_code[i - 1] + delta; 1152 } else { 1153 if (get_bits1(gb)) 1154 gainc_loc_mode0(gb, ctx, dst, i); // direct coding 1155 else 1156 dst->loc_code[i] = ref->loc_code[i]; // clone master 1157 } 1158 } else { /* descending curve */ 1159 tab = more_than_ref ? &gain_vlc_tabs[7] 1160 : &gain_vlc_tabs[10]; 1161 delta = get_vlc2(gb, tab->table, tab->bits, 1); 1162 if (more_than_ref) 1163 dst->loc_code[i] = dst->loc_code[i - 1] + delta; 1164 else 1165 dst->loc_code[i] = (ref->loc_code[i] + delta) & 0x1F; 1166 } 1167 } 1168 } 1169 } else /* VLC delta to previous */ 1170 for (sb = 0; sb < coded_subbands; sb++) 1171 gainc_loc_mode1(gb, ctx, &chan->gain_data[sb]); 1172 break; 1173 case 2: 1174 if (ch_num) { 1175 for (sb = 0; sb < coded_subbands; sb++) { 1176 if (chan->gain_data[sb].num_points <= 0) 1177 continue; 1178 dst = &chan->gain_data[sb]; 1179 ref = &ref_chan->gain_data[sb]; 1180 if (dst->num_points > ref->num_points || get_bits1(gb)) 1181 gainc_loc_mode1(gb, ctx, dst); 1182 else /* clone master for the whole subband */ 1183 for (i = 0; i < chan->gain_data[sb].num_points; i++) 1184 dst->loc_code[i] = ref->loc_code[i]; 1185 } 1186 } else { 1187 /* data for the first subband is coded directly */ 1188 for (i = 0; i < chan->gain_data[0].num_points; i++) 1189 gainc_loc_mode0(gb, ctx, &chan->gain_data[0], i); 1190 1191 for (sb = 1; sb < coded_subbands; sb++) { 1192 if (chan->gain_data[sb].num_points <= 0) 1193 continue; 1194 dst = &chan->gain_data[sb]; 1195 1196 /* 1st value is vlc-coded modulo delta to the corresponding 1197 * value of the previous subband if any or zero */ 1198 delta = get_vlc2(gb, gain_vlc_tabs[6].table, 1199 gain_vlc_tabs[6].bits, 1); 1200 pred = dst[-1].num_points > 0 1201 ? dst[-1].loc_code[0] : 0; 1202 dst->loc_code[0] = (pred + delta) & 0x1F; 1203 1204 for (i = 1; i < dst->num_points; i++) { 1205 more_than_ref = i >= dst[-1].num_points; 1206 /* Select VLC table according to curve direction and 1207 * presence of prediction. */ 1208 tab = &gain_vlc_tabs[(dst->lev_code[i] > dst->lev_code[i - 1]) * 1209 2 + more_than_ref + 6]; 1210 delta = get_vlc2(gb, tab->table, tab->bits, 1); 1211 if (more_than_ref) 1212 dst->loc_code[i] = dst->loc_code[i - 1] + delta; 1213 else 1214 dst->loc_code[i] = (dst[-1].loc_code[i] + delta) & 0x1F; 1215 } 1216 } 1217 } 1218 break; 1219 case 3: 1220 if (ch_num) { /* clone master or direct or direct coding */ 1221 for (sb = 0; sb < coded_subbands; sb++) 1222 for (i = 0; i < chan->gain_data[sb].num_points; i++) { 1223 if (i >= ref_chan->gain_data[sb].num_points) 1224 gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i); 1225 else 1226 chan->gain_data[sb].loc_code[i] = 1227 ref_chan->gain_data[sb].loc_code[i]; 1228 } 1229 } else { /* shorter delta to min */ 1230 delta_bits = get_bits(gb, 2) + 1; 1231 min_val = get_bits(gb, 5); 1232 1233 for (sb = 0; sb < coded_subbands; sb++) 1234 for (i = 0; i < chan->gain_data[sb].num_points; i++) 1235 chan->gain_data[sb].loc_code[i] = min_val + i + 1236 get_bits(gb, delta_bits); 1237 } 1238 break; 1239 } 1240 1241 /* Validate decoded information */ 1242 for (sb = 0; sb < coded_subbands; sb++) { 1243 dst = &chan->gain_data[sb]; 1244 for (i = 0; i < chan->gain_data[sb].num_points; i++) { 1245 if (dst->loc_code[i] < 0 || dst->loc_code[i] > 31 || 1246 (i && dst->loc_code[i] <= dst->loc_code[i - 1])) { 1247 av_log(avctx, AV_LOG_ERROR, 1248 "Invalid gain location: ch=%d, sb=%d, pos=%d, val=%d\n", 1249 ch_num, sb, i, dst->loc_code[i]); 1250 return AVERROR_INVALIDDATA; 1251 } 1252 } 1253 } 1254 1255 return 0; 1256} 1257 1258/** 1259 * Decode gain control data for all channels. 1260 * 1261 * @param[in] gb the GetBit context 1262 * @param[in,out] ctx ptr to the channel unit context 1263 * @param[in] num_channels number of channels to process 1264 * @param[in] avctx ptr to the AVCodecContext 1265 * @return result code: 0 = OK, otherwise - error code 1266 */ 1267static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1268 int num_channels, AVCodecContext *avctx) 1269{ 1270 int ch_num, coded_subbands, sb, ret; 1271 1272 for (ch_num = 0; ch_num < num_channels; ch_num++) { 1273 memset(ctx->channels[ch_num].gain_data, 0, 1274 sizeof(*ctx->channels[ch_num].gain_data) * ATRAC3P_SUBBANDS); 1275 1276 if (get_bits1(gb)) { /* gain control data present? */ 1277 coded_subbands = get_bits(gb, 4) + 1; 1278 if (get_bits1(gb)) /* is high band gain data replication on? */ 1279 ctx->channels[ch_num].num_gain_subbands = get_bits(gb, 4) + 1; 1280 else 1281 ctx->channels[ch_num].num_gain_subbands = coded_subbands; 1282 1283 if ((ret = decode_gainc_npoints(gb, ctx, ch_num, coded_subbands)) < 0 || 1284 (ret = decode_gainc_levels(gb, ctx, ch_num, coded_subbands)) < 0 || 1285 (ret = decode_gainc_loc_codes(gb, ctx, ch_num, coded_subbands, avctx)) < 0) 1286 return ret; 1287 1288 if (coded_subbands > 0) { /* propagate gain data if requested */ 1289 for (sb = coded_subbands; sb < ctx->channels[ch_num].num_gain_subbands; sb++) 1290 ctx->channels[ch_num].gain_data[sb] = 1291 ctx->channels[ch_num].gain_data[sb - 1]; 1292 } 1293 } else { 1294 ctx->channels[ch_num].num_gain_subbands = 0; 1295 } 1296 } 1297 1298 return 0; 1299} 1300 1301/** 1302 * Decode envelope for all tones of a channel. 1303 * 1304 * @param[in] gb the GetBit context 1305 * @param[in,out] ctx ptr to the channel unit context 1306 * @param[in] ch_num channel to process 1307 * @param[in] band_has_tones ptr to an array of per-band-flags: 1308 * 1 - tone data present 1309 */ 1310static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1311 int ch_num, int band_has_tones[]) 1312{ 1313 int sb; 1314 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; 1315 Atrac3pWavesData *ref = ctx->channels[0].tones_info; 1316 1317 if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */ 1318 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1319 if (!band_has_tones[sb]) 1320 continue; 1321 dst[sb].pend_env.has_start_point = get_bits1(gb); 1322 dst[sb].pend_env.start_pos = dst[sb].pend_env.has_start_point 1323 ? get_bits(gb, 5) : -1; 1324 dst[sb].pend_env.has_stop_point = get_bits1(gb); 1325 dst[sb].pend_env.stop_pos = dst[sb].pend_env.has_stop_point 1326 ? get_bits(gb, 5) : 32; 1327 } 1328 } else { /* mode 1(slave only): copy master */ 1329 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1330 if (!band_has_tones[sb]) 1331 continue; 1332 dst[sb].pend_env.has_start_point = ref[sb].pend_env.has_start_point; 1333 dst[sb].pend_env.has_stop_point = ref[sb].pend_env.has_stop_point; 1334 dst[sb].pend_env.start_pos = ref[sb].pend_env.start_pos; 1335 dst[sb].pend_env.stop_pos = ref[sb].pend_env.stop_pos; 1336 } 1337 } 1338} 1339 1340/** 1341 * Decode number of tones for each subband of a channel. 1342 * 1343 * @param[in] gb the GetBit context 1344 * @param[in,out] ctx ptr to the channel unit context 1345 * @param[in] ch_num channel to process 1346 * @param[in] band_has_tones ptr to an array of per-band-flags: 1347 * 1 - tone data present 1348 * @param[in] avctx ptr to the AVCodecContext 1349 * @return result code: 0 = OK, otherwise - error code 1350 */ 1351static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1352 int ch_num, int band_has_tones[], 1353 AVCodecContext *avctx) 1354{ 1355 int mode, sb, delta; 1356 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; 1357 Atrac3pWavesData *ref = ctx->channels[0].tones_info; 1358 1359 mode = get_bits(gb, ch_num + 1); 1360 switch (mode) { 1361 case 0: /** fixed-length coding */ 1362 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) 1363 if (band_has_tones[sb]) 1364 dst[sb].num_wavs = get_bits(gb, 4); 1365 break; 1366 case 1: /** variable-length coding */ 1367 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) 1368 if (band_has_tones[sb]) 1369 dst[sb].num_wavs = 1370 get_vlc2(gb, tone_vlc_tabs[1].table, 1371 tone_vlc_tabs[1].bits, 1); 1372 break; 1373 case 2: /** VLC modulo delta to master (slave only) */ 1374 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) 1375 if (band_has_tones[sb]) { 1376 delta = get_vlc2(gb, tone_vlc_tabs[2].table, 1377 tone_vlc_tabs[2].bits, 1); 1378 delta = sign_extend(delta, 3); 1379 dst[sb].num_wavs = (ref[sb].num_wavs + delta) & 0xF; 1380 } 1381 break; 1382 case 3: /** copy master (slave only) */ 1383 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) 1384 if (band_has_tones[sb]) 1385 dst[sb].num_wavs = ref[sb].num_wavs; 1386 break; 1387 } 1388 1389 /** initialize start tone index for each subband */ 1390 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) 1391 if (band_has_tones[sb]) { 1392 if (ctx->waves_info->tones_index + dst[sb].num_wavs > 48) { 1393 av_log(avctx, AV_LOG_ERROR, 1394 "Too many tones: %d (max. 48), frame: %d!\n", 1395 ctx->waves_info->tones_index + dst[sb].num_wavs, 1396 avctx->frame_number); 1397 return AVERROR_INVALIDDATA; 1398 } 1399 dst[sb].start_index = ctx->waves_info->tones_index; 1400 ctx->waves_info->tones_index += dst[sb].num_wavs; 1401 } 1402 1403 return 0; 1404} 1405 1406/** 1407 * Decode frequency information for each subband of a channel. 1408 * 1409 * @param[in] gb the GetBit context 1410 * @param[in,out] ctx ptr to the channel unit context 1411 * @param[in] ch_num channel to process 1412 * @param[in] band_has_tones ptr to an array of per-band-flags: 1413 * 1 - tone data present 1414 */ 1415static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1416 int ch_num, int band_has_tones[]) 1417{ 1418 int sb, i, direction, nbits, pred, delta; 1419 Atrac3pWaveParam *iwav, *owav; 1420 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; 1421 Atrac3pWavesData *ref = ctx->channels[0].tones_info; 1422 1423 if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */ 1424 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1425 if (!band_has_tones[sb] || !dst[sb].num_wavs) 1426 continue; 1427 iwav = &ctx->waves_info->waves[dst[sb].start_index]; 1428 direction = (dst[sb].num_wavs > 1) ? get_bits1(gb) : 0; 1429 if (direction) { /** packed numbers in descending order */ 1430 if (dst[sb].num_wavs) 1431 iwav[dst[sb].num_wavs - 1].freq_index = get_bits(gb, 10); 1432 for (i = dst[sb].num_wavs - 2; i >= 0 ; i--) { 1433 nbits = av_log2(iwav[i+1].freq_index) + 1; 1434 iwav[i].freq_index = get_bits(gb, nbits); 1435 } 1436 } else { /** packed numbers in ascending order */ 1437 for (i = 0; i < dst[sb].num_wavs; i++) { 1438 if (!i || iwav[i - 1].freq_index < 512) 1439 iwav[i].freq_index = get_bits(gb, 10); 1440 else { 1441 nbits = av_log2(1023 - iwav[i - 1].freq_index) + 1; 1442 iwav[i].freq_index = get_bits(gb, nbits) + 1443 1024 - (1 << nbits); 1444 } 1445 } 1446 } 1447 } 1448 } else { /* mode 1: VLC modulo delta to master (slave only) */ 1449 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1450 if (!band_has_tones[sb] || !dst[sb].num_wavs) 1451 continue; 1452 iwav = &ctx->waves_info->waves[ref[sb].start_index]; 1453 owav = &ctx->waves_info->waves[dst[sb].start_index]; 1454 for (i = 0; i < dst[sb].num_wavs; i++) { 1455 delta = get_vlc2(gb, tone_vlc_tabs[6].table, 1456 tone_vlc_tabs[6].bits, 1); 1457 delta = sign_extend(delta, 8); 1458 pred = (i < ref[sb].num_wavs) ? iwav[i].freq_index : 1459 (ref[sb].num_wavs ? iwav[ref[sb].num_wavs - 1].freq_index : 0); 1460 owav[i].freq_index = (pred + delta) & 0x3FF; 1461 } 1462 } 1463 } 1464} 1465 1466/** 1467 * Decode amplitude information for each subband of a channel. 1468 * 1469 * @param[in] gb the GetBit context 1470 * @param[in,out] ctx ptr to the channel unit context 1471 * @param[in] ch_num channel to process 1472 * @param[in] band_has_tones ptr to an array of per-band-flags: 1473 * 1 - tone data present 1474 */ 1475static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1476 int ch_num, int band_has_tones[]) 1477{ 1478 int mode, sb, j, i, diff, maxdiff, fi, delta, pred; 1479 Atrac3pWaveParam *wsrc, *wref; 1480 int refwaves[48] = { 0 }; 1481 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; 1482 Atrac3pWavesData *ref = ctx->channels[0].tones_info; 1483 1484 if (ch_num) { 1485 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1486 if (!band_has_tones[sb] || !dst[sb].num_wavs) 1487 continue; 1488 wsrc = &ctx->waves_info->waves[dst[sb].start_index]; 1489 wref = &ctx->waves_info->waves[ref[sb].start_index]; 1490 for (j = 0; j < dst[sb].num_wavs; j++) { 1491 for (i = 0, fi = 0, maxdiff = 1024; i < ref[sb].num_wavs; i++) { 1492 diff = FFABS(wsrc[j].freq_index - wref[i].freq_index); 1493 if (diff < maxdiff) { 1494 maxdiff = diff; 1495 fi = i; 1496 } 1497 } 1498 1499 if (maxdiff < 8) 1500 refwaves[dst[sb].start_index + j] = fi + ref[sb].start_index; 1501 else if (j < ref[sb].num_wavs) 1502 refwaves[dst[sb].start_index + j] = j + ref[sb].start_index; 1503 else 1504 refwaves[dst[sb].start_index + j] = -1; 1505 } 1506 } 1507 } 1508 1509 mode = get_bits(gb, ch_num + 1); 1510 1511 switch (mode) { 1512 case 0: /** fixed-length coding */ 1513 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1514 if (!band_has_tones[sb] || !dst[sb].num_wavs) 1515 continue; 1516 if (ctx->waves_info->amplitude_mode) 1517 for (i = 0; i < dst[sb].num_wavs; i++) 1518 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = get_bits(gb, 6); 1519 else 1520 ctx->waves_info->waves[dst[sb].start_index].amp_sf = get_bits(gb, 6); 1521 } 1522 break; 1523 case 1: /** min + VLC delta */ 1524 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1525 if (!band_has_tones[sb] || !dst[sb].num_wavs) 1526 continue; 1527 if (ctx->waves_info->amplitude_mode) 1528 for (i = 0; i < dst[sb].num_wavs; i++) 1529 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = 1530 get_vlc2(gb, tone_vlc_tabs[3].table, 1531 tone_vlc_tabs[3].bits, 1) + 20; 1532 else 1533 ctx->waves_info->waves[dst[sb].start_index].amp_sf = 1534 get_vlc2(gb, tone_vlc_tabs[4].table, 1535 tone_vlc_tabs[4].bits, 1) + 24; 1536 } 1537 break; 1538 case 2: /** VLC modulo delta to master (slave only) */ 1539 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1540 if (!band_has_tones[sb] || !dst[sb].num_wavs) 1541 continue; 1542 for (i = 0; i < dst[sb].num_wavs; i++) { 1543 delta = get_vlc2(gb, tone_vlc_tabs[5].table, 1544 tone_vlc_tabs[5].bits, 1); 1545 delta = sign_extend(delta, 5); 1546 pred = refwaves[dst[sb].start_index + i] >= 0 ? 1547 ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf : 34; 1548 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = (pred + delta) & 0x3F; 1549 } 1550 } 1551 break; 1552 case 3: /** clone master (slave only) */ 1553 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1554 if (!band_has_tones[sb]) 1555 continue; 1556 for (i = 0; i < dst[sb].num_wavs; i++) 1557 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = 1558 refwaves[dst[sb].start_index + i] >= 0 1559 ? ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf 1560 : 32; 1561 } 1562 break; 1563 } 1564} 1565 1566/** 1567 * Decode phase information for each subband of a channel. 1568 * 1569 * @param[in] gb the GetBit context 1570 * @param[in,out] ctx ptr to the channel unit context 1571 * @param[in] ch_num channel to process 1572 * @param[in] band_has_tones ptr to an array of per-band-flags: 1573 * 1 - tone data present 1574 */ 1575static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1576 int ch_num, int band_has_tones[]) 1577{ 1578 int sb, i; 1579 Atrac3pWaveParam *wparam; 1580 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info; 1581 1582 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) { 1583 if (!band_has_tones[sb]) 1584 continue; 1585 wparam = &ctx->waves_info->waves[dst[sb].start_index]; 1586 for (i = 0; i < dst[sb].num_wavs; i++) 1587 wparam[i].phase_index = get_bits(gb, 5); 1588 } 1589} 1590 1591/** 1592 * Decode tones info for all channels. 1593 * 1594 * @param[in] gb the GetBit context 1595 * @param[in,out] ctx ptr to the channel unit context 1596 * @param[in] num_channels number of channels to process 1597 * @param[in] avctx ptr to the AVCodecContext 1598 * @return result code: 0 = OK, otherwise - error code 1599 */ 1600static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1601 int num_channels, AVCodecContext *avctx) 1602{ 1603 int ch_num, i, ret; 1604 int band_has_tones[16]; 1605 1606 for (ch_num = 0; ch_num < num_channels; ch_num++) 1607 memset(ctx->channels[ch_num].tones_info, 0, 1608 sizeof(*ctx->channels[ch_num].tones_info) * ATRAC3P_SUBBANDS); 1609 1610 ctx->waves_info->tones_present = get_bits1(gb); 1611 if (!ctx->waves_info->tones_present) 1612 return 0; 1613 1614 memset(ctx->waves_info->waves, 0, sizeof(ctx->waves_info->waves)); 1615 1616 ctx->waves_info->amplitude_mode = get_bits1(gb); 1617 if (!ctx->waves_info->amplitude_mode) { 1618 avpriv_report_missing_feature(avctx, "GHA amplitude mode 0"); 1619 return AVERROR_PATCHWELCOME; 1620 } 1621 1622 ctx->waves_info->num_tone_bands = 1623 get_vlc2(gb, tone_vlc_tabs[0].table, 1624 tone_vlc_tabs[0].bits, 1) + 1; 1625 1626 if (num_channels == 2) { 1627 get_subband_flags(gb, ctx->waves_info->tone_sharing, ctx->waves_info->num_tone_bands); 1628 get_subband_flags(gb, ctx->waves_info->tone_master, ctx->waves_info->num_tone_bands); 1629 get_subband_flags(gb, ctx->waves_info->invert_phase, ctx->waves_info->num_tone_bands); 1630 } 1631 1632 ctx->waves_info->tones_index = 0; 1633 1634 for (ch_num = 0; ch_num < num_channels; ch_num++) { 1635 for (i = 0; i < ctx->waves_info->num_tone_bands; i++) 1636 band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i]; 1637 1638 decode_tones_envelope(gb, ctx, ch_num, band_has_tones); 1639 if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones, 1640 avctx)) < 0) 1641 return ret; 1642 1643 decode_tones_frequency(gb, ctx, ch_num, band_has_tones); 1644 decode_tones_amplitude(gb, ctx, ch_num, band_has_tones); 1645 decode_tones_phase(gb, ctx, ch_num, band_has_tones); 1646 } 1647 1648 if (num_channels == 2) { 1649 for (i = 0; i < ctx->waves_info->num_tone_bands; i++) { 1650 if (ctx->waves_info->tone_sharing[i]) 1651 ctx->channels[1].tones_info[i] = ctx->channels[0].tones_info[i]; 1652 1653 if (ctx->waves_info->tone_master[i]) 1654 FFSWAP(Atrac3pWavesData, ctx->channels[0].tones_info[i], 1655 ctx->channels[1].tones_info[i]); 1656 } 1657 } 1658 1659 return 0; 1660} 1661 1662int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, 1663 int num_channels, AVCodecContext *avctx) 1664{ 1665 int ret; 1666 1667 /* parse sound header */ 1668 ctx->num_quant_units = get_bits(gb, 5) + 1; 1669 if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) { 1670 av_log(avctx, AV_LOG_ERROR, 1671 "Invalid number of quantization units: %d!\n", 1672 ctx->num_quant_units); 1673 return AVERROR_INVALIDDATA; 1674 } 1675 1676 ctx->mute_flag = get_bits1(gb); 1677 1678 /* decode various sound parameters */ 1679 if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0) 1680 return ret; 1681 1682 ctx->num_subbands = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1; 1683 ctx->num_coded_subbands = ctx->used_quant_units 1684 ? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1 1685 : 0; 1686 1687 if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0) 1688 return ret; 1689 1690 if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0) 1691 return ret; 1692 1693 decode_spectrum(gb, ctx, num_channels, avctx); 1694 1695 if (num_channels == 2) { 1696 get_subband_flags(gb, ctx->swap_channels, ctx->num_coded_subbands); 1697 get_subband_flags(gb, ctx->negate_coeffs, ctx->num_coded_subbands); 1698 } 1699 1700 decode_window_shape(gb, ctx, num_channels); 1701 1702 if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0) 1703 return ret; 1704 1705 if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0) 1706 return ret; 1707 1708 /* decode global noise info */ 1709 ctx->noise_present = get_bits1(gb); 1710 if (ctx->noise_present) { 1711 ctx->noise_level_index = get_bits(gb, 4); 1712 ctx->noise_table_index = get_bits(gb, 4); 1713 } 1714 1715 return 0; 1716} 1717