528 lines
16 KiB
C++
528 lines
16 KiB
C++
/*
|
||
* SpectralQuantization.cpp
|
||
*
|
||
* Copyright 2019 HIMSA II K/S - www.himsa.dk. 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 "SpectralQuantization.hpp"
|
||
#include "SpectralDataTables.hpp"
|
||
#include <cmath>
|
||
#include <algorithm>
|
||
|
||
namespace Lc3Enc
|
||
{
|
||
|
||
SpectralQuantization::SpectralQuantization(uint16_t NE_, uint8_t fs_ind_) :
|
||
NE(NE_),
|
||
fs_ind(fs_ind_),
|
||
X_q(nullptr),
|
||
lastnz(0),
|
||
nbits_trunc(0),
|
||
rateFlag(0),
|
||
lsbMode(0),
|
||
gg(0),
|
||
lastnz_trunc(0),
|
||
gg_ind(0),
|
||
datapoints(nullptr),
|
||
gg_off(0),
|
||
gg_min(0),
|
||
nbits_offset(0),
|
||
nbits_spec(0),
|
||
nbits_spec_adj(0),
|
||
nbits_est(0),
|
||
reset_offset_old(false),
|
||
nbits_offset_old(0),
|
||
nbits_spec_old(0),
|
||
nbits_est_old(0)
|
||
|
||
{
|
||
X_q = new int16_t[NE];
|
||
}
|
||
|
||
SpectralQuantization::~SpectralQuantization()
|
||
{
|
||
delete[] X_q;
|
||
}
|
||
|
||
void SpectralQuantization::updateGlobalGainEstimationParameter(uint16_t nbits, uint16_t nbits_spec_local)
|
||
{
|
||
if (reset_offset_old)
|
||
{
|
||
nbits_offset = 0;
|
||
}
|
||
else
|
||
{
|
||
nbits_offset =
|
||
0.8 * nbits_offset_old +
|
||
0.2 * std::min(
|
||
40.f,
|
||
std::max(
|
||
-40.f,
|
||
nbits_offset_old + nbits_spec_old - nbits_est_old
|
||
)
|
||
);
|
||
}
|
||
|
||
nbits_spec_adj = static_cast<uint16_t>( nbits_spec_local + nbits_offset + 0.5);
|
||
|
||
gg_off = - std::min( 115, nbits / (10*(fs_ind+1)) )
|
||
- 105 - 5*(fs_ind+1);
|
||
}
|
||
|
||
void SpectralQuantization::computeSpectralEnergy(double* E, const double* X_f)
|
||
{
|
||
for (uint16_t k=0; k < NE/4; k++)
|
||
{
|
||
E[k] = pow(2, -31);
|
||
for (uint8_t n=0; n<=3; n++)
|
||
{
|
||
E[k] += X_f[4*k + n]*X_f[4*k + n];
|
||
}
|
||
E[k] = 10 * log10( E[k] );
|
||
}
|
||
}
|
||
|
||
void SpectralQuantization::globalGainEstimation(const double* E)
|
||
{
|
||
// converted pseudo-code from page 49/50 (d09r02_F2F)
|
||
int16_t fac = 256;
|
||
//𝑔𝑔𝑖𝑛𝑑 = 255;
|
||
gg_ind = 255;
|
||
for (uint8_t iter = 0; iter < 8; iter++)
|
||
{
|
||
fac >>= 1;
|
||
//𝑔𝑔𝑖𝑛𝑑 -= fac;
|
||
gg_ind -= fac;
|
||
double tmp = 0;
|
||
uint8_t iszero = 1;
|
||
//for (i = 𝑁𝐸/4-1; i >= 0; i--)
|
||
for (int8_t i = NE/4-1; i >= 0; i--)
|
||
{
|
||
//if (E[i]*28/20 < (𝑔𝑔𝑖𝑛𝑑+𝑔𝑔𝑜𝑓𝑓))
|
||
if (E[i]*28/20.0 < (gg_ind+gg_off))
|
||
{
|
||
if (iszero == 0)
|
||
{
|
||
tmp += 2.7*28/20.0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//if ((𝑔𝑔𝑖𝑛𝑑+𝑔𝑔𝑜𝑓𝑓) < E[i]*28/20 - 43*28/20)
|
||
if ((gg_ind+gg_off) < E[i]*28/20.0 - 43*28/20.0)
|
||
{
|
||
//tmp += 2*E[i]*28/20 – 2*(𝑔𝑔𝑖𝑛𝑑+𝑔𝑔𝑜𝑓𝑓) - 36*28/20;
|
||
tmp += 2*E[i]*28/20.0 - 2*(gg_ind+gg_off) - 36*28/20.0;
|
||
}
|
||
else
|
||
{
|
||
//tmp += E[i]*28/20 – (𝑔𝑔𝑖𝑛𝑑+𝑔𝑔𝑜𝑓𝑓) + 7*28/20;
|
||
tmp += E[i]*28/20.0 - (gg_ind+gg_off) + 7*28/20.0;
|
||
}
|
||
iszero = 0;
|
||
}
|
||
}
|
||
//if (tmp > 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐′ *1.4*28/20 && iszero == 0)
|
||
if ( (tmp > nbits_spec_adj*1.4*28/20.0) && (iszero == 0) )
|
||
{
|
||
//𝑔𝑔𝑖𝑛𝑑 += fac;
|
||
gg_ind += fac;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool SpectralQuantization::globalGainLimitation(const double* const X_f)
|
||
{
|
||
// -> not precisely clear where this limitation should occur
|
||
// -> Is the following converted pseudo code meant?
|
||
// -> Are the chosen datatypes appropriate?
|
||
double X_f_max = 0;
|
||
for (uint16_t n=0; n < NE; n++)
|
||
{
|
||
X_f_max = std::max(X_f_max, fabs(X_f[n]));
|
||
}
|
||
if (X_f_max > 0)
|
||
{
|
||
gg_min = ceil(28*log10(X_f_max/(32768-0.375))) - gg_off;
|
||
}
|
||
else
|
||
{
|
||
gg_min = 0;
|
||
}
|
||
bool reset_offset = false;
|
||
//if (𝑔𝑔𝑖𝑛𝑑 < 𝑔𝑔𝑚𝑖𝑛 || 𝑋𝑓𝑚𝑎𝑥 == 0)
|
||
if ((gg_ind < gg_min) || X_f_max == 0)
|
||
{
|
||
//𝑔𝑔𝑖𝑛𝑑 = 𝑔𝑔𝑚𝑖𝑛;
|
||
//𝑟𝑒𝑠𝑒𝑡𝑜𝑓𝑓𝑠𝑒𝑡 = 1;
|
||
gg_ind = gg_min;
|
||
reset_offset = true;
|
||
}
|
||
else
|
||
{
|
||
//𝑟𝑒𝑠𝑒𝑡𝑜𝑓𝑓𝑠𝑒𝑡 = 0;
|
||
reset_offset = false;
|
||
}
|
||
return reset_offset;
|
||
}
|
||
|
||
void SpectralQuantization::quantizeSpectrum(const double* const X_f)
|
||
{
|
||
gg = pow(10.f, (gg_ind+gg_off)/28.0f );
|
||
for (uint16_t n=0; n < NE; n++)
|
||
{
|
||
if (X_f[n] >= 0)
|
||
{
|
||
X_q[n] = X_f[n]/gg + 0.375;
|
||
}
|
||
else
|
||
{
|
||
X_q[n] = X_f[n]/gg - 0.375;
|
||
}
|
||
}
|
||
}
|
||
|
||
void SpectralQuantization::computeBitConsumption(
|
||
uint16_t nbits,
|
||
uint8_t& modeFlag)
|
||
{
|
||
//if (nbits > (160 + 𝑓𝑠𝑖𝑛𝑑 * 160))
|
||
if (nbits > (160 + fs_ind * 160))
|
||
{
|
||
rateFlag = 512;
|
||
}
|
||
else
|
||
{
|
||
rateFlag = 0;
|
||
}
|
||
//if (nbits >= (480 + 𝑓𝑠𝑖𝑛𝑑 * 160))
|
||
if (nbits >= (480 + fs_ind * 160))
|
||
{
|
||
modeFlag = 1;
|
||
}
|
||
else
|
||
{
|
||
modeFlag = 0;
|
||
}
|
||
|
||
//lastnz = 𝑁𝐸;
|
||
lastnz = NE;
|
||
//while (lastnz>2 && 𝑋𝑞[lastnz-1] == 0 && 𝑋𝑞[lastnz-2] == 0)
|
||
while ( (lastnz>2) && (X_q[lastnz-1] == 0) && (X_q[lastnz-2] == 0) )
|
||
{
|
||
lastnz -= 2;
|
||
}
|
||
|
||
//𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 = 0;
|
||
//𝑛𝑏𝑖𝑡𝑠𝑡𝑟𝑢𝑛𝑐 = 0;
|
||
//𝑛𝑏𝑖𝑡𝑠𝑙𝑠𝑏 = 0;
|
||
uint32_t nbits_est_local = 0;
|
||
uint32_t nbits_trunc_local = 0;
|
||
nbits_lsb = 0;
|
||
lastnz_trunc = 2;
|
||
uint16_t c = 0;
|
||
for (uint16_t n = 0; n < lastnz; n=n+2)
|
||
{
|
||
uint16_t t = c + rateFlag;
|
||
//if (n > 𝑁𝐸/2)
|
||
if (n > NE/2)
|
||
{
|
||
t += 256;
|
||
}
|
||
//a = abs(𝑋𝑞[n]);
|
||
uint16_t a = abs(X_q[n]);
|
||
uint16_t a_lsb = a;
|
||
//b = abs(𝑋𝑞[n+1]);
|
||
uint16_t b = abs(X_q[n+1]);
|
||
uint16_t b_lsb = b;
|
||
uint16_t lev = 0;
|
||
//while (max(a,b) >= 4)
|
||
uint8_t pki;
|
||
while (std::max(a,b) >= 4)
|
||
{
|
||
pki = ac_spec_lookup[t+lev*1024];
|
||
//𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 += ac_spec_bits[pki][16];
|
||
nbits_est_local += ac_spec_bits[pki][16];
|
||
if ( (lev == 0) && (modeFlag == 1) )
|
||
{
|
||
//𝑛𝑏𝑖𝑡𝑠𝑙𝑠𝑏 += 2;
|
||
nbits_lsb += 2;
|
||
}
|
||
else
|
||
{
|
||
//𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 += 2*2048;
|
||
nbits_est_local += 2*2048;
|
||
}
|
||
a >>= 1;
|
||
b >>= 1;
|
||
lev = std::min(lev+1,3);
|
||
}
|
||
pki = ac_spec_lookup[t+lev*1024];
|
||
uint16_t sym = a + 4*b;
|
||
//𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 += ac_spec_bits[pki][sym];
|
||
nbits_est_local += ac_spec_bits[pki][sym];
|
||
//a_lsb = abs(𝑋𝑞[n]); -> implemented earlier
|
||
//b_lsb = abs(𝑋𝑞[n+1]); -> implemented earlier
|
||
//𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 += (min(a_lsb,1) + min(b_lsb,1)) * 2048;
|
||
//nbits_est_local += (std::min(a_lsb,static_cast<uint16_t>(1))
|
||
// + std::min(b_lsb,static_cast<uint16_t>(1))) * 2048;
|
||
// alternative implementation (more clear, more performant?)
|
||
if (a_lsb > 0) nbits_est_local += 2048;
|
||
if (b_lsb > 0) nbits_est_local += 2048;
|
||
if ( (lev > 0) && (modeFlag == 1) )
|
||
{
|
||
a_lsb >>= 1;
|
||
b_lsb >>= 1;
|
||
//if (a_lsb == 0 && 𝑋𝑞[n] != 0)
|
||
if (a_lsb == 0 && X_q[n] != 0)
|
||
{
|
||
//𝑛𝑏𝑖𝑡𝑠𝑙𝑠𝑏++;
|
||
nbits_lsb++;
|
||
}
|
||
//if (b_lsb == 0 && 𝑋𝑞[n+1] != 0)
|
||
if (b_lsb == 0 && X_q[n+1] != 0)
|
||
{
|
||
//𝑛𝑏𝑖𝑡𝑠𝑙𝑠𝑏++;
|
||
nbits_lsb++;
|
||
}
|
||
}
|
||
|
||
//if ((𝑋𝑞[n] != 0 || 𝑋𝑞[n+1] != 0) && (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 <= 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐*2048))
|
||
//if (((X_q[n] != 0) || (X_q[n+1] != 0)) && (nbits_est_local <= nbits_spec*2048))
|
||
if (((X_q[n] != 0) || (X_q[n+1] != 0)) && (ceil(nbits_est_local/2048.0) <= nbits_spec))
|
||
{
|
||
lastnz_trunc = n + 2;
|
||
//𝑛𝑏𝑖𝑡𝑠𝑡𝑟𝑢𝑛𝑐 = 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡;
|
||
nbits_trunc_local = nbits_est_local;
|
||
}
|
||
if (lev <= 1)
|
||
{
|
||
t = 1 + (a+b)*(lev+1);
|
||
}
|
||
else
|
||
{
|
||
t = 12 + lev;
|
||
}
|
||
c = (c&15)*16 + t;
|
||
}
|
||
//𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 = ceil(𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡/2048) + 𝑛𝑏𝑖𝑡𝑠𝑙𝑠𝑏;
|
||
nbits_est = ceil(nbits_est_local/2048.0) + nbits_lsb;
|
||
//𝑛𝑏𝑖𝑡𝑠𝑡𝑟𝑢𝑛𝑐 = ceil(𝑛𝑏𝑖𝑡𝑠𝑡𝑟𝑢𝑛𝑐/2048);
|
||
nbits_trunc = ceil(nbits_trunc_local/2048.0);
|
||
}
|
||
|
||
bool SpectralQuantization::globalGainAdjustment()
|
||
{
|
||
uint16_t t1[5] = {80, 230, 380, 530, 680};
|
||
uint16_t t2[5] = {500, 1025, 1550, 2075, 2600};
|
||
uint16_t t3[5] = {850, 1700, 2550, 3400, 4250};
|
||
|
||
double delta;
|
||
double delta2;
|
||
//if (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 < t1[𝑓𝑠𝑖𝑛𝑑])
|
||
if (nbits_est < t1[fs_ind])
|
||
{
|
||
//delta = (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡+48)/16;
|
||
delta = (nbits_est+48)/static_cast<double>(16);
|
||
}
|
||
//else if (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 < t2[𝑓𝑠𝑖𝑛𝑑])
|
||
else if (nbits_est < t2[fs_ind])
|
||
{
|
||
//tmp1 = t1[𝑓𝑠𝑖𝑛𝑑]/16+3;
|
||
//tmp2 = t2[𝑓𝑠𝑖𝑛𝑑]/48;
|
||
//delta = (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡-t1[𝑓𝑠𝑖𝑛𝑑])*(tmp2-tmp1)/(t2[𝑓𝑠𝑖𝑛𝑑]-t1[𝑓𝑠𝑖𝑛𝑑]) + tmp1;
|
||
double tmp1 = t1[fs_ind]/static_cast<double>(16) +3;
|
||
double tmp2 = t2[fs_ind]/static_cast<double>(48);
|
||
delta = (nbits_est-t1[fs_ind])*(tmp2-tmp1)/(t2[fs_ind]-t1[fs_ind]) + tmp1;
|
||
}
|
||
//else if (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 < t3[𝑓𝑠𝑖𝑛𝑑])
|
||
else if (nbits_est < t3[fs_ind])
|
||
{
|
||
//delta = 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡/48;
|
||
delta = nbits_est/static_cast<double>(48);
|
||
}
|
||
else
|
||
{
|
||
//delta = t3[𝑓𝑠𝑖𝑛𝑑]/48;
|
||
delta = t3[fs_ind]/static_cast<double>(48);
|
||
}
|
||
//delta = nint(delta); // this looks like we need floating point
|
||
// nint(.) is the rounding-to-nearest-integer function.
|
||
delta = static_cast<int16_t>(delta+0.5); // this looks like we need floating point
|
||
delta2 = delta + 2;
|
||
|
||
uint16_t gg_ind_origin = gg_ind;
|
||
|
||
/*
|
||
if ((𝑔𝑔𝑖𝑛𝑑 < 255 && 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 > 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐) ||
|
||
(𝑔𝑔𝑖𝑛𝑑 > 0 && 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 < 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐 – delta2))
|
||
{
|
||
if (𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 < 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐 – delta2)
|
||
{
|
||
𝑔𝑔𝑖𝑛𝑑 -= 1;
|
||
}
|
||
else if (𝑔𝑔𝑖𝑛𝑑 == 254 || 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 < 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐 + delta)
|
||
{
|
||
𝑔𝑔𝑖𝑛𝑑 += 1;
|
||
}
|
||
else
|
||
{
|
||
𝑔𝑔𝑖𝑛𝑑 += 2;
|
||
}
|
||
𝑔𝑔𝑖𝑛𝑑 = max(𝑔𝑔𝑖𝑛𝑑, 𝑔𝑔𝑚𝑖𝑛);
|
||
}
|
||
*/
|
||
if (( (gg_ind < 255) && (nbits_est > nbits_spec)) ||
|
||
( (gg_ind > 0) && (nbits_est < nbits_spec - delta2)))
|
||
{
|
||
if (nbits_est < nbits_spec - delta2)
|
||
{
|
||
gg_ind -= 1;
|
||
}
|
||
else if ( (gg_ind == 254) || (nbits_est < nbits_spec + delta) )
|
||
{
|
||
gg_ind += 1;
|
||
}
|
||
else
|
||
{
|
||
gg_ind += 2;
|
||
}
|
||
gg_ind = std::max(gg_ind, gg_min);
|
||
}
|
||
|
||
return (gg_ind_origin != gg_ind);
|
||
}
|
||
|
||
void SpectralQuantization::run(const double* const X_f, uint16_t nbits, uint16_t nbits_spec_local)
|
||
{
|
||
nbits_spec = nbits_spec_local;
|
||
|
||
//3.3.10.2 First global gain estimation (d09r02_F2F)
|
||
updateGlobalGainEstimationParameter(nbits, nbits_spec_local);
|
||
|
||
double E[NE/4];
|
||
computeSpectralEnergy(E, X_f);
|
||
globalGainEstimation(E);
|
||
// Finally, the quantized gain index is limited such that
|
||
// the quantized spectrum stays within the range [-32768,32767]
|
||
bool reset_offset = globalGainLimitation(X_f);
|
||
|
||
// 3.3.10.3 Quantization (d09r02_F2F)
|
||
quantizeSpectrum(X_f);
|
||
|
||
// 3.3.10.4 Bit consumption (d09r02_F2F)
|
||
uint8_t modeFlag;
|
||
computeBitConsumption(
|
||
nbits,
|
||
modeFlag);
|
||
|
||
if (nullptr!=datapoints)
|
||
{
|
||
datapoints->log("gg_ind", &gg_ind, sizeof(gg_ind));
|
||
datapoints->log("gg", &gg, sizeof(gg) );
|
||
datapoints->log("X_q", X_q, sizeof(int16_t)*NE);
|
||
datapoints->log("lastnz", &lastnz, sizeof(lastnz));
|
||
datapoints->log("lastnz_trunc", &lastnz_trunc, sizeof(lastnz_trunc));
|
||
datapoints->log("nbits_est", &nbits_est, sizeof(nbits_est) );
|
||
datapoints->log("nbits_trunc", &nbits_trunc, sizeof(nbits_trunc) );
|
||
}
|
||
|
||
// 3.3.10.5 Truncation (d09r02_F2F)
|
||
for (uint16_t k = lastnz_trunc; k < lastnz; k++)
|
||
{
|
||
//𝑋𝑞[k] = 0;
|
||
X_q[k] = 0;
|
||
}
|
||
|
||
//if (modeFlag == 1 && 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 > 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐)
|
||
if ( (modeFlag == 1) && (nbits_est > nbits_spec) )
|
||
{
|
||
lsbMode = 1;
|
||
}
|
||
else
|
||
{
|
||
lsbMode = 0;
|
||
}
|
||
|
||
if (nullptr!=datapoints)
|
||
{
|
||
datapoints->log("lsbMode", &lsbMode, sizeof(lsbMode) );
|
||
}
|
||
|
||
|
||
// Note: states needs to be transferred prior
|
||
// to spectrum re-quantization!
|
||
nbits_spec_old = nbits_spec;
|
||
nbits_est_old = nbits_est;
|
||
reset_offset_old = reset_offset;
|
||
nbits_offset_old = nbits_offset;
|
||
|
||
|
||
// 3.3.10.6 Global gain adjustment (d09r02_F2F)
|
||
bool isAdjusted = globalGainAdjustment();
|
||
if (isAdjusted)
|
||
{
|
||
quantizeSpectrum(X_f);
|
||
computeBitConsumption(
|
||
nbits,
|
||
modeFlag);
|
||
|
||
// 3.3.10.5 Truncation (d09r02_F2F)
|
||
for (uint16_t k = lastnz_trunc; k < lastnz; k++)
|
||
{
|
||
//𝑋𝑞[k] = 0;
|
||
X_q[k] = 0;
|
||
}
|
||
|
||
//if (modeFlag == 1 && 𝑛𝑏𝑖𝑡𝑠𝑒𝑠𝑡 > 𝑛𝑏𝑖𝑡𝑠𝑠𝑝𝑒𝑐)
|
||
if (modeFlag == 1 && nbits_est > nbits_spec)
|
||
{
|
||
lsbMode = 1;
|
||
}
|
||
else
|
||
{
|
||
lsbMode = 0;
|
||
}
|
||
|
||
}
|
||
if (nullptr!=datapoints)
|
||
{
|
||
datapoints->log("isAdjusted", &isAdjusted, sizeof(isAdjusted));
|
||
datapoints->log("gg_ind_adj", &gg_ind, sizeof(gg_ind));
|
||
datapoints->log("gg_adj", &gg, sizeof(gg) );
|
||
datapoints->log("X_q_req", X_q, sizeof(int16_t)*NE);
|
||
datapoints->log("lastnz_req", &lastnz_trunc, sizeof(lastnz_trunc));
|
||
datapoints->log("nbits_est_req", &nbits_est, sizeof(nbits_est) );
|
||
datapoints->log("nbits_trunc_req", &nbits_trunc, sizeof(nbits_trunc) );
|
||
datapoints->log("lsbMode_req", &lsbMode, sizeof(lsbMode) );
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
void SpectralQuantization::registerDatapoints(DatapointContainer* datapoints_)
|
||
{
|
||
datapoints = datapoints_;
|
||
if (nullptr != datapoints)
|
||
{
|
||
datapoints->addDatapoint( "gg_off", &gg_off, sizeof(gg_off) );
|
||
datapoints->addDatapoint( "gg_min", &gg_min, sizeof(gg_min) );
|
||
datapoints->addDatapoint( "nbits_offset", &nbits_offset, sizeof(nbits_offset) );
|
||
}
|
||
}
|
||
|
||
}//namespace Lc3Enc
|