| /* |
| * ArithmeticDec.cpp |
| * |
| * Copyright 2021 HIMSA II K/S - www.himsa.com. Represented by EHIMA - |
| * www.ehima.com |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "ArithmeticDec.hpp" |
| |
| #include <algorithm> // std::min |
| #include <cmath> |
| #include <cstring> |
| |
| #include "BitReader.hpp" |
| #include "SpectralDataTables.hpp" |
| #include "TemporalNoiseShapingTables.hpp" |
| |
| namespace Lc3Dec { |
| |
| ArithmeticDec::ArithmeticDec(uint16_t NF_, uint16_t NE_, uint16_t rateFlag_, |
| uint8_t tns_lpc_weighting_) |
| : NF(NF_), |
| NE(NE_), |
| rateFlag(rateFlag_), |
| tns_lpc_weighting(tns_lpc_weighting_), |
| X_hat_q_ari(nullptr), |
| save_lev(nullptr), |
| nf_seed(0), |
| nbits_residual(0) { |
| X_hat_q_ari = new int16_t[NE]; |
| save_lev = new uint8_t[NE]; |
| } |
| |
| ArithmeticDec::~ArithmeticDec() { |
| delete[] X_hat_q_ari; |
| delete[] save_lev; |
| } |
| |
| void ac_dec_init(const uint8_t bytes[], uint16_t* bp, struct ac_dec_state* st) { |
| st->low = 0; |
| st->range = 0x00ffffff; |
| for (uint8_t i = 0; i < 3; i++) { |
| st->low <<= 8; |
| st->low += bytes[(*bp)++]; |
| } |
| } |
| |
| uint8_t ac_decode(const uint8_t bytes[], uint16_t* bp, struct ac_dec_state* st, |
| int16_t cum_freq[], int16_t sym_freq[], uint8_t numsym, |
| uint8_t& BEC_detect) { |
| uint32_t tmp = st->range >> 10; |
| if (st->low >= (tmp << 10)) { |
| BEC_detect = 1; |
| return 0; |
| } |
| uint8_t val = numsym - 1; |
| while (st->low < tmp * cum_freq[val]) { |
| val--; |
| } |
| st->low -= tmp * cum_freq[val]; |
| st->range = tmp * sym_freq[val]; |
| while (st->range < 0x10000) { |
| st->low <<= 8; |
| st->low &= 0x00ffffff; |
| st->low += bytes[(*bp)++]; |
| st->range <<= 8; |
| } |
| return val; |
| } |
| |
| double ArithmeticDec::rc_q(uint8_t k, uint8_t f) { |
| // with Δ =π/17 |
| const double pi = std::acos(-1); |
| double quantizer_stepsize = pi / 17.0; |
| return sin(quantizer_stepsize * (rc_i[k + 8 * f] - 8)); |
| } |
| |
| void ArithmeticDec::run(const uint8_t* bytes, uint16_t& bp, uint16_t& bp_side, |
| uint8_t& mask_side, int16_t& num_tns_filters, |
| int16_t rc_order[], const uint8_t& lsbMode, |
| const int16_t& lastnz, uint16_t nbits, |
| uint8_t& BEC_detect) { |
| int16_t c = 0; |
| |
| // make local copy of rc_order (is this really what we want) |
| rc_order_ari[0] = rc_order[0]; |
| rc_order_ari[1] = rc_order[1]; |
| |
| /* Arithmetic Decoder Initialization */ |
| ac_dec_init(bytes, &bp, &st); |
| |
| /* TNS data */ |
| // Note: some initialization code like that below can be found in d09r02, |
| // but there has been none in d09r01. However, the complete |
| // initialization has been added here, in order to get a proper match to |
| // the reference output data |
| for (uint8_t f = 0; f < 2; f++) { |
| for (uint8_t k = 0; k < 8; k++) { |
| rc_i[k + 8 * f] = 8; |
| } |
| } |
| for (uint8_t f = 0; f < num_tns_filters; f++) { |
| // if (𝑟𝑐𝑜𝑟𝑑𝑒𝑟(𝑓) > 0) |
| if (rc_order[f] > 0) { |
| //𝑟𝑐𝑜𝑟𝑑𝑒𝑟(𝑓) = ac_decode(bytes, &bp, &st, |
| rc_order_ari[f] = |
| ac_decode(bytes, &bp, &st, ac_tns_order_cumfreq[tns_lpc_weighting], |
| ac_tns_order_freq[tns_lpc_weighting], 8, BEC_detect); |
| if (BEC_detect) { |
| // early exit to avoid unpredictable side-effects |
| return; |
| } |
| |
| rc_order_ari[f] = rc_order_ari[f] + 1; |
| // specification (d09r02_F2F) proposes initialization |
| // of rc_i at this place; here implemented above in order |
| // to be performed independet from num_tns_filters |
| for (uint8_t k = 0; k < rc_order_ari[f]; k++) { |
| //𝑟𝑐𝑖(𝑘,𝑓) = ac_decode(bytes, &bp, &st, ac_tns_coef_cumfreq[k], |
| // rc_i[k][f] = ac_decode(bytes, &bp, &st, ac_tns_coef_cumfreq[k], |
| rc_i[k + 8 * f] = ac_decode(bytes, &bp, &st, ac_tns_coef_cumfreq[k], |
| ac_tns_coef_freq[k], 17, BEC_detect); |
| if (BEC_detect) { |
| // early exit to avoid unpredictable side-effects |
| return; |
| } |
| } |
| } |
| } |
| |
| /* Spectral data */ |
| for (uint16_t k = 0; k < lastnz; k += 2) { |
| uint16_t t = c + rateFlag; |
| // if (k > 𝑁𝐸/2) |
| if (k > NE / 2) { |
| t += 256; |
| } |
| //𝑋𝑞̂[k] = 𝑋𝑞̂[k+1] = 0; |
| X_hat_q_ari[k] = X_hat_q_ari[k + 1] = 0; |
| uint8_t lev; |
| uint8_t sym; |
| for (lev = 0; lev < 14; lev++) { |
| uint8_t pki = |
| ac_spec_lookup[t + std::min(lev, static_cast<uint8_t>(3U)) * 1024]; |
| sym = ac_decode(bytes, &bp, &st, ac_spec_cumfreq[pki], ac_spec_freq[pki], |
| 17, BEC_detect); |
| if (BEC_detect) { |
| // early exit to avoid unpredictable side-effects |
| return; |
| } |
| if (sym < 16) { |
| break; |
| } |
| if (lsbMode == 0 || lev > 0) { |
| uint8_t bit = read_bit(bytes, &bp_side, &mask_side); |
| //𝑋𝑞̂[k] += bit << lev; |
| X_hat_q_ari[k] += bit << lev; |
| bit = read_bit(bytes, &bp_side, &mask_side); |
| //𝑋𝑞̂[k+1] += bit << lev; |
| X_hat_q_ari[k + 1] += bit << lev; |
| } |
| } |
| if (lev == 14) { |
| BEC_detect = 1; |
| return; |
| } |
| if (lsbMode == 1) { |
| save_lev[k] = lev; |
| } |
| uint8_t a = sym & 0x3; |
| uint8_t b = sym >> 2; |
| //𝑋𝑞̂[k] += a << lev; |
| //𝑋𝑞̂[k+1] += b << lev; |
| // if (𝑋𝑞̂[k] > 0) |
| X_hat_q_ari[k] += a << lev; |
| X_hat_q_ari[k + 1] += b << lev; |
| if (X_hat_q_ari[k] > 0) { |
| uint8_t bit = read_bit(bytes, &bp_side, &mask_side); |
| if (bit == 1) { |
| //𝑋𝑞̂[k] = -𝑋𝑞̂[k]; |
| X_hat_q_ari[k] = -X_hat_q_ari[k]; |
| } |
| } |
| // if (𝑋𝑞̂[k+1] > 0) |
| if (X_hat_q_ari[k + 1] > 0) { |
| uint8_t bit = read_bit(bytes, &bp_side, &mask_side); |
| if (bit == 1) { |
| //𝑋𝑞̂[k+1] = -𝑋𝑞̂[k+1]; |
| X_hat_q_ari[k + 1] = -X_hat_q_ari[k + 1]; |
| } |
| } |
| lev = std::min(lev, static_cast<uint8_t>(3)); |
| if (lev <= 1) { |
| t = 1 + (a + b) * (lev + 1); |
| } else { |
| t = 12 + lev; |
| } |
| c = (c & 15) * 16 + t; |
| // Note: specification of the following line hase been changed from d09r01 |
| // to d09r02_F2F |
| if (bp - bp_side > 3) { |
| BEC_detect = 1; |
| return; |
| } |
| } |
| // reset remaining fields in array X_hat_q_ari to simplify testing |
| for (int16_t k = lastnz; k < NE; k++) { |
| X_hat_q_ari[k] = 0; |
| } |
| |
| // 3.4.2.6 Residual data and finalization (d09r02_F2F) |
| /* Number of residual bits */ |
| int16_t nbits_side = nbits - (8 * bp_side + 8 - log2(mask_side)); |
| int16_t nbits_ari = (bp - 3) * 8; |
| nbits_ari += 25 - floor(log2(st.range)); |
| int16_t nbits_residual_tmp = nbits - (nbits_side + nbits_ari); |
| if (nbits_residual_tmp < 0) { |
| BEC_detect = 1; |
| return; |
| } |
| nbits_residual = nbits_residual_tmp; |
| } |
| |
| void ArithmeticDec::registerDatapoints(DatapointContainer* datapoints) { |
| if (nullptr != datapoints) { |
| datapoints->addDatapoint("rateFlag", &rateFlag, sizeof(rateFlag)); |
| datapoints->addDatapoint("tns_lpc_weighting", &tns_lpc_weighting, |
| sizeof(tns_lpc_weighting)); |
| datapoints->addDatapoint("rc_order_ari", &rc_order_ari[0], |
| sizeof(rc_order_ari)); |
| datapoints->addDatapoint("rc_i", &rc_i[0], sizeof(rc_i)); |
| datapoints->addDatapoint("X_hat_q_ari", &X_hat_q_ari[0], |
| sizeof(int16_t) * NE); |
| datapoints->addDatapoint("nbits_residual", &nbits_residual, |
| sizeof(nbits_residual)); |
| } |
| } |
| |
| } // namespace Lc3Dec |
