1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 /*
12 * encode.c
13 *
14 * This file contains definition of funtions for encoding.
15 * Decoding of upper-band, including 8-12 kHz, when the bandwidth is
16 * 0-12 kHz, and 8-16 kHz, when the bandwidth is 0-16 kHz.
17 *
18 */
19
20 #include <stdlib.h>
21 #include <string.h>
22 #include <stdio.h>
23
24 #include "structs.h"
25 #include "codec.h"
26 #include "pitch_estimator.h"
27 #include "entropy_coding.h"
28 #include "arith_routines.h"
29 #include "pitch_gain_tables.h"
30 #include "pitch_lag_tables.h"
31 #include "spectrum_ar_model_tables.h"
32 #include "lpc_tables.h"
33 #include "lpc_analysis.h"
34 #include "bandwidth_estimator.h"
35 #include "lpc_shape_swb12_tables.h"
36 #include "lpc_shape_swb16_tables.h"
37 #include "lpc_gain_swb_tables.h"
38
39
40 #define UB_LOOKAHEAD 24
41
42
43 /*
44 Rate allocation tables of lower and upper-band bottleneck for
45 12kHz & 16kHz bandwidth.
46
47 12 kHz bandwidth
48 -----------------
49 The overall bottleneck of the coder is between 38 kbps and 45 kbps. We have
50 considered 7 enteries, uniformly distributed in this interval, i.e. 38,
51 39.17, 40.33, 41.5, 42.67, 43.83 and 45. For every entery, the lower-band
52 and the upper-band bottlenecks are specified in
53 'kLowerBandBitRate12' and 'kUpperBandBitRate12'
54 tables, respectively. E.g. the overall rate of 41.5 kbps corresponts to a
55 bottleneck of 31 kbps for lower-band and 27 kbps for upper-band. Given an
56 overall bottleneck of the codec, we use linear interpolation to get
57 lower-band and upper-band bottlenecks.
58
59 16 kHz bandwidth
60 -----------------
61 The overall bottleneck of the coder is between 50 kbps and 56 kbps. We have
62 considered 7 enteries, uniformly distributed in this interval, i.e. 50, 51.2,
63 52.4, 53.6, 54.8 and 56. For every entery, the lower-band and the upper-band
64 bottlenecks are specified in 'kLowerBandBitRate16' and
65 'kUpperBandBitRate16' tables, respectively. E.g. the overall rate
66 of 53.6 kbps corresponts to a bottleneck of 32 kbps for lower-band and 30
67 kbps for upper-band. Given an overall bottleneck of the codec, we use linear
68 interpolation to get lower-band and upper-band bottlenecks.
69
70 */
71
72 /* 38 39.17 40.33 41.5 42.67 43.83 45 */
73 static const int16_t kLowerBandBitRate12[7] = {
74 29000, 30000, 30000, 31000, 31000, 32000, 32000 };
75 static const int16_t kUpperBandBitRate12[7] = {
76 25000, 25000, 27000, 27000, 29000, 29000, 32000 };
77
78 /* 50 51.2 52.4 53.6 54.8 56 */
79 static const int16_t kLowerBandBitRate16[6] = {
80 31000, 31000, 32000, 32000, 32000, 32000 };
81 static const int16_t kUpperBandBitRate16[6] = {
82 28000, 29000, 29000, 30000, 31000, 32000 };
83
84 /******************************************************************************
85 * WebRtcIsac_RateAllocation()
86 * Internal function to perform a rate-allocation for upper and lower-band,
87 * given a total rate.
88 *
89 * Input:
90 * - inRateBitPerSec : a total bottleneck in bits/sec.
91 *
92 * Output:
93 * - rateLBBitPerSec : a bottleneck allocated to the lower-band
94 * in bits/sec.
95 * - rateUBBitPerSec : a bottleneck allocated to the upper-band
96 * in bits/sec.
97 *
98 * Return value : 0 if rate allocation has been successful.
99 * -1 if failed to allocate rates.
100 */
101
WebRtcIsac_RateAllocation(int32_t inRateBitPerSec,double * rateLBBitPerSec,double * rateUBBitPerSec,enum ISACBandwidth * bandwidthKHz)102 int16_t WebRtcIsac_RateAllocation(int32_t inRateBitPerSec,
103 double* rateLBBitPerSec,
104 double* rateUBBitPerSec,
105 enum ISACBandwidth* bandwidthKHz) {
106 int16_t idx;
107 double idxD;
108 double idxErr;
109 if (inRateBitPerSec < 38000) {
110 /* If the given overall bottleneck is less than 38000 then
111 * then codec has to operate in wideband mode, i.e. 8 kHz
112 * bandwidth. */
113 *rateLBBitPerSec = (int16_t)((inRateBitPerSec > 32000) ?
114 32000 : inRateBitPerSec);
115 *rateUBBitPerSec = 0;
116 *bandwidthKHz = isac8kHz;
117 } else if ((inRateBitPerSec >= 38000) && (inRateBitPerSec < 50000)) {
118 /* At a bottleneck between 38 and 50 kbps the codec is operating
119 * at 12 kHz bandwidth. Using xxxBandBitRate12[] to calculates
120 * upper/lower bottleneck */
121
122 /* Find the bottlenecks by linear interpolation,
123 * step is (45000 - 38000)/6.0 we use the inverse of it. */
124 const double stepSizeInv = 8.5714286e-4;
125 idxD = (inRateBitPerSec - 38000) * stepSizeInv;
126 idx = (idxD >= 6) ? 6 : ((int16_t)idxD);
127 idxErr = idxD - idx;
128 *rateLBBitPerSec = kLowerBandBitRate12[idx];
129 *rateUBBitPerSec = kUpperBandBitRate12[idx];
130
131 if (idx < 6) {
132 *rateLBBitPerSec += (int16_t)(
133 idxErr * (kLowerBandBitRate12[idx + 1] - kLowerBandBitRate12[idx]));
134 *rateUBBitPerSec += (int16_t)(
135 idxErr * (kUpperBandBitRate12[idx + 1] - kUpperBandBitRate12[idx]));
136 }
137 *bandwidthKHz = isac12kHz;
138 } else if ((inRateBitPerSec >= 50000) && (inRateBitPerSec <= 56000)) {
139 /* A bottleneck between 50 and 56 kbps corresponds to bandwidth
140 * of 16 kHz. Using xxxBandBitRate16[] to calculates
141 * upper/lower bottleneck. */
142
143 /* Find the bottlenecks by linear interpolation
144 * step is (56000 - 50000)/5 we use the inverse of it. */
145 const double stepSizeInv = 8.3333333e-4;
146 idxD = (inRateBitPerSec - 50000) * stepSizeInv;
147 idx = (idxD >= 5) ? 5 : ((int16_t)idxD);
148 idxErr = idxD - idx;
149 *rateLBBitPerSec = kLowerBandBitRate16[idx];
150 *rateUBBitPerSec = kUpperBandBitRate16[idx];
151
152 if (idx < 5) {
153 *rateLBBitPerSec += (int16_t)(idxErr *
154 (kLowerBandBitRate16[idx + 1] -
155 kLowerBandBitRate16[idx]));
156
157 *rateUBBitPerSec += (int16_t)(idxErr *
158 (kUpperBandBitRate16[idx + 1] -
159 kUpperBandBitRate16[idx]));
160 }
161 *bandwidthKHz = isac16kHz;
162 } else {
163 /* Out-of-range botlteneck value. */
164 return -1;
165 }
166
167 /* limit the values. */
168 *rateLBBitPerSec = (*rateLBBitPerSec > 32000) ? 32000 : *rateLBBitPerSec;
169 *rateUBBitPerSec = (*rateUBBitPerSec > 32000) ? 32000 : *rateUBBitPerSec;
170 return 0;
171 }
172
173
WebRtcIsac_ResetBitstream(Bitstr * bit_stream)174 void WebRtcIsac_ResetBitstream(Bitstr* bit_stream) {
175 bit_stream->W_upper = 0xFFFFFFFF;
176 bit_stream->stream_index = 0;
177 bit_stream->streamval = 0;
178 }
179
WebRtcIsac_EncodeLb(const TransformTables * transform_tables,float * in,ISACLBEncStruct * ISACencLB_obj,int16_t codingMode,int16_t bottleneckIndex)180 int WebRtcIsac_EncodeLb(const TransformTables* transform_tables,
181 float* in, ISACLBEncStruct* ISACencLB_obj,
182 int16_t codingMode,
183 int16_t bottleneckIndex) {
184 int stream_length = 0;
185 int err;
186 int k;
187 int iterCntr;
188
189 double lofilt_coef[(ORDERLO + 1)*SUBFRAMES];
190 double hifilt_coef[(ORDERHI + 1)*SUBFRAMES];
191 float LP[FRAMESAMPLES_HALF];
192 float HP[FRAMESAMPLES_HALF];
193
194 double LP_lookahead[FRAMESAMPLES_HALF];
195 double HP_lookahead[FRAMESAMPLES_HALF];
196 double LP_lookahead_pf[FRAMESAMPLES_HALF + QLOOKAHEAD];
197 double LPw[FRAMESAMPLES_HALF];
198
199 double HPw[FRAMESAMPLES_HALF];
200 double LPw_pf[FRAMESAMPLES_HALF];
201 int16_t fre[FRAMESAMPLES_HALF]; /* Q7 */
202 int16_t fim[FRAMESAMPLES_HALF]; /* Q7 */
203
204 double PitchLags[4];
205 double PitchGains[4];
206 int16_t PitchGains_Q12[4];
207 int16_t AvgPitchGain_Q12;
208
209 int frame_mode; /* 0 for 30ms, 1 for 60ms */
210 int status = 0;
211 int my_index;
212 transcode_obj transcodingParam;
213 double bytesLeftSpecCoding;
214 uint16_t payloadLimitBytes;
215
216 /* Copy new frame-length and bottleneck rate only for the first 10 ms data */
217 if (ISACencLB_obj->buffer_index == 0) {
218 /* Set the framelength for the next packet. */
219 ISACencLB_obj->current_framesamples = ISACencLB_obj->new_framelength;
220 }
221 /* 'frame_mode' is 0 (30 ms) or 1 (60 ms). */
222 frame_mode = ISACencLB_obj->current_framesamples / MAX_FRAMESAMPLES;
223
224 /* buffer speech samples (by 10ms packet) until the frame-length */
225 /* is reached (30 or 60 ms). */
226 /*****************************************************************/
227
228 /* fill the buffer with 10ms input data */
229 for (k = 0; k < FRAMESAMPLES_10ms; k++) {
230 ISACencLB_obj->data_buffer_float[k + ISACencLB_obj->buffer_index] = in[k];
231 }
232
233 /* If buffersize is not equal to current framesize then increase index
234 * and return. We do no encoding untill we have enough audio. */
235 if (ISACencLB_obj->buffer_index + FRAMESAMPLES_10ms != FRAMESAMPLES) {
236 ISACencLB_obj->buffer_index += FRAMESAMPLES_10ms;
237 return 0;
238 }
239 /* If buffer reached the right size, reset index and continue with
240 * encoding the frame. */
241 ISACencLB_obj->buffer_index = 0;
242
243 /* End of buffer function. */
244 /**************************/
245
246 /* Encoding */
247 /************/
248
249 if (frame_mode == 0 || ISACencLB_obj->frame_nb == 0) {
250 /* This is to avoid Linux warnings until we change 'int' to 'Word32'
251 * at all places. */
252 int intVar;
253 /* reset bitstream */
254 WebRtcIsac_ResetBitstream(&(ISACencLB_obj->bitstr_obj));
255
256 if ((codingMode == 0) && (frame_mode == 0) &&
257 (ISACencLB_obj->enforceFrameSize == 0)) {
258 ISACencLB_obj->new_framelength = WebRtcIsac_GetNewFrameLength(
259 ISACencLB_obj->bottleneck, ISACencLB_obj->current_framesamples);
260 }
261
262 ISACencLB_obj->s2nr = WebRtcIsac_GetSnr(
263 ISACencLB_obj->bottleneck, ISACencLB_obj->current_framesamples);
264
265 /* Encode frame length. */
266 status = WebRtcIsac_EncodeFrameLen(
267 ISACencLB_obj->current_framesamples, &ISACencLB_obj->bitstr_obj);
268 if (status < 0) {
269 /* Wrong frame size. */
270 return status;
271 }
272 /* Save framelength for multiple packets memory. */
273 ISACencLB_obj->SaveEnc_obj.framelength =
274 ISACencLB_obj->current_framesamples;
275
276 /* To be used for Redundant Coding. */
277 ISACencLB_obj->lastBWIdx = bottleneckIndex;
278 intVar = (int)bottleneckIndex;
279 WebRtcIsac_EncodeReceiveBw(&intVar, &ISACencLB_obj->bitstr_obj);
280 }
281
282 /* Split signal in two bands. */
283 WebRtcIsac_SplitAndFilterFloat(ISACencLB_obj->data_buffer_float, LP, HP,
284 LP_lookahead, HP_lookahead,
285 &ISACencLB_obj->prefiltbankstr_obj);
286
287 /* estimate pitch parameters and pitch-filter lookahead signal */
288 WebRtcIsac_PitchAnalysis(LP_lookahead, LP_lookahead_pf,
289 &ISACencLB_obj->pitchanalysisstr_obj, PitchLags,
290 PitchGains);
291
292 /* Encode in FIX Q12. */
293
294 /* Convert PitchGain to Fixed point. */
295 for (k = 0; k < PITCH_SUBFRAMES; k++) {
296 PitchGains_Q12[k] = (int16_t)(PitchGains[k] * 4096.0);
297 }
298
299 /* Set where to store data in multiple packets memory. */
300 if (frame_mode == 0 || ISACencLB_obj->frame_nb == 0) {
301 ISACencLB_obj->SaveEnc_obj.startIdx = 0;
302 } else {
303 ISACencLB_obj->SaveEnc_obj.startIdx = 1;
304 }
305
306 /* Quantize & encode pitch parameters. */
307 WebRtcIsac_EncodePitchGain(PitchGains_Q12, &ISACencLB_obj->bitstr_obj,
308 &ISACencLB_obj->SaveEnc_obj);
309 WebRtcIsac_EncodePitchLag(PitchLags, PitchGains_Q12,
310 &ISACencLB_obj->bitstr_obj,
311 &ISACencLB_obj->SaveEnc_obj);
312
313 AvgPitchGain_Q12 = (PitchGains_Q12[0] + PitchGains_Q12[1] +
314 PitchGains_Q12[2] + PitchGains_Q12[3]) >> 2;
315
316 /* Find coefficients for perceptual pre-filters. */
317 WebRtcIsac_GetLpcCoefLb(LP_lookahead_pf, HP_lookahead,
318 &ISACencLB_obj->maskfiltstr_obj, ISACencLB_obj->s2nr,
319 PitchGains_Q12, lofilt_coef, hifilt_coef);
320
321 /* Code LPC model and shape - gains not quantized yet. */
322 WebRtcIsac_EncodeLpcLb(lofilt_coef, hifilt_coef, &ISACencLB_obj->bitstr_obj,
323 &ISACencLB_obj->SaveEnc_obj);
324
325 /* Convert PitchGains back to FLOAT for pitchfilter_pre. */
326 for (k = 0; k < 4; k++) {
327 PitchGains[k] = ((float)PitchGains_Q12[k]) / 4096;
328 }
329
330 /* Store the state of arithmetic coder before coding LPC gains. */
331 transcodingParam.W_upper = ISACencLB_obj->bitstr_obj.W_upper;
332 transcodingParam.stream_index = ISACencLB_obj->bitstr_obj.stream_index;
333 transcodingParam.streamval = ISACencLB_obj->bitstr_obj.streamval;
334 transcodingParam.stream[0] =
335 ISACencLB_obj->bitstr_obj.stream[ISACencLB_obj->bitstr_obj.stream_index -
336 2];
337 transcodingParam.stream[1] =
338 ISACencLB_obj->bitstr_obj.stream[ISACencLB_obj->bitstr_obj.stream_index -
339 1];
340 transcodingParam.stream[2] =
341 ISACencLB_obj->bitstr_obj.stream[ISACencLB_obj->bitstr_obj.stream_index];
342
343 /* Store LPC Gains before encoding them. */
344 for (k = 0; k < SUBFRAMES; k++) {
345 transcodingParam.loFiltGain[k] = lofilt_coef[(LPC_LOBAND_ORDER + 1) * k];
346 transcodingParam.hiFiltGain[k] = hifilt_coef[(LPC_HIBAND_ORDER + 1) * k];
347 }
348
349 /* Code gains */
350 WebRtcIsac_EncodeLpcGainLb(lofilt_coef, hifilt_coef,
351 &ISACencLB_obj->bitstr_obj,
352 &ISACencLB_obj->SaveEnc_obj);
353
354 /* Get the correct value for the payload limit and calculate the
355 * number of bytes left for coding the spectrum. */
356 if ((frame_mode == 1) && (ISACencLB_obj->frame_nb == 0)) {
357 /* It is a 60ms and we are in the first 30ms then the limit at
358 * this point should be half of the assigned value. */
359 payloadLimitBytes = ISACencLB_obj->payloadLimitBytes60 >> 1;
360 } else if (frame_mode == 0) {
361 /* It is a 30ms frame */
362 /* Subract 3 because termination process may add 3 bytes. */
363 payloadLimitBytes = ISACencLB_obj->payloadLimitBytes30 - 3;
364 } else {
365 /* This is the second half of a 60ms frame. */
366 /* Subract 3 because termination process may add 3 bytes. */
367 payloadLimitBytes = ISACencLB_obj->payloadLimitBytes60 - 3;
368 }
369 bytesLeftSpecCoding = payloadLimitBytes - transcodingParam.stream_index;
370
371 /* Perceptual pre-filtering (using normalized lattice filter). */
372 /* Low-band filtering. */
373 WebRtcIsac_NormLatticeFilterMa(ORDERLO,
374 ISACencLB_obj->maskfiltstr_obj.PreStateLoF,
375 ISACencLB_obj->maskfiltstr_obj.PreStateLoG,
376 LP, lofilt_coef, LPw);
377 /* High-band filtering. */
378 WebRtcIsac_NormLatticeFilterMa(ORDERHI,
379 ISACencLB_obj->maskfiltstr_obj.PreStateHiF,
380 ISACencLB_obj->maskfiltstr_obj.PreStateHiG,
381 HP, hifilt_coef, HPw);
382 /* Pitch filter. */
383 WebRtcIsac_PitchfilterPre(LPw, LPw_pf, &ISACencLB_obj->pitchfiltstr_obj,
384 PitchLags, PitchGains);
385 /* Transform */
386 WebRtcIsac_Time2Spec(transform_tables,
387 LPw_pf, HPw, fre, fim, &ISACencLB_obj->fftstr_obj);
388
389 /* Save data for multiple packets memory. */
390 my_index = ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF;
391 memcpy(&ISACencLB_obj->SaveEnc_obj.fre[my_index], fre, sizeof(fre));
392 memcpy(&ISACencLB_obj->SaveEnc_obj.fim[my_index], fim, sizeof(fim));
393
394 ISACencLB_obj->SaveEnc_obj.AvgPitchGain[ISACencLB_obj->SaveEnc_obj.startIdx] =
395 AvgPitchGain_Q12;
396
397 /* Quantization and loss-less coding. */
398 err = WebRtcIsac_EncodeSpec(fre, fim, AvgPitchGain_Q12, kIsacLowerBand,
399 &ISACencLB_obj->bitstr_obj);
400 if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
401 /* There has been an error but it was not too large payload
402 (we can cure too large payload). */
403 if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
404 /* If this is the second 30ms of a 60ms frame reset
405 this such that in the next call encoder starts fresh. */
406 ISACencLB_obj->frame_nb = 0;
407 }
408 return err;
409 }
410 iterCntr = 0;
411 while ((ISACencLB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
412 (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
413 double bytesSpecCoderUsed;
414 double transcodeScale;
415
416 if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
417 /* We were not able to limit the payload size */
418 if ((frame_mode == 1) && (ISACencLB_obj->frame_nb == 0)) {
419 /* This was the first 30ms of a 60ms frame. Although
420 the payload is larger than it should be but we let
421 the second 30ms be encoded. Maybe together we
422 won't exceed the limit. */
423 ISACencLB_obj->frame_nb = 1;
424 return 0;
425 } else if ((frame_mode == 1) && (ISACencLB_obj->frame_nb == 1)) {
426 ISACencLB_obj->frame_nb = 0;
427 }
428
429 if (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
430 return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
431 } else {
432 return status;
433 }
434 }
435
436 if (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
437 bytesSpecCoderUsed = STREAM_SIZE_MAX;
438 /* Being conservative */
439 transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
440 } else {
441 bytesSpecCoderUsed = ISACencLB_obj->bitstr_obj.stream_index -
442 transcodingParam.stream_index;
443 transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
444 }
445
446 /* To be safe, we reduce the scale depending on
447 the number of iterations. */
448 transcodeScale *= (1.0 - (0.9 * (double)iterCntr /
449 (double)MAX_PAYLOAD_LIMIT_ITERATION));
450
451 /* Scale the LPC Gains. */
452 for (k = 0; k < SUBFRAMES; k++) {
453 lofilt_coef[(LPC_LOBAND_ORDER + 1) * k] =
454 transcodingParam.loFiltGain[k] * transcodeScale;
455 hifilt_coef[(LPC_HIBAND_ORDER + 1) * k] =
456 transcodingParam.hiFiltGain[k] * transcodeScale;
457 transcodingParam.loFiltGain[k] = lofilt_coef[(LPC_LOBAND_ORDER + 1) * k];
458 transcodingParam.hiFiltGain[k] = hifilt_coef[(LPC_HIBAND_ORDER + 1) * k];
459 }
460
461 /* Scale DFT coefficients. */
462 for (k = 0; k < FRAMESAMPLES_HALF; k++) {
463 fre[k] = (int16_t)(fre[k] * transcodeScale);
464 fim[k] = (int16_t)(fim[k] * transcodeScale);
465 }
466
467 /* Save data for multiple packets memory. */
468 my_index = ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF;
469 memcpy(&ISACencLB_obj->SaveEnc_obj.fre[my_index], fre, sizeof(fre));
470 memcpy(&ISACencLB_obj->SaveEnc_obj.fim[my_index], fim, sizeof(fim));
471
472 /* Re-store the state of arithmetic coder before coding LPC gains. */
473 ISACencLB_obj->bitstr_obj.W_upper = transcodingParam.W_upper;
474 ISACencLB_obj->bitstr_obj.stream_index = transcodingParam.stream_index;
475 ISACencLB_obj->bitstr_obj.streamval = transcodingParam.streamval;
476 ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index - 2] =
477 transcodingParam.stream[0];
478 ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index - 1] =
479 transcodingParam.stream[1];
480 ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index] =
481 transcodingParam.stream[2];
482
483 /* Code gains. */
484 WebRtcIsac_EncodeLpcGainLb(lofilt_coef, hifilt_coef,
485 &ISACencLB_obj->bitstr_obj,
486 &ISACencLB_obj->SaveEnc_obj);
487
488 /* Update the number of bytes left for encoding the spectrum. */
489 bytesLeftSpecCoding = payloadLimitBytes - transcodingParam.stream_index;
490
491 /* Encode the spectrum. */
492 err = WebRtcIsac_EncodeSpec(fre, fim, AvgPitchGain_Q12, kIsacLowerBand,
493 &ISACencLB_obj->bitstr_obj);
494
495 if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
496 /* There has been an error but it was not too large
497 payload (we can cure too large payload). */
498 if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
499 /* If this is the second 30 ms of a 60 ms frame reset
500 this such that in the next call encoder starts fresh. */
501 ISACencLB_obj->frame_nb = 0;
502 }
503 return err;
504 }
505 iterCntr++;
506 }
507
508 /* If 60 ms frame-size and just processed the first 30 ms, */
509 /* go back to main function to buffer the other 30 ms speech frame. */
510 if (frame_mode == 1) {
511 if (ISACencLB_obj->frame_nb == 0) {
512 ISACencLB_obj->frame_nb = 1;
513 return 0;
514 } else if (ISACencLB_obj->frame_nb == 1) {
515 ISACencLB_obj->frame_nb = 0;
516 /* Also update the frame-length for next packet,
517 in Adaptive mode only. */
518 if (codingMode == 0 && (ISACencLB_obj->enforceFrameSize == 0)) {
519 ISACencLB_obj->new_framelength =
520 WebRtcIsac_GetNewFrameLength(ISACencLB_obj->bottleneck,
521 ISACencLB_obj->current_framesamples);
522 }
523 }
524 } else {
525 ISACencLB_obj->frame_nb = 0;
526 }
527
528 /* Complete arithmetic coding. */
529 stream_length = WebRtcIsac_EncTerminate(&ISACencLB_obj->bitstr_obj);
530 return stream_length;
531 }
532
533
534
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)535 static int LimitPayloadUb(ISACUBEncStruct* ISACencUB_obj,
536 uint16_t payloadLimitBytes,
537 double bytesLeftSpecCoding,
538 transcode_obj* transcodingParam,
539 int16_t* fre, int16_t* fim,
540 double* lpcGains, enum ISACBand band, int status) {
541
542 int iterCntr = 0;
543 int k;
544 double bytesSpecCoderUsed;
545 double transcodeScale;
546 const int16_t kAveragePitchGain = 0.0;
547
548 do {
549 if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
550 /* We were not able to limit the payload size. */
551 return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
552 }
553
554 if (status == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
555 bytesSpecCoderUsed = STREAM_SIZE_MAX;
556 /* Being conservative. */
557 transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
558 } else {
559 bytesSpecCoderUsed = ISACencUB_obj->bitstr_obj.stream_index -
560 transcodingParam->stream_index;
561 transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
562 }
563
564 /* To be safe, we reduce the scale depending on the
565 number of iterations. */
566 transcodeScale *= (1.0 - (0.9 * (double)iterCntr /
567 (double)MAX_PAYLOAD_LIMIT_ITERATION));
568
569 /* Scale the LPC Gains. */
570 if (band == kIsacUpperBand16) {
571 /* Two sets of coefficients if 16 kHz. */
572 for (k = 0; k < SUBFRAMES; k++) {
573 transcodingParam->loFiltGain[k] *= transcodeScale;
574 transcodingParam->hiFiltGain[k] *= transcodeScale;
575 }
576 } else {
577 /* One sets of coefficients if 12 kHz. */
578 for (k = 0; k < SUBFRAMES; k++) {
579 transcodingParam->loFiltGain[k] *= transcodeScale;
580 }
581 }
582
583 /* Scale DFT coefficients. */
584 for (k = 0; k < FRAMESAMPLES_HALF; k++) {
585 fre[k] = (int16_t)(fre[k] * transcodeScale + 0.5);
586 fim[k] = (int16_t)(fim[k] * transcodeScale + 0.5);
587 }
588 /* Store FFT coefficients for multiple encoding. */
589 memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre,
590 sizeof(ISACencUB_obj->SaveEnc_obj.realFFT));
591 memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
592 sizeof(ISACencUB_obj->SaveEnc_obj.imagFFT));
593
594 /* Store the state of arithmetic coder before coding LPC gains */
595 ISACencUB_obj->bitstr_obj.W_upper = transcodingParam->W_upper;
596 ISACencUB_obj->bitstr_obj.stream_index = transcodingParam->stream_index;
597 ISACencUB_obj->bitstr_obj.streamval = transcodingParam->streamval;
598 ISACencUB_obj->bitstr_obj.stream[transcodingParam->stream_index - 2] =
599 transcodingParam->stream[0];
600 ISACencUB_obj->bitstr_obj.stream[transcodingParam->stream_index - 1] =
601 transcodingParam->stream[1];
602 ISACencUB_obj->bitstr_obj.stream[transcodingParam->stream_index] =
603 transcodingParam->stream[2];
604
605 /* Store the gains for multiple encoding. */
606 memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains,
607 SUBFRAMES * sizeof(double));
608 /* Entropy Code lpc-gains, indices are stored for a later use.*/
609 WebRtcIsac_EncodeLpcGainUb(transcodingParam->loFiltGain,
610 &ISACencUB_obj->bitstr_obj,
611 ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
612
613 /* If 16kHz should do one more set. */
614 if (band == kIsacUpperBand16) {
615 /* Store the gains for multiple encoding. */
616 memcpy(&ISACencUB_obj->SaveEnc_obj.lpcGain[SUBFRAMES],
617 &lpcGains[SUBFRAMES], SUBFRAMES * sizeof(double));
618 /* Entropy Code lpc-gains, indices are stored for a later use.*/
619 WebRtcIsac_EncodeLpcGainUb(
620 transcodingParam->hiFiltGain, &ISACencUB_obj->bitstr_obj,
621 &ISACencUB_obj->SaveEnc_obj.lpcGainIndex[SUBFRAMES]);
622 }
623
624 /* Update the number of bytes left for encoding the spectrum. */
625 bytesLeftSpecCoding = payloadLimitBytes -
626 ISACencUB_obj->bitstr_obj.stream_index;
627
628 /* Save the bit-stream object at this point for FEC. */
629 memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
630 &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));
631
632 /* Encode the spectrum. */
633 status = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain,
634 band, &ISACencUB_obj->bitstr_obj);
635 if ((status < 0) && (status != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
636 /* There has been an error but it was not too large payload
637 (we can cure too large payload). */
638 return status;
639 }
640 iterCntr++;
641 } while ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
642 (status == -ISAC_DISALLOWED_BITSTREAM_LENGTH));
643 return 0;
644 }
645
WebRtcIsac_EncodeUb16(const TransformTables * transform_tables,float * in,ISACUBEncStruct * ISACencUB_obj,int32_t jitterInfo)646 int WebRtcIsac_EncodeUb16(const TransformTables* transform_tables,
647 float* in, ISACUBEncStruct* ISACencUB_obj,
648 int32_t jitterInfo) {
649 int err;
650 int k;
651
652 double lpcVecs[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
653 double percepFilterParams[(1 + UB_LPC_ORDER) * (SUBFRAMES << 1) +
654 (1 + UB_LPC_ORDER)];
655
656 double LP_lookahead[FRAMESAMPLES];
657 int16_t fre[FRAMESAMPLES_HALF]; /* Q7 */
658 int16_t fim[FRAMESAMPLES_HALF]; /* Q7 */
659
660 int status = 0;
661
662 double varscale[2];
663 double corr[SUBFRAMES << 1][UB_LPC_ORDER + 1];
664 double lpcGains[SUBFRAMES << 1];
665 transcode_obj transcodingParam;
666 uint16_t payloadLimitBytes;
667 double s2nr;
668 const int16_t kAveragePitchGain = 0.0;
669 int bytesLeftSpecCoding;
670
671 /* Buffer speech samples (by 10ms packet) until the frame-length is */
672 /* reached (30 ms). */
673 /*********************************************************************/
674
675 /* fill the buffer with 10ms input data */
676 memcpy(&ISACencUB_obj->data_buffer_float[ISACencUB_obj->buffer_index], in,
677 FRAMESAMPLES_10ms * sizeof(float));
678
679 /* If buffer size is not equal to current frame-size, and end of file is
680 * not reached yet, we don't do encoding unless we have the whole frame. */
681 if (ISACencUB_obj->buffer_index + FRAMESAMPLES_10ms < FRAMESAMPLES) {
682 ISACencUB_obj->buffer_index += FRAMESAMPLES_10ms;
683 return 0;
684 }
685
686 /* End of buffer function. */
687 /**************************/
688
689 /* Encoding */
690 /************/
691
692 /* Reset bit-stream */
693 WebRtcIsac_ResetBitstream(&(ISACencUB_obj->bitstr_obj));
694
695 /* Encoding of bandwidth information. */
696 WebRtcIsac_EncodeJitterInfo(jitterInfo, &ISACencUB_obj->bitstr_obj);
697
698 status = WebRtcIsac_EncodeBandwidth(isac16kHz, &ISACencUB_obj->bitstr_obj);
699 if (status < 0) {
700 return status;
701 }
702
703 s2nr = WebRtcIsac_GetSnr(ISACencUB_obj->bottleneck, FRAMESAMPLES);
704
705 memcpy(lpcVecs, ISACencUB_obj->lastLPCVec, UB_LPC_ORDER * sizeof(double));
706
707 for (k = 0; k < FRAMESAMPLES; k++) {
708 LP_lookahead[k] = ISACencUB_obj->data_buffer_float[UB_LOOKAHEAD + k];
709 }
710
711 /* Find coefficients for perceptual pre-filters. */
712 WebRtcIsac_GetLpcCoefUb(LP_lookahead, &ISACencUB_obj->maskfiltstr_obj,
713 &lpcVecs[UB_LPC_ORDER], corr, varscale, isac16kHz);
714
715 memcpy(ISACencUB_obj->lastLPCVec,
716 &lpcVecs[(UB16_LPC_VEC_PER_FRAME - 1) * (UB_LPC_ORDER)],
717 sizeof(double) * UB_LPC_ORDER);
718
719 /* Code LPC model and shape - gains not quantized yet. */
720 WebRtcIsac_EncodeLpcUB(lpcVecs, &ISACencUB_obj->bitstr_obj,
721 percepFilterParams, isac16kHz,
722 &ISACencUB_obj->SaveEnc_obj);
723
724 /* the first set of lpc parameters are from the last sub-frame of
725 * the previous frame. so we don't care about them. */
726 WebRtcIsac_GetLpcGain(s2nr, &percepFilterParams[UB_LPC_ORDER + 1],
727 (SUBFRAMES << 1), lpcGains, corr, varscale);
728
729 /* Store the state of arithmetic coder before coding LPC gains */
730 transcodingParam.stream_index = ISACencUB_obj->bitstr_obj.stream_index;
731 transcodingParam.W_upper = ISACencUB_obj->bitstr_obj.W_upper;
732 transcodingParam.streamval = ISACencUB_obj->bitstr_obj.streamval;
733 transcodingParam.stream[0] =
734 ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
735 2];
736 transcodingParam.stream[1] =
737 ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
738 1];
739 transcodingParam.stream[2] =
740 ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index];
741
742 /* Store LPC Gains before encoding them. */
743 for (k = 0; k < SUBFRAMES; k++) {
744 transcodingParam.loFiltGain[k] = lpcGains[k];
745 transcodingParam.hiFiltGain[k] = lpcGains[SUBFRAMES + k];
746 }
747
748 /* Store the gains for multiple encoding. */
749 memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains,
750 (SUBFRAMES << 1) * sizeof(double));
751
752 WebRtcIsac_EncodeLpcGainUb(lpcGains, &ISACencUB_obj->bitstr_obj,
753 ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
754 WebRtcIsac_EncodeLpcGainUb(
755 &lpcGains[SUBFRAMES], &ISACencUB_obj->bitstr_obj,
756 &ISACencUB_obj->SaveEnc_obj.lpcGainIndex[SUBFRAMES]);
757
758 /* Get the correct value for the payload limit and calculate the number of
759 bytes left for coding the spectrum. It is a 30ms frame
760 Subract 3 because termination process may add 3 bytes */
761 payloadLimitBytes = ISACencUB_obj->maxPayloadSizeBytes -
762 ISACencUB_obj->numBytesUsed - 3;
763 bytesLeftSpecCoding = payloadLimitBytes -
764 ISACencUB_obj->bitstr_obj.stream_index;
765
766 for (k = 0; k < (SUBFRAMES << 1); k++) {
767 percepFilterParams[k * (UB_LPC_ORDER + 1) + (UB_LPC_ORDER + 1)] =
768 lpcGains[k];
769 }
770
771 /* LPC filtering (using normalized lattice filter), */
772 /* first half-frame. */
773 WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
774 ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
775 ISACencUB_obj->maskfiltstr_obj.PreStateLoG,
776 &ISACencUB_obj->data_buffer_float[0],
777 &percepFilterParams[UB_LPC_ORDER + 1],
778 &LP_lookahead[0]);
779
780 /* Second half-frame filtering. */
781 WebRtcIsac_NormLatticeFilterMa(
782 UB_LPC_ORDER, ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
783 ISACencUB_obj->maskfiltstr_obj.PreStateLoG,
784 &ISACencUB_obj->data_buffer_float[FRAMESAMPLES_HALF],
785 &percepFilterParams[(UB_LPC_ORDER + 1) + SUBFRAMES * (UB_LPC_ORDER + 1)],
786 &LP_lookahead[FRAMESAMPLES_HALF]);
787
788 WebRtcIsac_Time2Spec(transform_tables,
789 &LP_lookahead[0], &LP_lookahead[FRAMESAMPLES_HALF],
790 fre, fim, &ISACencUB_obj->fftstr_obj);
791
792 /* Store FFT coefficients for multiple encoding. */
793 memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre, sizeof(fre));
794 memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim, sizeof(fim));
795
796 /* Prepare the audio buffer for the next packet
797 * move the last 3 ms to the beginning of the buffer. */
798 memcpy(ISACencUB_obj->data_buffer_float,
799 &ISACencUB_obj->data_buffer_float[FRAMESAMPLES],
800 LB_TOTAL_DELAY_SAMPLES * sizeof(float));
801 /* start writing with 3 ms delay to compensate for the delay
802 * of the lower-band. */
803 ISACencUB_obj->buffer_index = LB_TOTAL_DELAY_SAMPLES;
804
805 /* Save the bit-stream object at this point for FEC. */
806 memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj, &ISACencUB_obj->bitstr_obj,
807 sizeof(Bitstr));
808
809 /* Qantization and lossless coding */
810 /* Note that there is no pitch-gain for this band so kAveragePitchGain = 0
811 * is passed to the function. In fact, the function ignores the 3rd parameter
812 * for this band. */
813 err = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain, kIsacUpperBand16,
814 &ISACencUB_obj->bitstr_obj);
815 if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
816 return err;
817 }
818
819 if ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
820 (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
821 err = LimitPayloadUb(ISACencUB_obj, payloadLimitBytes, bytesLeftSpecCoding,
822 &transcodingParam, fre, fim, lpcGains,
823 kIsacUpperBand16, err);
824 }
825 if (err < 0) {
826 return err;
827 }
828 /* Complete arithmetic coding. */
829 return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
830 }
831
832
WebRtcIsac_EncodeUb12(const TransformTables * transform_tables,float * in,ISACUBEncStruct * ISACencUB_obj,int32_t jitterInfo)833 int WebRtcIsac_EncodeUb12(const TransformTables* transform_tables,
834 float* in, ISACUBEncStruct* ISACencUB_obj,
835 int32_t jitterInfo) {
836 int err;
837 int k;
838
839 double lpcVecs[UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME];
840
841 double percepFilterParams[(1 + UB_LPC_ORDER) * SUBFRAMES];
842 float LP[FRAMESAMPLES_HALF];
843 float HP[FRAMESAMPLES_HALF];
844
845 double LP_lookahead[FRAMESAMPLES_HALF];
846 double HP_lookahead[FRAMESAMPLES_HALF];
847 double LPw[FRAMESAMPLES_HALF];
848
849 double HPw[FRAMESAMPLES_HALF];
850 int16_t fre[FRAMESAMPLES_HALF]; /* Q7 */
851 int16_t fim[FRAMESAMPLES_HALF]; /* Q7 */
852
853 int status = 0;
854
855 double varscale[1];
856
857 double corr[UB_LPC_GAIN_DIM][UB_LPC_ORDER + 1];
858 double lpcGains[SUBFRAMES];
859 transcode_obj transcodingParam;
860 uint16_t payloadLimitBytes;
861 double s2nr;
862 const int16_t kAveragePitchGain = 0.0;
863 double bytesLeftSpecCoding;
864
865 /* Buffer speech samples (by 10ms packet) until the framelength is */
866 /* reached (30 ms). */
867 /********************************************************************/
868
869 /* Fill the buffer with 10ms input data. */
870 memcpy(&ISACencUB_obj->data_buffer_float[ISACencUB_obj->buffer_index], in,
871 FRAMESAMPLES_10ms * sizeof(float));
872
873 /* if buffer-size is not equal to current frame-size then increase the
874 index and return. We do the encoding when we have enough audio. */
875 if (ISACencUB_obj->buffer_index + FRAMESAMPLES_10ms < FRAMESAMPLES) {
876 ISACencUB_obj->buffer_index += FRAMESAMPLES_10ms;
877 return 0;
878 }
879 /* If buffer reached the right size, reset index and continue
880 with encoding the frame */
881 ISACencUB_obj->buffer_index = 0;
882
883 /* End of buffer function */
884 /**************************/
885
886 /* Encoding */
887 /************/
888
889 /* Reset bit-stream. */
890 WebRtcIsac_ResetBitstream(&(ISACencUB_obj->bitstr_obj));
891
892 /* Encoding bandwidth information. */
893 WebRtcIsac_EncodeJitterInfo(jitterInfo, &ISACencUB_obj->bitstr_obj);
894 status = WebRtcIsac_EncodeBandwidth(isac12kHz, &ISACencUB_obj->bitstr_obj);
895 if (status < 0) {
896 return status;
897 }
898
899 s2nr = WebRtcIsac_GetSnr(ISACencUB_obj->bottleneck, FRAMESAMPLES);
900
901 /* Split signal in two bands. */
902 WebRtcIsac_SplitAndFilterFloat(ISACencUB_obj->data_buffer_float, HP, LP,
903 HP_lookahead, LP_lookahead,
904 &ISACencUB_obj->prefiltbankstr_obj);
905
906 /* Find coefficients for perceptual pre-filters. */
907 WebRtcIsac_GetLpcCoefUb(LP_lookahead, &ISACencUB_obj->maskfiltstr_obj,
908 lpcVecs, corr, varscale, isac12kHz);
909
910 /* Code LPC model and shape - gains not quantized yet. */
911 WebRtcIsac_EncodeLpcUB(lpcVecs, &ISACencUB_obj->bitstr_obj,
912 percepFilterParams, isac12kHz,
913 &ISACencUB_obj->SaveEnc_obj);
914
915 WebRtcIsac_GetLpcGain(s2nr, percepFilterParams, SUBFRAMES, lpcGains, corr,
916 varscale);
917
918 /* Store the state of arithmetic coder before coding LPC gains. */
919 transcodingParam.W_upper = ISACencUB_obj->bitstr_obj.W_upper;
920 transcodingParam.stream_index = ISACencUB_obj->bitstr_obj.stream_index;
921 transcodingParam.streamval = ISACencUB_obj->bitstr_obj.streamval;
922 transcodingParam.stream[0] =
923 ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
924 2];
925 transcodingParam.stream[1] =
926 ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index -
927 1];
928 transcodingParam.stream[2] =
929 ISACencUB_obj->bitstr_obj.stream[ISACencUB_obj->bitstr_obj.stream_index];
930
931 /* Store LPC Gains before encoding them. */
932 for (k = 0; k < SUBFRAMES; k++) {
933 transcodingParam.loFiltGain[k] = lpcGains[k];
934 }
935
936 /* Store the gains for multiple encoding. */
937 memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains, SUBFRAMES *
938 sizeof(double));
939
940 WebRtcIsac_EncodeLpcGainUb(lpcGains, &ISACencUB_obj->bitstr_obj,
941 ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
942
943 for (k = 0; k < SUBFRAMES; k++) {
944 percepFilterParams[k * (UB_LPC_ORDER + 1)] = lpcGains[k];
945 }
946
947 /* perceptual pre-filtering (using normalized lattice filter) */
948 /* low-band filtering */
949 WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
950 ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
951 ISACencUB_obj->maskfiltstr_obj.PreStateLoG, LP,
952 percepFilterParams, LPw);
953
954 /* Get the correct value for the payload limit and calculate the number
955 of bytes left for coding the spectrum. It is a 30ms frame Subract 3
956 because termination process may add 3 bytes */
957 payloadLimitBytes = ISACencUB_obj->maxPayloadSizeBytes -
958 ISACencUB_obj->numBytesUsed - 3;
959 bytesLeftSpecCoding = payloadLimitBytes -
960 ISACencUB_obj->bitstr_obj.stream_index;
961
962 memset(HPw, 0, sizeof(HPw));
963
964 /* Transform */
965 WebRtcIsac_Time2Spec(transform_tables,
966 LPw, HPw, fre, fim, &ISACencUB_obj->fftstr_obj);
967
968 /* Store FFT coefficients for multiple encoding. */
969 memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre,
970 sizeof(ISACencUB_obj->SaveEnc_obj.realFFT));
971 memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
972 sizeof(ISACencUB_obj->SaveEnc_obj.imagFFT));
973
974 /* Save the bit-stream object at this point for FEC. */
975 memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
976 &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));
977
978 /* Quantization and loss-less coding */
979 /* The 4th parameter to this function is pitch-gain, which is only used
980 * when encoding 0-8 kHz band, and irrelevant in this function, therefore,
981 * we insert zero here. */
982 err = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain, kIsacUpperBand12,
983 &ISACencUB_obj->bitstr_obj);
984 if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
985 /* There has been an error but it was not too large
986 payload (we can cure too large payload) */
987 return err;
988 }
989
990 if ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
991 (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
992 err = LimitPayloadUb(ISACencUB_obj, payloadLimitBytes, bytesLeftSpecCoding,
993 &transcodingParam, fre, fim, lpcGains,
994 kIsacUpperBand12, err);
995 }
996 if (err < 0) {
997 return err;
998 }
999 /* Complete arithmetic coding. */
1000 return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
1001 }
1002
1003
1004
1005
1006
1007
1008 /* This function is used to create a new bit-stream with new BWE.
1009 The same data as previously encoded with the function WebRtcIsac_Encoder().
1010 The data needed is taken from the structure, where it was stored
1011 when calling the encoder. */
1012
WebRtcIsac_EncodeStoredDataLb(const IsacSaveEncoderData * ISACSavedEnc_obj,Bitstr * ISACBitStr_obj,int BWnumber,float scale)1013 int WebRtcIsac_EncodeStoredDataLb(const IsacSaveEncoderData* ISACSavedEnc_obj,
1014 Bitstr* ISACBitStr_obj, int BWnumber,
1015 float scale) {
1016 int ii;
1017 int status;
1018 int BWno = BWnumber;
1019
1020 const uint16_t* WebRtcIsac_kQPitchGainCdf_ptr[1];
1021 const uint16_t** cdf;
1022
1023 double tmpLPCcoeffs_lo[(ORDERLO + 1)*SUBFRAMES * 2];
1024 double tmpLPCcoeffs_hi[(ORDERHI + 1)*SUBFRAMES * 2];
1025 int tmpLPCindex_g[12 * 2];
1026 int16_t tmp_fre[FRAMESAMPLES], tmp_fim[FRAMESAMPLES];
1027 const int kModel = 0;
1028
1029 /* Sanity Check - possible values for BWnumber is 0 - 23. */
1030 if ((BWnumber < 0) || (BWnumber > 23)) {
1031 return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
1032 }
1033
1034 /* Reset bit-stream. */
1035 WebRtcIsac_ResetBitstream(ISACBitStr_obj);
1036
1037 /* Encode frame length */
1038 status = WebRtcIsac_EncodeFrameLen(ISACSavedEnc_obj->framelength,
1039 ISACBitStr_obj);
1040 if (status < 0) {
1041 /* Wrong frame size. */
1042 return status;
1043 }
1044
1045 /* Transcoding */
1046 if ((scale > 0.0) && (scale < 1.0)) {
1047 /* Compensate LPC gain. */
1048 for (ii = 0;
1049 ii < ((ORDERLO + 1)* SUBFRAMES * (1 + ISACSavedEnc_obj->startIdx));
1050 ii++) {
1051 tmpLPCcoeffs_lo[ii] = scale * ISACSavedEnc_obj->LPCcoeffs_lo[ii];
1052 }
1053 for (ii = 0;
1054 ii < ((ORDERHI + 1) * SUBFRAMES * (1 + ISACSavedEnc_obj->startIdx));
1055 ii++) {
1056 tmpLPCcoeffs_hi[ii] = scale * ISACSavedEnc_obj->LPCcoeffs_hi[ii];
1057 }
1058 /* Scale DFT. */
1059 for (ii = 0;
1060 ii < (FRAMESAMPLES_HALF * (1 + ISACSavedEnc_obj->startIdx));
1061 ii++) {
1062 tmp_fre[ii] = (int16_t)((scale) * (float)ISACSavedEnc_obj->fre[ii]);
1063 tmp_fim[ii] = (int16_t)((scale) * (float)ISACSavedEnc_obj->fim[ii]);
1064 }
1065 } else {
1066 for (ii = 0;
1067 ii < (KLT_ORDER_GAIN * (1 + ISACSavedEnc_obj->startIdx));
1068 ii++) {
1069 tmpLPCindex_g[ii] = ISACSavedEnc_obj->LPCindex_g[ii];
1070 }
1071 for (ii = 0;
1072 ii < (FRAMESAMPLES_HALF * (1 + ISACSavedEnc_obj->startIdx));
1073 ii++) {
1074 tmp_fre[ii] = ISACSavedEnc_obj->fre[ii];
1075 tmp_fim[ii] = ISACSavedEnc_obj->fim[ii];
1076 }
1077 }
1078
1079 /* Encode bandwidth estimate. */
1080 WebRtcIsac_EncodeReceiveBw(&BWno, ISACBitStr_obj);
1081
1082 /* Loop over number of 30 msec */
1083 for (ii = 0; ii <= ISACSavedEnc_obj->startIdx; ii++) {
1084 /* Encode pitch gains. */
1085 *WebRtcIsac_kQPitchGainCdf_ptr = WebRtcIsac_kQPitchGainCdf;
1086 WebRtcIsac_EncHistMulti(ISACBitStr_obj,
1087 &ISACSavedEnc_obj->pitchGain_index[ii],
1088 WebRtcIsac_kQPitchGainCdf_ptr, 1);
1089
1090 /* Entropy coding of quantization pitch lags */
1091 /* Voicing classification. */
1092 if (ISACSavedEnc_obj->meanGain[ii] < 0.2) {
1093 cdf = WebRtcIsac_kQPitchLagCdfPtrLo;
1094 } else if (ISACSavedEnc_obj->meanGain[ii] < 0.4) {
1095 cdf = WebRtcIsac_kQPitchLagCdfPtrMid;
1096 } else {
1097 cdf = WebRtcIsac_kQPitchLagCdfPtrHi;
1098 }
1099 WebRtcIsac_EncHistMulti(ISACBitStr_obj,
1100 &ISACSavedEnc_obj->pitchIndex[PITCH_SUBFRAMES * ii],
1101 cdf, PITCH_SUBFRAMES);
1102
1103 /* LPC */
1104 /* Only one model exists. The entropy coding is done only for backward
1105 * compatibility. */
1106 WebRtcIsac_EncHistMulti(ISACBitStr_obj, &kModel,
1107 WebRtcIsac_kQKltModelCdfPtr, 1);
1108 /* Entropy coding of quantization indices - LPC shape only. */
1109 WebRtcIsac_EncHistMulti(ISACBitStr_obj,
1110 &ISACSavedEnc_obj->LPCindex_s[KLT_ORDER_SHAPE * ii],
1111 WebRtcIsac_kQKltCdfPtrShape,
1112 KLT_ORDER_SHAPE);
1113
1114 /* If transcoding, get new LPC gain indices */
1115 if (scale < 1.0) {
1116 WebRtcIsac_TranscodeLPCCoef(
1117 &tmpLPCcoeffs_lo[(ORDERLO + 1) * SUBFRAMES * ii],
1118 &tmpLPCcoeffs_hi[(ORDERHI + 1)*SUBFRAMES * ii],
1119 &tmpLPCindex_g[KLT_ORDER_GAIN * ii]);
1120 }
1121
1122 /* Entropy coding of quantization indices - LPC gain. */
1123 WebRtcIsac_EncHistMulti(ISACBitStr_obj, &tmpLPCindex_g[KLT_ORDER_GAIN * ii],
1124 WebRtcIsac_kQKltCdfPtrGain, KLT_ORDER_GAIN);
1125
1126 /* Quantization and loss-less coding. */
1127 status = WebRtcIsac_EncodeSpec(&tmp_fre[ii * FRAMESAMPLES_HALF],
1128 &tmp_fim[ii * FRAMESAMPLES_HALF],
1129 ISACSavedEnc_obj->AvgPitchGain[ii],
1130 kIsacLowerBand, ISACBitStr_obj);
1131 if (status < 0) {
1132 return status;
1133 }
1134 }
1135 /* Complete arithmetic coding. */
1136 return WebRtcIsac_EncTerminate(ISACBitStr_obj);
1137 }
1138
1139
WebRtcIsac_EncodeStoredDataUb(const ISACUBSaveEncDataStruct * ISACSavedEnc_obj,Bitstr * bitStream,int32_t jitterInfo,float scale,enum ISACBandwidth bandwidth)1140 int WebRtcIsac_EncodeStoredDataUb(
1141 const ISACUBSaveEncDataStruct* ISACSavedEnc_obj,
1142 Bitstr* bitStream,
1143 int32_t jitterInfo,
1144 float scale,
1145 enum ISACBandwidth bandwidth) {
1146 int n;
1147 int err;
1148 double lpcGain[SUBFRAMES];
1149 int16_t realFFT[FRAMESAMPLES_HALF];
1150 int16_t imagFFT[FRAMESAMPLES_HALF];
1151 const uint16_t** shape_cdf;
1152 int shape_len;
1153 const int16_t kAveragePitchGain = 0.0;
1154 enum ISACBand band;
1155 /* Reset bitstream. */
1156 WebRtcIsac_ResetBitstream(bitStream);
1157
1158 /* Encode jitter index. */
1159 WebRtcIsac_EncodeJitterInfo(jitterInfo, bitStream);
1160
1161 err = WebRtcIsac_EncodeBandwidth(bandwidth, bitStream);
1162 if (err < 0) {
1163 return err;
1164 }
1165
1166 /* Encode LPC-shape. */
1167 if (bandwidth == isac12kHz) {
1168 shape_cdf = WebRtcIsac_kLpcShapeCdfMatUb12;
1169 shape_len = UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME;
1170 band = kIsacUpperBand12;
1171 } else {
1172 shape_cdf = WebRtcIsac_kLpcShapeCdfMatUb16;
1173 shape_len = UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME;
1174 band = kIsacUpperBand16;
1175 }
1176 WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->indexLPCShape,
1177 shape_cdf, shape_len);
1178
1179 if ((scale <= 0.0) || (scale >= 1.0)) {
1180 /* We only consider scales between zero and one. */
1181 WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->lpcGainIndex,
1182 WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
1183 if (bandwidth == isac16kHz) {
1184 /* Store gain indices of the second half. */
1185 WebRtcIsac_EncHistMulti(bitStream,
1186 &ISACSavedEnc_obj->lpcGainIndex[SUBFRAMES],
1187 WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
1188 }
1189 /* Store FFT coefficients. */
1190 err = WebRtcIsac_EncodeSpec(ISACSavedEnc_obj->realFFT,
1191 ISACSavedEnc_obj->imagFFT, kAveragePitchGain,
1192 band, bitStream);
1193 } else {
1194 /* Scale LPC gain and FFT coefficients. */
1195 for (n = 0; n < SUBFRAMES; n++) {
1196 lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n];
1197 }
1198 /* Store LPC gains. */
1199 WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
1200
1201 if (bandwidth == isac16kHz) {
1202 /* Scale and code the gains of the second half of the frame, if 16kHz. */
1203 for (n = 0; n < SUBFRAMES; n++) {
1204 lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n + SUBFRAMES];
1205 }
1206 WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
1207 }
1208
1209 for (n = 0; n < FRAMESAMPLES_HALF; n++) {
1210 realFFT[n] = (int16_t)(scale * (float)ISACSavedEnc_obj->realFFT[n] +
1211 0.5f);
1212 imagFFT[n] = (int16_t)(scale * (float)ISACSavedEnc_obj->imagFFT[n] +
1213 0.5f);
1214 }
1215 /* Store FFT coefficients. */
1216 err = WebRtcIsac_EncodeSpec(realFFT, imagFFT, kAveragePitchGain,
1217 band, bitStream);
1218 }
1219 if (err < 0) {
1220 /* Error happened while encoding FFT coefficients. */
1221 return err;
1222 }
1223
1224 /* Complete arithmetic coding. */
1225 return WebRtcIsac_EncTerminate(bitStream);
1226 }
1227
WebRtcIsac_GetRedPayloadUb(const ISACUBSaveEncDataStruct * ISACSavedEncObj,Bitstr * bitStreamObj,enum ISACBandwidth bandwidth)1228 int16_t WebRtcIsac_GetRedPayloadUb(
1229 const ISACUBSaveEncDataStruct* ISACSavedEncObj,
1230 Bitstr* bitStreamObj,
1231 enum ISACBandwidth bandwidth) {
1232 int n;
1233 int16_t status;
1234 int16_t realFFT[FRAMESAMPLES_HALF];
1235 int16_t imagFFT[FRAMESAMPLES_HALF];
1236 enum ISACBand band;
1237 const int16_t kAveragePitchGain = 0.0;
1238 /* Store bit-stream object. */
1239 memcpy(bitStreamObj, &ISACSavedEncObj->bitStreamObj, sizeof(Bitstr));
1240
1241 /* Scale FFT coefficients. */
1242 for (n = 0; n < FRAMESAMPLES_HALF; n++) {
1243 realFFT[n] = (int16_t)((float)ISACSavedEncObj->realFFT[n] *
1244 RCU_TRANSCODING_SCALE_UB + 0.5);
1245 imagFFT[n] = (int16_t)((float)ISACSavedEncObj->imagFFT[n] *
1246 RCU_TRANSCODING_SCALE_UB + 0.5);
1247 }
1248
1249 band = (bandwidth == isac12kHz) ? kIsacUpperBand12 : kIsacUpperBand16;
1250 status = WebRtcIsac_EncodeSpec(realFFT, imagFFT, kAveragePitchGain, band,
1251 bitStreamObj);
1252 if (status < 0) {
1253 return status;
1254 } else {
1255 /* Terminate entropy coding */
1256 return WebRtcIsac_EncTerminate(bitStreamObj);
1257 }
1258 }
1259