AnotherFoxGuy/webrtc-audio-processing
1
0
Fork 0
Code Pull Requests Activity
webrtc-audio-processing/webrtc/modules/audio_coding/codecs/isac/main/source/encode.c
Guillaume Desmottes 34efc689c2 add webrtc-audio-coding public library 
This new lib contains the bare minimum to implement an iSAC encoder and
decoder.

The webrtc files have been copied from the revision as the existing
imported files (c8b569e0a7ad0b369e15f0197b3a558699ec8efa).
2020-03-27 14:52:22 +01:00

1259 lines
47 KiB
C
Raw Blame History

/*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
/*
* encode.c
*
* This file contains definition of funtions for encoding.
* Decoding of upper-band, including 8-12 kHz, when the bandwidth is
* 0-12 kHz, and 8-16 kHz, when the bandwidth is 0-16 kHz.
*
*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "structs.h"
#include "codec.h"
#include "pitch_estimator.h"
#include "entropy_coding.h"
#include "arith_routines.h"
#include "pitch_gain_tables.h"
#include "pitch_lag_tables.h"
#include "spectrum_ar_model_tables.h"
#include "lpc_tables.h"
#include "lpc_analysis.h"
#include "bandwidth_estimator.h"
#include "lpc_shape_swb12_tables.h"
#include "lpc_shape_swb16_tables.h"
#include "lpc_gain_swb_tables.h"
#define UB_LOOKAHEAD 24
/*
Rate allocation tables of lower and upper-band bottleneck for
12kHz & 16kHz bandwidth.
12 kHz bandwidth
-----------------
The overall bottleneck of the coder is between 38 kbps and 45 kbps. We have
considered 7 enteries, uniformly distributed in this interval, i.e. 38,
39.17, 40.33, 41.5, 42.67, 43.83 and 45. For every entery, the lower-band
and the upper-band bottlenecks are specified in
'kLowerBandBitRate12' and 'kUpperBandBitRate12'
tables, respectively. E.g. the overall rate of 41.5 kbps corresponts to a
bottleneck of 31 kbps for lower-band and 27 kbps for upper-band. Given an
overall bottleneck of the codec, we use linear interpolation to get
lower-band and upper-band bottlenecks.
16 kHz bandwidth
-----------------
The overall bottleneck of the coder is between 50 kbps and 56 kbps. We have
considered 7 enteries, uniformly distributed in this interval, i.e. 50, 51.2,
52.4, 53.6, 54.8 and 56. For every entery, the lower-band and the upper-band
bottlenecks are specified in 'kLowerBandBitRate16' and
'kUpperBandBitRate16' tables, respectively. E.g. the overall rate
of 53.6 kbps corresponts to a bottleneck of 32 kbps for lower-band and 30
kbps for upper-band. Given an overall bottleneck of the codec, we use linear
interpolation to get lower-band and upper-band bottlenecks.
*/
/* 38 39.17 40.33 41.5 42.67 43.83 45 */
static const int16_t kLowerBandBitRate12[7] = {
29000, 30000, 30000, 31000, 31000, 32000, 32000 };
static const int16_t kUpperBandBitRate12[7] = {
25000, 25000, 27000, 27000, 29000, 29000, 32000 };
/* 50 51.2 52.4 53.6 54.8 56 */
static const int16_t kLowerBandBitRate16[6] = {
31000, 31000, 32000, 32000, 32000, 32000 };
static const int16_t kUpperBandBitRate16[6] = {
28000, 29000, 29000, 30000, 31000, 32000 };
/******************************************************************************
* WebRtcIsac_RateAllocation()
* Internal function to perform a rate-allocation for upper and lower-band,
* given a total rate.
*
* Input:
* - inRateBitPerSec : a total bottleneck in bits/sec.
*
* Output:
* - rateLBBitPerSec : a bottleneck allocated to the lower-band
* in bits/sec.
* - rateUBBitPerSec : a bottleneck allocated to the upper-band
* in bits/sec.
*
* Return value : 0 if rate allocation has been successful.
* -1 if failed to allocate rates.
*/
int16_t WebRtcIsac_RateAllocation(int32_t inRateBitPerSec,
double* rateLBBitPerSec,
double* rateUBBitPerSec,
enum ISACBandwidth* bandwidthKHz) {
int16_t idx;
double idxD;
double idxErr;
if (inRateBitPerSec < 38000) {
/* If the given overall bottleneck is less than 38000 then
* then codec has to operate in wideband mode, i.e. 8 kHz
* bandwidth. */
*rateLBBitPerSec = (int16_t)((inRateBitPerSec > 32000) ?
32000 : inRateBitPerSec);
*rateUBBitPerSec = 0;
*bandwidthKHz = isac8kHz;
} else if ((inRateBitPerSec >= 38000) && (inRateBitPerSec < 50000)) {
/* At a bottleneck between 38 and 50 kbps the codec is operating
* at 12 kHz bandwidth. Using xxxBandBitRate12[] to calculates
* upper/lower bottleneck */
/* Find the bottlenecks by linear interpolation,
* step is (45000 - 38000)/6.0 we use the inverse of it. */
const double stepSizeInv = 8.5714286e-4;
idxD = (inRateBitPerSec - 38000) * stepSizeInv;
idx = (idxD >= 6) ? 6 : ((int16_t)idxD);
idxErr = idxD - idx;
*rateLBBitPerSec = kLowerBandBitRate12[idx];
*rateUBBitPerSec = kUpperBandBitRate12[idx];
if (idx < 6) {
*rateLBBitPerSec += (int16_t)(
idxErr * (kLowerBandBitRate12[idx + 1] - kLowerBandBitRate12[idx]));
*rateUBBitPerSec += (int16_t)(
idxErr * (kUpperBandBitRate12[idx + 1] - kUpperBandBitRate12[idx]));
}
*bandwidthKHz = isac12kHz;
} else if ((inRateBitPerSec >= 50000) && (inRateBitPerSec <= 56000)) {
/* A bottleneck between 50 and 56 kbps corresponds to bandwidth
* of 16 kHz. Using xxxBandBitRate16[] to calculates
* upper/lower bottleneck. */
/* Find the bottlenecks by linear interpolation
* step is (56000 - 50000)/5 we use the inverse of it. */
const double stepSizeInv = 8.3333333e-4;
idxD = (inRateBitPerSec - 50000) * stepSizeInv;
idx = (idxD >= 5) ? 5 : ((int16_t)idxD);
idxErr = idxD - idx;
*rateLBBitPerSec = kLowerBandBitRate16[idx];
*rateUBBitPerSec = kUpperBandBitRate16[idx];
if (idx < 5) {
*rateLBBitPerSec += (int16_t)(idxErr *
(kLowerBandBitRate16[idx + 1] -
kLowerBandBitRate16[idx]));
*rateUBBitPerSec += (int16_t)(idxErr *
(kUpperBandBitRate16[idx + 1] -
kUpperBandBitRate16[idx]));
}
*bandwidthKHz = isac16kHz;
} else {
/* Out-of-range botlteneck value. */
return -1;
}
/* limit the values. */
*rateLBBitPerSec = (*rateLBBitPerSec > 32000) ? 32000 : *rateLBBitPerSec;
*rateUBBitPerSec = (*rateUBBitPerSec > 32000) ? 32000 : *rateUBBitPerSec;
return 0;
}
void WebRtcIsac_ResetBitstream(Bitstr* bit_stream) {
bit_stream->W_upper = 0xFFFFFFFF;
bit_stream->stream_index = 0;
bit_stream->streamval = 0;
}
int WebRtcIsac_EncodeLb(const TransformTables* transform_tables,
float* in, ISACLBEncStruct* ISACencLB_obj,
int16_t codingMode,
int16_t bottleneckIndex) {
int stream_length = 0;
int err;
int k;
int iterCntr;
double lofilt_coef[(ORDERLO + 1)*SUBFRAMES];
double hifilt_coef[(ORDERHI + 1)*SUBFRAMES];
float LP[FRAMESAMPLES_HALF];
float HP[FRAMESAMPLES_HALF];
double LP_lookahead[FRAMESAMPLES_HALF];
double HP_lookahead[FRAMESAMPLES_HALF];
double LP_lookahead_pf[FRAMESAMPLES_HALF + QLOOKAHEAD];
double LPw[FRAMESAMPLES_HALF];
double HPw[FRAMESAMPLES_HALF];
double LPw_pf[FRAMESAMPLES_HALF];
int16_t fre[FRAMESAMPLES_HALF]; /* Q7 */
int16_t fim[FRAMESAMPLES_HALF]; /* Q7 */
double PitchLags[4];
double PitchGains[4];
int16_t PitchGains_Q12[4];
int16_t AvgPitchGain_Q12;
int frame_mode; /* 0 for 30ms, 1 for 60ms */
int status = 0;
int my_index;
transcode_obj transcodingParam;
double bytesLeftSpecCoding;
uint16_t payloadLimitBytes;
/* Copy new frame-length and bottleneck rate only for the first 10 ms data */
if (ISACencLB_obj->buffer_index == 0) {
/* Set the framelength for the next packet. */
ISACencLB_obj->current_framesamples = ISACencLB_obj->new_framelength;
}
/* 'frame_mode' is 0 (30 ms) or 1 (60 ms). */
frame_mode = ISACencLB_obj->current_framesamples / MAX_FRAMESAMPLES;
/* buffer speech samples (by 10ms packet) until the frame-length */
/* is reached (30 or 60 ms). */
/*****************************************************************/
/* fill the buffer with 10ms input data */
for (k = 0; k < FRAMESAMPLES_10ms; k++) {
ISACencLB_obj->data_buffer_float[k + ISACencLB_obj->buffer_index] = in[k];
}
/* If buffersize is not equal to current framesize then increase index
* and return. We do no encoding untill we have enough audio. */
if (ISACencLB_obj->buffer_index + FRAMESAMPLES_10ms != FRAMESAMPLES) {
ISACencLB_obj->buffer_index += FRAMESAMPLES_10ms;
return 0;
}
/* If buffer reached the right size, reset index and continue with
* encoding the frame. */
ISACencLB_obj->buffer_index = 0;
/* End of buffer function. */
/**************************/
/* Encoding */
/************/
if (frame_mode == 0 || ISACencLB_obj->frame_nb == 0) {
/* This is to avoid Linux warnings until we change 'int' to 'Word32'
* at all places. */
int intVar;
/* reset bitstream */
WebRtcIsac_ResetBitstream(&(ISACencLB_obj->bitstr_obj));
if ((codingMode == 0) && (frame_mode == 0) &&
(ISACencLB_obj->enforceFrameSize == 0)) {
ISACencLB_obj->new_framelength = WebRtcIsac_GetNewFrameLength(
ISACencLB_obj->bottleneck, ISACencLB_obj->current_framesamples);
}
ISACencLB_obj->s2nr = WebRtcIsac_GetSnr(
ISACencLB_obj->bottleneck, ISACencLB_obj->current_framesamples);
/* Encode frame length. */
status = WebRtcIsac_EncodeFrameLen(
ISACencLB_obj->current_framesamples, &ISACencLB_obj->bitstr_obj);
if (status < 0) {
/* Wrong frame size. */
return status;
}
/* Save framelength for multiple packets memory. */
ISACencLB_obj->SaveEnc_obj.framelength =
ISACencLB_obj->current_framesamples;
/* To be used for Redundant Coding. */
ISACencLB_obj->lastBWIdx = bottleneckIndex;
intVar = (int)bottleneckIndex;
WebRtcIsac_EncodeReceiveBw(&intVar, &ISACencLB_obj->bitstr_obj);
}
/* Split signal in two bands. */
WebRtcIsac_SplitAndFilterFloat(ISACencLB_obj->data_buffer_float, LP, HP,
LP_lookahead, HP_lookahead,
&ISACencLB_obj->prefiltbankstr_obj);
/* estimate pitch parameters and pitch-filter lookahead signal */
WebRtcIsac_PitchAnalysis(LP_lookahead, LP_lookahead_pf,
&ISACencLB_obj->pitchanalysisstr_obj, PitchLags,
PitchGains);
/* Encode in FIX Q12. */
/* Convert PitchGain to Fixed point. */
for (k = 0; k < PITCH_SUBFRAMES; k++) {
PitchGains_Q12[k] = (int16_t)(PitchGains[k] * 4096.0);
}
/* Set where to store data in multiple packets memory. */
if (frame_mode == 0 || ISACencLB_obj->frame_nb == 0) {
ISACencLB_obj->SaveEnc_obj.startIdx = 0;
} else {
ISACencLB_obj->SaveEnc_obj.startIdx = 1;
}
/* Quantize & encode pitch parameters. */
WebRtcIsac_EncodePitchGain(PitchGains_Q12, &ISACencLB_obj->bitstr_obj,
&ISACencLB_obj->SaveEnc_obj);
WebRtcIsac_EncodePitchLag(PitchLags, PitchGains_Q12,
&ISACencLB_obj->bitstr_obj,
&ISACencLB_obj->SaveEnc_obj);
AvgPitchGain_Q12 = (PitchGains_Q12[0] + PitchGains_Q12[1] +
PitchGains_Q12[2] + PitchGains_Q12[3]) >> 2;
/* Find coefficients for perceptual pre-filters. */
WebRtcIsac_GetLpcCoefLb(LP_lookahead_pf, HP_lookahead,
&ISACencLB_obj->maskfiltstr_obj, ISACencLB_obj->s2nr,
PitchGains_Q12, lofilt_coef, hifilt_coef);
/* Code LPC model and shape - gains not quantized yet. */
WebRtcIsac_EncodeLpcLb(lofilt_coef, hifilt_coef, &ISACencLB_obj->bitstr_obj,
&ISACencLB_obj->SaveEnc_obj);
/* Convert PitchGains back to FLOAT for pitchfilter_pre. */
for (k = 0; k < 4; k++) {
PitchGains[k] = ((float)PitchGains_Q12[k]) / 4096;
}
/* Store the state of arithmetic coder before coding LPC gains. */
transcodingParam.W_upper = ISACencLB_obj->bitstr_obj.W_upper;
transcodingParam.stream_index = ISACencLB_obj->bitstr_obj.stream_index;
transcodingParam.streamval = ISACencLB_obj->bitstr_obj.streamval;
transcodingParam.stream[0] =
ISACencLB_obj->bitstr_obj.stream[ISACencLB_obj->bitstr_obj.stream_index -
2];
transcodingParam.stream[1] =
ISACencLB_obj->bitstr_obj.stream[ISACencLB_obj->bitstr_obj.stream_index -
1];
transcodingParam.stream[2] =
ISACencLB_obj->bitstr_obj.stream[ISACencLB_obj->bitstr_obj.stream_index];
/* Store LPC Gains before encoding them. */
for (k = 0; k < SUBFRAMES; k++) {
transcodingParam.loFiltGain[k] = lofilt_coef[(LPC_LOBAND_ORDER + 1) * k];
transcodingParam.hiFiltGain[k] = hifilt_coef[(LPC_HIBAND_ORDER + 1) * k];
}
/* Code gains */
WebRtcIsac_EncodeLpcGainLb(lofilt_coef, hifilt_coef,
&ISACencLB_obj->bitstr_obj,
&ISACencLB_obj->SaveEnc_obj);
/* Get the correct value for the payload limit and calculate the
* number of bytes left for coding the spectrum. */
if ((frame_mode == 1) && (ISACencLB_obj->frame_nb == 0)) {
/* It is a 60ms and we are in the first 30ms then the limit at
* this point should be half of the assigned value. */
payloadLimitBytes = ISACencLB_obj->payloadLimitBytes60 >> 1;
} else if (frame_mode == 0) {
/* It is a 30ms frame */
/* Subract 3 because termination process may add 3 bytes. */
payloadLimitBytes = ISACencLB_obj->payloadLimitBytes30 - 3;
} else {
/* This is the second half of a 60ms frame. */
/* Subract 3 because termination process may add 3 bytes. */
payloadLimitBytes = ISACencLB_obj->payloadLimitBytes60 - 3;
}
bytesLeftSpecCoding = payloadLimitBytes - transcodingParam.stream_index;
/* Perceptual pre-filtering (using normalized lattice filter). */
/* Low-band filtering. */
WebRtcIsac_NormLatticeFilterMa(ORDERLO,
ISACencLB_obj->maskfiltstr_obj.PreStateLoF,
ISACencLB_obj->maskfiltstr_obj.PreStateLoG,
LP, lofilt_coef, LPw);
/* High-band filtering. */
WebRtcIsac_NormLatticeFilterMa(ORDERHI,
ISACencLB_obj->maskfiltstr_obj.PreStateHiF,
ISACencLB_obj->maskfiltstr_obj.PreStateHiG,
HP, hifilt_coef, HPw);
/* Pitch filter. */
WebRtcIsac_PitchfilterPre(LPw, LPw_pf, &ISACencLB_obj->pitchfiltstr_obj,
PitchLags, PitchGains);
/* Transform */
WebRtcIsac_Time2Spec(transform_tables,
LPw_pf, HPw, fre, fim, &ISACencLB_obj->fftstr_obj);
/* Save data for multiple packets memory. */
my_index = ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF;
memcpy(&ISACencLB_obj->SaveEnc_obj.fre[my_index], fre, sizeof(fre));
memcpy(&ISACencLB_obj->SaveEnc_obj.fim[my_index], fim, sizeof(fim));
ISACencLB_obj->SaveEnc_obj.AvgPitchGain[ISACencLB_obj->SaveEnc_obj.startIdx] =
AvgPitchGain_Q12;
/* Quantization and loss-less coding. */
err = WebRtcIsac_EncodeSpec(fre, fim, AvgPitchGain_Q12, kIsacLowerBand,
&ISACencLB_obj->bitstr_obj);
if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
/* There has been an error but it was not too large payload
(we can cure too large payload). */
if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
/* If this is the second 30ms of a 60ms frame reset
this such that in the next call encoder starts fresh. */
ISACencLB_obj->frame_nb = 0;
}
return err;
}
iterCntr = 0;
while ((ISACencLB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
(err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
double bytesSpecCoderUsed;
double transcodeScale;
if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
/* We were not able to limit the payload size */
if ((frame_mode == 1) && (ISACencLB_obj->frame_nb == 0)) {
/* This was the first 30ms of a 60ms frame. Although
the payload is larger than it should be but we let
the second 30ms be encoded. Maybe together we
won't exceed the limit. */
ISACencLB_obj->frame_nb = 1;
return 0;
} else if ((frame_mode == 1) && (ISACencLB_obj->frame_nb == 1)) {
ISACencLB_obj->frame_nb = 0;
}
if (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
} else {
return status;
}
}
if (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
bytesSpecCoderUsed = STREAM_SIZE_MAX;
/* Being conservative */
transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
} else {
bytesSpecCoderUsed = ISACencLB_obj->bitstr_obj.stream_index -
transcodingParam.stream_index;
transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
}
/* To be safe, we reduce the scale depending on
the number of iterations. */
transcodeScale *= (1.0 - (0.9 * (double)iterCntr /
(double)MAX_PAYLOAD_LIMIT_ITERATION));
/* Scale the LPC Gains. */
for (k = 0; k < SUBFRAMES; k++) {
lofilt_coef[(LPC_LOBAND_ORDER + 1) * k] =
transcodingParam.loFiltGain[k] * transcodeScale;
hifilt_coef[(LPC_HIBAND_ORDER + 1) * k] =
transcodingParam.hiFiltGain[k] * transcodeScale;
transcodingParam.loFiltGain[k] = lofilt_coef[(LPC_LOBAND_ORDER + 1) * k];
transcodingParam.hiFiltGain[k] = hifilt_coef[(LPC_HIBAND_ORDER + 1) * k];
}
/* Scale DFT coefficients. */
for (k = 0; k < FRAMESAMPLES_HALF; k++) {
fre[k] = (int16_t)(fre[k] * transcodeScale);
fim[k] = (int16_t)(fim[k] * transcodeScale);
}
/* Save data for multiple packets memory. */
my_index = ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF;
memcpy(&ISACencLB_obj->SaveEnc_obj.fre[my_index], fre, sizeof(fre));
memcpy(&ISACencLB_obj->SaveEnc_obj.fim[my_index], fim, sizeof(fim));
/* Re-store the state of arithmetic coder before coding LPC gains. */
ISACencLB_obj->bitstr_obj.W_upper = transcodingParam.W_upper;
ISACencLB_obj->bitstr_obj.stream_index = transcodingParam.stream_index;
ISACencLB_obj->bitstr_obj.streamval = transcodingParam.streamval;
ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index - 2] =
transcodingParam.stream[0];
ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index - 1] =
transcodingParam.stream[1];
ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index] =
transcodingParam.stream[2];
/* Code gains. */
WebRtcIsac_EncodeLpcGainLb(lofilt_coef, hifilt_coef,
&ISACencLB_obj->bitstr_obj,
&ISACencLB_obj->SaveEnc_obj);
/* Update the number of bytes left for encoding the spectrum. */
bytesLeftSpecCoding = payloadLimitBytes - transcodingParam.stream_index;
/* Encode the spectrum. */
err = WebRtcIsac_EncodeSpec(fre, fim, AvgPitchGain_Q12, kIsacLowerBand,
&ISACencLB_obj->bitstr_obj);
if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
/* There has been an error but it was not too large
payload (we can cure too large payload). */
if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
/* If this is the second 30 ms of a 60 ms frame reset
this such that in the next call encoder starts fresh. */
ISACencLB_obj->frame_nb = 0;
}
return err;
}
iterCntr++;
}
/* If 60 ms frame-size and just processed the first 30 ms, */
/* go back to main function to buffer the other 30 ms speech frame. */
if (frame_mode == 1) {
if (ISACencLB_obj->frame_nb == 0) {
ISACencLB_obj->frame_nb = 1;
return 0;
} else if (ISACencLB_obj->frame_nb == 1) {
ISACencLB_obj->frame_nb = 0;
/* Also update the frame-length for next packet,
in Adaptive mode only. */
if (codingMode == 0 && (ISACencLB_obj->enforceFrameSize == 0)) {
ISACencLB_obj->new_framelength =
WebRtcIsac_GetNewFrameLength(ISACencLB_obj->bottleneck,
ISACencLB_obj->current_framesamples);
}
}
} else {
ISACencLB_obj->frame_nb = 0;
}
/* Complete arithmetic coding. */
stream_length = WebRtcIsac_EncTerminate(&ISACencLB_obj->bitstr_obj);
return stream_length;
}
static int LimitPayloadUb(ISACUBEncStruct* ISACencUB_obj,
uint16_t payloadLimitBytes,
double bytesLeftSpecCoding,
transcode_obj* transcodingParam,
int16_t* fre, int16_t* fim,
double* lpcGains, enum ISACBand band, int status) {
int iterCntr = 0;
int k;
double bytesSpecCoderUsed;
double transcodeScale;
const int16_t kAveragePitchGain = 0.0;
do {
if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
/* We were not able to limit the payload size. */
return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
}
if (status == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
bytesSpecCoderUsed = STREAM_SIZE_MAX;
/* Being conservative. */
transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
} else {
bytesSpecCoderUsed = ISACencUB_obj->bitstr_obj.stream_index -
transcodingParam->stream_index;
transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
}
/* To be safe, we reduce the scale depending on the
number of iterations. */
transcodeScale *= (1.0 - (0.9 * (double)iterCntr /
(double)MAX_PAYLOAD_LIMIT_ITERATION));
/* Scale the LPC Gains. */
if (band == kIsacUpperBand16) {
/* Two sets of coefficients if 16 kHz. */
for (k = 0; k < SUBFRAMES; k++) {
transcodingParam->loFiltGain[k] *= transcodeScale;
transcodingParam->hiFiltGain[k] *= transcodeScale;
}
} else {
/* One sets of coefficients if 12 kHz. */
for (k = 0; k < SUBFRAMES; k++) {
transcodingParam->loFiltGain[k] *= transcodeScale;
}
}
/* Scale DFT coefficients. */
for (k = 0; k < FRAMESAMPLES_HALF; k++) {
fre[k] = (int16_t)(fre[k] * transcodeScale + 0.5);
fim[k] = (int16_t)(fim[k] * transcodeScale + 0.5);
}
/* Store FFT coefficients for multiple encoding. */
memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre,
sizeof(ISACencUB_obj->SaveEnc_obj.realFFT));
memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
sizeof(ISACencUB_obj->SaveEnc_obj.imagFFT));
/* Store the state of arithmetic coder before coding LPC gains */
ISACencUB_obj->bitstr_obj.W_upper = transcodingParam->W_upper;
ISACencUB_obj->bitstr_obj.stream_index = transcodingParam->stream_index;
ISACencUB_obj->bitstr_obj.streamval = transcodingParam->streamval;
ISACencUB_obj->bitstr_obj.stream[transcodingParam->stream_index - 2] =
transcodingParam->stream[0];
ISACencUB_obj->bitstr_obj.stream[transcodingParam->stream_index - 1] =
transcodingParam->stream[1];
ISACencUB_obj->bitstr_obj.stream[transcodingParam->stream_index] =
transcodingParam->stream[2];
/* Store the gains for multiple encoding. */
memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains,
SUBFRAMES * sizeof(double));
/* Entropy Code lpc-gains, indices are stored for a later use.*/
WebRtcIsac_EncodeLpcGainUb(transcodingParam->loFiltGain,
&ISACencUB_obj->bitstr_obj,
ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
/* If 16kHz should do one more set. */
if (band == kIsacUpperBand16) {
/* Store the gains for multiple encoding. */
memcpy(&ISACencUB_obj->SaveEnc_obj.lpcGain[SUBFRAMES],
&lpcGains[SUBFRAMES], SUBFRAMES * sizeof(double));
/* Entropy Code lpc-gains, indices are stored for a later use.*/
WebRtcIsac_EncodeLpcGainUb(
transcodingParam->hiFiltGain, &ISACencUB_obj->bitstr_obj,
&ISACencUB_obj->SaveEnc_obj.lpcGainIndex[SUBFRAMES]);
}
/* Update the number of bytes left for encoding the spectrum. */
bytesLeftSpecCoding = payloadLimitBytes -
ISACencUB_obj->bitstr_obj.stream_index;
/* Save the bit-stream object at this point for FEC. */
memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
&ISACencUB_obj->bitstr_obj, sizeof(Bitstr));
/* Encode the spectrum. */
status = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain,
band, &ISACencUB_obj->bitstr_obj);
if ((status < 0) && (status != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
/* There has been an error but it was not too large payload
(we can cure too large payload). */
return status;
}
iterCntr++;
} while ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
(status == -ISAC_DISALLOWED_BITSTREAM_LENGTH));
return 0;
}
int WebRtcIsac_EncodeUb16(const TransformTables* transform_tables,
float* in, ISACUBEncStruct* ISACencUB_obj,
int32_t jitterInfo) {
int err;
int k;
double lpcVecs[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
double percepFilterParams[(1 + UB_LPC_ORDER) * (SUBFRAMES << 1) +
(1 + UB_LPC_ORDER)];
double LP_lookahead[FRAMESAMPLES];
int16_t fre[FRAMESAMPLES_HALF]; /* Q7 */
int16_t fim[FRAMESAMPLES_HALF]; /* Q7 */
int status = 0;
double varscale[2];
double corr[SUBFRAMES << 1][UB_LPC_ORDER + 1];
double lpcGains[SUBFRAMES << 1];
transcode_obj transcodingParam;
uint16_t payloadLimitBytes;
double s2nr;
const int16_t kAveragePitchGain = 0.0;
int bytesLeftSpecCoding;
/* Buffer speech samples (by 10ms packet) until the frame-length is */
/* reached (30 ms). */
/*********************************************************************/
/* fill the buffer with 10ms input data */
memcpy(&ISACencUB_obj->data_buffer_float[ISACencUB_obj->buffer_index], in,
FRAMESAMPLES_10ms * sizeof(float));
/* If buffer size is not equal to current frame-size, and end of file is
* not reached yet, we don't do encoding unless we have the whole frame. */
if (ISACencUB_obj->buffer_index + FRAMESAMPLES_10ms < FRAMESAMPLES) {
ISACencUB_obj->buffer_index += FRAMESAMPLES_10ms;
return 0;
}
/* End of buffer function. */
/**************************/
/* Encoding */
/************/
/* Reset bit-stream */
WebRtcIsac_ResetBitstream(&(ISACencUB_obj->bitstr_obj));
/* Encoding of bandwidth information. */
WebRtcIsac_EncodeJitterInfo(jitterInfo, &ISACencUB_obj->bitstr_obj);
status = WebRtcIsac_EncodeBandwidth(isac16kHz, &ISACencUB_obj->bitstr_obj);
if (status < 0) {
return status;
}
s2nr = WebRtcIsac_GetSnr(ISACencUB_obj->bottleneck, FRAMESAMPLES);
memcpy(lpcVecs, ISACencUB_obj->lastLPCVec, UB_LPC_ORDER * sizeof(double));
for (k = 0; k < FRAMESAMPLES; k++) {
LP_lookahead[k] = ISACencUB_obj->data_buffer_float[UB_LOOKAHEAD + k];
}
/* Find coefficients for perceptual pre-filters. */
WebRtcIsac_GetLpcCoefUb(LP_lookahead, &ISACencUB_obj->maskfiltstr_obj,
&lpcVecs[UB_LPC_ORDER], corr, varscale, isac16kHz);
memcpy(ISACencUB_obj->lastLPCVec,
&lpcVecs[(UB16_LPC_VEC_PER_FRAME - 1) * (UB_LPC_ORDER)],
sizeof(double) * UB_LPC_ORDER);
/* Code LPC model and shape - gains not quantized yet. */
WebRtcIsac_EncodeLpcUB(lpcVecs, &ISACencUB_obj->bitstr_obj,
percepFilterParams, isac16kHz,
&ISACencUB_obj->SaveEnc_obj);
/* the first set of lpc parameters are from the last sub-frame of
* the previous frame. so we don't care about them. */
WebRtcIsac_GetLpcGain(s2nr, &percepFilterParams[UB_LPC_ORDER + 1],
(SUBFRAMES << 1), lpcGains, corr, varscale);
/* Store the state of arithmetic coder before coding LPC gains */
transcodingParam.stream_index = ISACencUB_obj->bitstr_obj.stream_index;
transcodingParam.W_upper = ISACencUB_obj->bitstr_obj.W_upper;
transcodingParam.streamval = ISACencUB_obj->bitstr_obj.streamval;
transcodingParam.stream[0] =
ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
2];
transcodingParam.stream[1] =
ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
1];
transcodingParam.stream[2] =
ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index];
/* Store LPC Gains before encoding them. */
for (k = 0; k < SUBFRAMES; k++) {
transcodingParam.loFiltGain[k] = lpcGains[k];
transcodingParam.hiFiltGain[k] = lpcGains[SUBFRAMES + k];
}
/* Store the gains for multiple encoding. */
memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains,
(SUBFRAMES << 1) * sizeof(double));
WebRtcIsac_EncodeLpcGainUb(lpcGains, &ISACencUB_obj->bitstr_obj,
ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
WebRtcIsac_EncodeLpcGainUb(
&lpcGains[SUBFRAMES], &ISACencUB_obj->bitstr_obj,
&ISACencUB_obj->SaveEnc_obj.lpcGainIndex[SUBFRAMES]);
/* Get the correct value for the payload limit and calculate the number of
bytes left for coding the spectrum. It is a 30ms frame
Subract 3 because termination process may add 3 bytes */
payloadLimitBytes = ISACencUB_obj->maxPayloadSizeBytes -
ISACencUB_obj->numBytesUsed - 3;
bytesLeftSpecCoding = payloadLimitBytes -
ISACencUB_obj->bitstr_obj.stream_index;
for (k = 0; k < (SUBFRAMES << 1); k++) {
percepFilterParams[k * (UB_LPC_ORDER + 1) + (UB_LPC_ORDER + 1)] =
lpcGains[k];
}
/* LPC filtering (using normalized lattice filter), */
/* first half-frame. */
WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
ISACencUB_obj->maskfiltstr_obj.PreStateLoG,
&ISACencUB_obj->data_buffer_float[0],
&percepFilterParams[UB_LPC_ORDER + 1],
&LP_lookahead[0]);
/* Second half-frame filtering. */
WebRtcIsac_NormLatticeFilterMa(
UB_LPC_ORDER, ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
ISACencUB_obj->maskfiltstr_obj.PreStateLoG,
&ISACencUB_obj->data_buffer_float[FRAMESAMPLES_HALF],
&percepFilterParams[(UB_LPC_ORDER + 1) + SUBFRAMES * (UB_LPC_ORDER + 1)],
&LP_lookahead[FRAMESAMPLES_HALF]);
WebRtcIsac_Time2Spec(transform_tables,
&LP_lookahead[0], &LP_lookahead[FRAMESAMPLES_HALF],
fre, fim, &ISACencUB_obj->fftstr_obj);
/* Store FFT coefficients for multiple encoding. */
memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre, sizeof(fre));
memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim, sizeof(fim));
/* Prepare the audio buffer for the next packet
* move the last 3 ms to the beginning of the buffer. */
memcpy(ISACencUB_obj->data_buffer_float,
&ISACencUB_obj->data_buffer_float[FRAMESAMPLES],
LB_TOTAL_DELAY_SAMPLES * sizeof(float));
/* start writing with 3 ms delay to compensate for the delay
* of the lower-band. */
ISACencUB_obj->buffer_index = LB_TOTAL_DELAY_SAMPLES;
/* Save the bit-stream object at this point for FEC. */
memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj, &ISACencUB_obj->bitstr_obj,
sizeof(Bitstr));
/* Qantization and lossless coding */
/* Note that there is no pitch-gain for this band so kAveragePitchGain = 0
* is passed to the function. In fact, the function ignores the 3rd parameter
* for this band. */
err = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain, kIsacUpperBand16,
&ISACencUB_obj->bitstr_obj);
if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
return err;
}
if ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
(err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
err = LimitPayloadUb(ISACencUB_obj, payloadLimitBytes, bytesLeftSpecCoding,
&transcodingParam, fre, fim, lpcGains,
kIsacUpperBand16, err);
}
if (err < 0) {
return err;
}
/* Complete arithmetic coding. */
return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
}
int WebRtcIsac_EncodeUb12(const TransformTables* transform_tables,
float* in, ISACUBEncStruct* ISACencUB_obj,
int32_t jitterInfo) {
int err;
int k;
double lpcVecs[UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME];
double percepFilterParams[(1 + UB_LPC_ORDER) * SUBFRAMES];
float LP[FRAMESAMPLES_HALF];
float HP[FRAMESAMPLES_HALF];
double LP_lookahead[FRAMESAMPLES_HALF];
double HP_lookahead[FRAMESAMPLES_HALF];
double LPw[FRAMESAMPLES_HALF];
double HPw[FRAMESAMPLES_HALF];
int16_t fre[FRAMESAMPLES_HALF]; /* Q7 */
int16_t fim[FRAMESAMPLES_HALF]; /* Q7 */
int status = 0;
double varscale[1];
double corr[UB_LPC_GAIN_DIM][UB_LPC_ORDER + 1];
double lpcGains[SUBFRAMES];
transcode_obj transcodingParam;
uint16_t payloadLimitBytes;
double s2nr;
const int16_t kAveragePitchGain = 0.0;
double bytesLeftSpecCoding;
/* Buffer speech samples (by 10ms packet) until the framelength is */
/* reached (30 ms). */
/********************************************************************/
/* Fill the buffer with 10ms input data. */
memcpy(&ISACencUB_obj->data_buffer_float[ISACencUB_obj->buffer_index], in,
FRAMESAMPLES_10ms * sizeof(float));
/* if buffer-size is not equal to current frame-size then increase the
index and return. We do the encoding when we have enough audio. */
if (ISACencUB_obj->buffer_index + FRAMESAMPLES_10ms < FRAMESAMPLES) {
ISACencUB_obj->buffer_index += FRAMESAMPLES_10ms;
return 0;
}
/* If buffer reached the right size, reset index and continue
with encoding the frame */
ISACencUB_obj->buffer_index = 0;
/* End of buffer function */
/**************************/
/* Encoding */
/************/
/* Reset bit-stream. */
WebRtcIsac_ResetBitstream(&(ISACencUB_obj->bitstr_obj));
/* Encoding bandwidth information. */
WebRtcIsac_EncodeJitterInfo(jitterInfo, &ISACencUB_obj->bitstr_obj);
status = WebRtcIsac_EncodeBandwidth(isac12kHz, &ISACencUB_obj->bitstr_obj);
if (status < 0) {
return status;
}
s2nr = WebRtcIsac_GetSnr(ISACencUB_obj->bottleneck, FRAMESAMPLES);
/* Split signal in two bands. */
WebRtcIsac_SplitAndFilterFloat(ISACencUB_obj->data_buffer_float, HP, LP,
HP_lookahead, LP_lookahead,
&ISACencUB_obj->prefiltbankstr_obj);
/* Find coefficients for perceptual pre-filters. */
WebRtcIsac_GetLpcCoefUb(LP_lookahead, &ISACencUB_obj->maskfiltstr_obj,
lpcVecs, corr, varscale, isac12kHz);
/* Code LPC model and shape - gains not quantized yet. */
WebRtcIsac_EncodeLpcUB(lpcVecs, &ISACencUB_obj->bitstr_obj,
percepFilterParams, isac12kHz,
&ISACencUB_obj->SaveEnc_obj);
WebRtcIsac_GetLpcGain(s2nr, percepFilterParams, SUBFRAMES, lpcGains, corr,
varscale);
/* Store the state of arithmetic coder before coding LPC gains. */
transcodingParam.W_upper = ISACencUB_obj->bitstr_obj.W_upper;
transcodingParam.stream_index = ISACencUB_obj->bitstr_obj.stream_index;
transcodingParam.streamval = ISACencUB_obj->bitstr_obj.streamval;
transcodingParam.stream[0] =
ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
2];
transcodingParam.stream[1] =
ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
1];
transcodingParam.stream[2] =
ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index];
/* Store LPC Gains before encoding them. */
for (k = 0; k < SUBFRAMES; k++) {
transcodingParam.loFiltGain[k] = lpcGains[k];
}
/* Store the gains for multiple encoding. */
memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains, SUBFRAMES *
sizeof(double));
WebRtcIsac_EncodeLpcGainUb(lpcGains, &ISACencUB_obj->bitstr_obj,
ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
for (k = 0; k < SUBFRAMES; k++) {
percepFilterParams[k * (UB_LPC_ORDER + 1)] = lpcGains[k];
}
/* perceptual pre-filtering (using normalized lattice filter) */
/* low-band filtering */
WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
ISACencUB_obj->maskfiltstr_obj.PreStateLoG, LP,
percepFilterParams, LPw);
/* Get the correct value for the payload limit and calculate the number
of bytes left for coding the spectrum. It is a 30ms frame Subract 3
because termination process may add 3 bytes */
payloadLimitBytes = ISACencUB_obj->maxPayloadSizeBytes -
ISACencUB_obj->numBytesUsed - 3;
bytesLeftSpecCoding = payloadLimitBytes -
ISACencUB_obj->bitstr_obj.stream_index;
memset(HPw, 0, sizeof(HPw));
/* Transform */
WebRtcIsac_Time2Spec(transform_tables,
LPw, HPw, fre, fim, &ISACencUB_obj->fftstr_obj);
/* Store FFT coefficients for multiple encoding. */
memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre,
sizeof(ISACencUB_obj->SaveEnc_obj.realFFT));
memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
sizeof(ISACencUB_obj->SaveEnc_obj.imagFFT));
/* Save the bit-stream object at this point for FEC. */
memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
&ISACencUB_obj->bitstr_obj, sizeof(Bitstr));
/* Quantization and loss-less coding */
/* The 4th parameter to this function is pitch-gain, which is only used
* when encoding 0-8 kHz band, and irrelevant in this function, therefore,
* we insert zero here. */
err = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain, kIsacUpperBand12,
&ISACencUB_obj->bitstr_obj);
if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
/* There has been an error but it was not too large
payload (we can cure too large payload) */
return err;
}
if ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
(err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
err = LimitPayloadUb(ISACencUB_obj, payloadLimitBytes, bytesLeftSpecCoding,
&transcodingParam, fre, fim, lpcGains,
kIsacUpperBand12, err);
}
if (err < 0) {
return err;
}
/* Complete arithmetic coding. */
return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
}
/* This function is used to create a new bit-stream with new BWE.
The same data as previously encoded with the function WebRtcIsac_Encoder().
The data needed is taken from the structure, where it was stored
when calling the encoder. */
int WebRtcIsac_EncodeStoredDataLb(const IsacSaveEncoderData* ISACSavedEnc_obj,
Bitstr* ISACBitStr_obj, int BWnumber,
float scale) {
int ii;
int status;
int BWno = BWnumber;
const uint16_t* WebRtcIsac_kQPitchGainCdf_ptr[1];
const uint16_t** cdf;
double tmpLPCcoeffs_lo[(ORDERLO + 1)*SUBFRAMES * 2];
double tmpLPCcoeffs_hi[(ORDERHI + 1)*SUBFRAMES * 2];
int tmpLPCindex_g[12 * 2];
int16_t tmp_fre[FRAMESAMPLES], tmp_fim[FRAMESAMPLES];
const int kModel = 0;
/* Sanity Check - possible values for BWnumber is 0 - 23. */
if ((BWnumber < 0) || (BWnumber > 23)) {
return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
}
/* Reset bit-stream. */
WebRtcIsac_ResetBitstream(ISACBitStr_obj);
/* Encode frame length */
status = WebRtcIsac_EncodeFrameLen(ISACSavedEnc_obj->framelength,
ISACBitStr_obj);
if (status < 0) {
/* Wrong frame size. */
return status;
}
/* Transcoding */
if ((scale > 0.0) && (scale < 1.0)) {
/* Compensate LPC gain. */
for (ii = 0;
ii < ((ORDERLO + 1)* SUBFRAMES * (1 + ISACSavedEnc_obj->startIdx));
ii++) {
tmpLPCcoeffs_lo[ii] = scale * ISACSavedEnc_obj->LPCcoeffs_lo[ii];
}
for (ii = 0;
ii < ((ORDERHI + 1) * SUBFRAMES * (1 + ISACSavedEnc_obj->startIdx));
ii++) {
tmpLPCcoeffs_hi[ii] = scale * ISACSavedEnc_obj->LPCcoeffs_hi[ii];
}
/* Scale DFT. */
for (ii = 0;
ii < (FRAMESAMPLES_HALF * (1 + ISACSavedEnc_obj->startIdx));
ii++) {
tmp_fre[ii] = (int16_t)((scale) * (float)ISACSavedEnc_obj->fre[ii]);
tmp_fim[ii] = (int16_t)((scale) * (float)ISACSavedEnc_obj->fim[ii]);
}
} else {
for (ii = 0;
ii < (KLT_ORDER_GAIN * (1 + ISACSavedEnc_obj->startIdx));
ii++) {
tmpLPCindex_g[ii] = ISACSavedEnc_obj->LPCindex_g[ii];
}
for (ii = 0;
ii < (FRAMESAMPLES_HALF * (1 + ISACSavedEnc_obj->startIdx));
ii++) {
tmp_fre[ii] = ISACSavedEnc_obj->fre[ii];
tmp_fim[ii] = ISACSavedEnc_obj->fim[ii];
}
}
/* Encode bandwidth estimate. */
WebRtcIsac_EncodeReceiveBw(&BWno, ISACBitStr_obj);
/* Loop over number of 30 msec */
for (ii = 0; ii <= ISACSavedEnc_obj->startIdx; ii++) {
/* Encode pitch gains. */
*WebRtcIsac_kQPitchGainCdf_ptr = WebRtcIsac_kQPitchGainCdf;
WebRtcIsac_EncHistMulti(ISACBitStr_obj,
&ISACSavedEnc_obj->pitchGain_index[ii],
WebRtcIsac_kQPitchGainCdf_ptr, 1);
/* Entropy coding of quantization pitch lags */
/* Voicing classification. */
if (ISACSavedEnc_obj->meanGain[ii] < 0.2) {
cdf = WebRtcIsac_kQPitchLagCdfPtrLo;
} else if (ISACSavedEnc_obj->meanGain[ii] < 0.4) {
cdf = WebRtcIsac_kQPitchLagCdfPtrMid;
} else {
cdf = WebRtcIsac_kQPitchLagCdfPtrHi;
}
WebRtcIsac_EncHistMulti(ISACBitStr_obj,
&ISACSavedEnc_obj->pitchIndex[PITCH_SUBFRAMES * ii],
cdf, PITCH_SUBFRAMES);
/* LPC */
/* Only one model exists. The entropy coding is done only for backward
* compatibility. */
WebRtcIsac_EncHistMulti(ISACBitStr_obj, &kModel,
WebRtcIsac_kQKltModelCdfPtr, 1);
/* Entropy coding of quantization indices - LPC shape only. */
WebRtcIsac_EncHistMulti(ISACBitStr_obj,
&ISACSavedEnc_obj->LPCindex_s[KLT_ORDER_SHAPE * ii],
WebRtcIsac_kQKltCdfPtrShape,
KLT_ORDER_SHAPE);
/* If transcoding, get new LPC gain indices */
if (scale < 1.0) {
WebRtcIsac_TranscodeLPCCoef(
&tmpLPCcoeffs_lo[(ORDERLO + 1) * SUBFRAMES * ii],
&tmpLPCcoeffs_hi[(ORDERHI + 1)*SUBFRAMES * ii],
&tmpLPCindex_g[KLT_ORDER_GAIN * ii]);
}
/* Entropy coding of quantization indices - LPC gain. */
WebRtcIsac_EncHistMulti(ISACBitStr_obj, &tmpLPCindex_g[KLT_ORDER_GAIN * ii],
WebRtcIsac_kQKltCdfPtrGain, KLT_ORDER_GAIN);
/* Quantization and loss-less coding. */
status = WebRtcIsac_EncodeSpec(&tmp_fre[ii * FRAMESAMPLES_HALF],
&tmp_fim[ii * FRAMESAMPLES_HALF],
ISACSavedEnc_obj->AvgPitchGain[ii],
kIsacLowerBand, ISACBitStr_obj);
if (status < 0) {
return status;
}
}
/* Complete arithmetic coding. */
return WebRtcIsac_EncTerminate(ISACBitStr_obj);
}
int WebRtcIsac_EncodeStoredDataUb(
const ISACUBSaveEncDataStruct* ISACSavedEnc_obj,
Bitstr* bitStream,
int32_t jitterInfo,
float scale,
enum ISACBandwidth bandwidth) {
int n;
int err;
double lpcGain[SUBFRAMES];
int16_t realFFT[FRAMESAMPLES_HALF];
int16_t imagFFT[FRAMESAMPLES_HALF];
const uint16_t** shape_cdf;
int shape_len;
const int16_t kAveragePitchGain = 0.0;
enum ISACBand band;
/* Reset bitstream. */
WebRtcIsac_ResetBitstream(bitStream);
/* Encode jitter index. */
WebRtcIsac_EncodeJitterInfo(jitterInfo, bitStream);
err = WebRtcIsac_EncodeBandwidth(bandwidth, bitStream);
if (err < 0) {
return err;
}
/* Encode LPC-shape. */
if (bandwidth == isac12kHz) {
shape_cdf = WebRtcIsac_kLpcShapeCdfMatUb12;
shape_len = UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME;
band = kIsacUpperBand12;
} else {
shape_cdf = WebRtcIsac_kLpcShapeCdfMatUb16;
shape_len = UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME;
band = kIsacUpperBand16;
}
WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->indexLPCShape,
shape_cdf, shape_len);
if ((scale <= 0.0) || (scale >= 1.0)) {
/* We only consider scales between zero and one. */
WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->lpcGainIndex,
WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
if (bandwidth == isac16kHz) {
/* Store gain indices of the second half. */
WebRtcIsac_EncHistMulti(bitStream,
&ISACSavedEnc_obj->lpcGainIndex[SUBFRAMES],
WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
}
/* Store FFT coefficients. */
err = WebRtcIsac_EncodeSpec(ISACSavedEnc_obj->realFFT,
ISACSavedEnc_obj->imagFFT, kAveragePitchGain,
band, bitStream);
} else {
/* Scale LPC gain and FFT coefficients. */
for (n = 0; n < SUBFRAMES; n++) {
lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n];
}
/* Store LPC gains. */
WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
if (bandwidth == isac16kHz) {
/* Scale and code the gains of the second half of the frame, if 16kHz. */
for (n = 0; n < SUBFRAMES; n++) {
lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n + SUBFRAMES];
}
WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
}
for (n = 0; n < FRAMESAMPLES_HALF; n++) {
realFFT[n] = (int16_t)(scale * (float)ISACSavedEnc_obj->realFFT[n] +
0.5f);
imagFFT[n] = (int16_t)(scale * (float)ISACSavedEnc_obj->imagFFT[n] +
0.5f);
}
/* Store FFT coefficients. */
err = WebRtcIsac_EncodeSpec(realFFT, imagFFT, kAveragePitchGain,
band, bitStream);
}
if (err < 0) {
/* Error happened while encoding FFT coefficients. */
return err;
}
/* Complete arithmetic coding. */
return WebRtcIsac_EncTerminate(bitStream);
}
int16_t WebRtcIsac_GetRedPayloadUb(
const ISACUBSaveEncDataStruct* ISACSavedEncObj,
Bitstr* bitStreamObj,
enum ISACBandwidth bandwidth) {
int n;
int16_t status;
int16_t realFFT[FRAMESAMPLES_HALF];
int16_t imagFFT[FRAMESAMPLES_HALF];
enum ISACBand band;
const int16_t kAveragePitchGain = 0.0;
/* Store bit-stream object. */
memcpy(bitStreamObj, &ISACSavedEncObj->bitStreamObj, sizeof(Bitstr));
/* Scale FFT coefficients. */
for (n = 0; n < FRAMESAMPLES_HALF; n++) {
realFFT[n] = (int16_t)((float)ISACSavedEncObj->realFFT[n] *
RCU_TRANSCODING_SCALE_UB + 0.5);
imagFFT[n] = (int16_t)((float)ISACSavedEncObj->imagFFT[n] *
RCU_TRANSCODING_SCALE_UB + 0.5);
}
band = (bandwidth == isac12kHz) ? kIsacUpperBand12 : kIsacUpperBand16;
status = WebRtcIsac_EncodeSpec(realFFT, imagFFT, kAveragePitchGain, band,
bitStreamObj);
if (status < 0) {
return status;
} else {
/* Terminate entropy coding */
return WebRtcIsac_EncTerminate(bitStreamObj);
}
}
View Git Blame Copy Permalink