src/third_party/webrtc/modules/audio_coding/codecs/isac/fix/source/isacfix.c

   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  * isacfix.c
  13  *
  14  * This C file contains the functions for the ISAC API
  15  *
  16  */
  17
  18 #include "webrtc/modules/audio_coding/codecs/isac/fix/interface/isacfix.h"
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22
  23 #include "webrtc/modules/audio_coding/codecs/isac/fix/source/bandwidth_estimator.h"
  24 #include "webrtc/modules/audio_coding/codecs/isac/fix/source/codec.h"
  25 #include "webrtc/modules/audio_coding/codecs/isac/fix/source/entropy_coding.h"
  26 #include "webrtc/modules/audio_coding/codecs/isac/fix/source/filterbank_internal.h"
  27 #include "webrtc/modules/audio_coding/codecs/isac/fix/source/lpc_masking_model.h"
  28 #include "webrtc/modules/audio_coding/codecs/isac/fix/source/structs.h"
  29 #include "webrtc/system_wrappers/interface/cpu_features_wrapper.h"
  30
  31 // Declare function pointers.
  32 FilterMaLoopFix WebRtcIsacfix_FilterMaLoopFix;
  33 Spec2Time WebRtcIsacfix_Spec2Time;
  34 Time2Spec WebRtcIsacfix_Time2Spec;
  35 MatrixProduct1 WebRtcIsacfix_MatrixProduct1;
  36 MatrixProduct2 WebRtcIsacfix_MatrixProduct2;
  37
  38 /**************************************************************************
  39  * WebRtcIsacfix_AssignSize(...)
  40  *
  41  * Functions used when malloc is not allowed
  42  * Returns number of bytes needed to allocate for iSAC struct.
  43  *
  44  */
  45
  46 int16_t WebRtcIsacfix_AssignSize(int *sizeinbytes) {
  47   *sizeinbytes=sizeof(ISACFIX_SubStruct)*2/sizeof(int16_t);
  48   return(0);
  49 }
  50
  51 /***************************************************************************
  52  * WebRtcIsacfix_Assign(...)
  53  *
  54  * Functions used when malloc is not allowed
  55  * Place struct at given address
  56  *
  57  * If successful, Return 0, else Return -1
  58  */
  59
  60 int16_t WebRtcIsacfix_Assign(ISACFIX_MainStruct **inst, void *ISACFIX_inst_Addr) {
  61   if (ISACFIX_inst_Addr!=NULL) {
  62     *inst = (ISACFIX_MainStruct*)ISACFIX_inst_Addr;
  63     (*(ISACFIX_SubStruct**)inst)->errorcode = 0;
  64     (*(ISACFIX_SubStruct**)inst)->initflag = 0;
  65     (*(ISACFIX_SubStruct**)inst)->ISACenc_obj.SaveEnc_ptr = NULL;
  66     return(0);
  67   } else {
  68     return(-1);
  69   }
  70 }
  71
  72
  73 #ifndef ISACFIX_NO_DYNAMIC_MEM
  74
  75 /****************************************************************************
  76  * WebRtcIsacfix_Create(...)
  77  *
  78  * This function creates a ISAC instance, which will contain the state
  79  * information for one coding/decoding channel.
  80  *
  81  * Input:
  82  *      - *ISAC_main_inst   : a pointer to the coder instance.
  83  *
  84  * Return value             :  0 - Ok
  85  *                            -1 - Error
  86  */
  87
  88 int16_t WebRtcIsacfix_Create(ISACFIX_MainStruct **ISAC_main_inst)
  89 {
  90   ISACFIX_SubStruct *tempo;
  91   tempo = malloc(1 * sizeof(ISACFIX_SubStruct));
  92   *ISAC_main_inst = (ISACFIX_MainStruct *)tempo;
  93   if (*ISAC_main_inst!=NULL) {
  94     (*(ISACFIX_SubStruct**)ISAC_main_inst)->errorcode = 0;
  95     (*(ISACFIX_SubStruct**)ISAC_main_inst)->initflag = 0;
  96     (*(ISACFIX_SubStruct**)ISAC_main_inst)->ISACenc_obj.SaveEnc_ptr = NULL;
  97     WebRtcSpl_Init();
  98     return(0);
  99   } else {
 100     return(-1);
 101   }
 102 }
 103
 104
 105 /****************************************************************************
 106  * WebRtcIsacfix_CreateInternal(...)
 107  *
 108  * This function creates the memory that is used to store data in the encoder
 109  *
 110  * Input:
 111  *      - *ISAC_main_inst   : a pointer to the coder instance.
 112  *
 113  * Return value             :  0 - Ok
 114  *                            -1 - Error
 115  */
 116
 117 int16_t WebRtcIsacfix_CreateInternal(ISACFIX_MainStruct *ISAC_main_inst)
 118 {
 119   ISACFIX_SubStruct *ISAC_inst;
 120
 121   /* typecast pointer to real structure */
 122   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 123
 124   /* Allocate memory for storing encoder data */
 125   ISAC_inst->ISACenc_obj.SaveEnc_ptr = malloc(1 * sizeof(ISAC_SaveEncData_t));
 126
 127   if (ISAC_inst->ISACenc_obj.SaveEnc_ptr!=NULL) {
 128     return(0);
 129   } else {
 130     return(-1);
 131   }
 132 }
 133
 134
 135 #endif
 136
 137
 138
 139 /****************************************************************************
 140  * WebRtcIsacfix_Free(...)
 141  *
 142  * This function frees the ISAC instance created at the beginning.
 143  *
 144  * Input:
 145  *      - ISAC_main_inst    : a ISAC instance.
 146  *
 147  * Return value             :  0 - Ok
 148  *                            -1 - Error
 149  */
 150
 151 int16_t WebRtcIsacfix_Free(ISACFIX_MainStruct *ISAC_main_inst)
 152 {
 153   free(ISAC_main_inst);
 154   return(0);
 155 }
 156
 157 /****************************************************************************
 158  * WebRtcIsacfix_FreeInternal(...)
 159  *
 160  * This function frees the internal memory for storing encoder data.
 161  *
 162  * Input:
 163  *       - ISAC_main_inst    : a ISAC instance.
 164  *
 165  * Return value              :  0 - Ok
 166  *                             -1 - Error
 167  */
 168
 169 int16_t WebRtcIsacfix_FreeInternal(ISACFIX_MainStruct *ISAC_main_inst)
 170 {
 171   ISACFIX_SubStruct *ISAC_inst;
 172
 173   /* typecast pointer to real structure */
 174   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 175
 176   /* Release memory */
 177   free(ISAC_inst->ISACenc_obj.SaveEnc_ptr);
 178
 179   return(0);
 180 }
 181
 182 /****************************************************************************
 183  * WebRtcIsacfix_InitNeon(...)
 184  *
 185  * This function initializes function pointers for ARM Neon platform.
 186  */
 187
 188 #if (defined WEBRTC_DETECT_ARM_NEON || defined WEBRTC_ARCH_ARM_NEON)
 189 static void WebRtcIsacfix_InitNeon(void) {
 190   WebRtcIsacfix_AutocorrFix = WebRtcIsacfix_AutocorrNeon;
 191   WebRtcIsacfix_FilterMaLoopFix = WebRtcIsacfix_FilterMaLoopNeon;
 192   WebRtcIsacfix_Spec2Time = WebRtcIsacfix_Spec2TimeNeon;
 193   WebRtcIsacfix_Time2Spec = WebRtcIsacfix_Time2SpecNeon;
 194   WebRtcIsacfix_CalculateResidualEnergy =
 195       WebRtcIsacfix_CalculateResidualEnergyNeon;
 196   WebRtcIsacfix_AllpassFilter2FixDec16 =
 197       WebRtcIsacfix_AllpassFilter2FixDec16Neon;
 198   WebRtcIsacfix_MatrixProduct1 = WebRtcIsacfix_MatrixProduct1Neon;
 199   WebRtcIsacfix_MatrixProduct2 = WebRtcIsacfix_MatrixProduct2Neon;
 200 }
 201 #endif
 202
 203 /****************************************************************************
 204  * WebRtcIsacfix_InitMIPS(...)
 205  *
 206  * This function initializes function pointers for MIPS platform.
 207  */
 208
 209 #if defined(MIPS32_LE)
 210 static void WebRtcIsacfix_InitMIPS(void) {
 211   WebRtcIsacfix_AutocorrFix = WebRtcIsacfix_AutocorrMIPS;
 212   WebRtcIsacfix_FilterMaLoopFix = WebRtcIsacfix_FilterMaLoopMIPS;
 213   WebRtcIsacfix_Spec2Time = WebRtcIsacfix_Spec2TimeMIPS;
 214   WebRtcIsacfix_Time2Spec = WebRtcIsacfix_Time2SpecMIPS;
 215   WebRtcIsacfix_MatrixProduct1 = WebRtcIsacfix_MatrixProduct1MIPS;
 216   WebRtcIsacfix_MatrixProduct2 = WebRtcIsacfix_MatrixProduct2MIPS;
 217 #if defined(MIPS_DSP_R1_LE)
 218   WebRtcIsacfix_AllpassFilter2FixDec16 =
 219       WebRtcIsacfix_AllpassFilter2FixDec16MIPS;
 220   WebRtcIsacfix_HighpassFilterFixDec32 =
 221       WebRtcIsacfix_HighpassFilterFixDec32MIPS;
 222 #endif
 223 #if defined(MIPS_DSP_R2_LE)
 224   WebRtcIsacfix_CalculateResidualEnergy =
 225       WebRtcIsacfix_CalculateResidualEnergyMIPS;
 226 #endif
 227 }
 228 #endif
 229
 230 /****************************************************************************
 231  * WebRtcIsacfix_EncoderInit(...)
 232  *
 233  * This function initializes a ISAC instance prior to the encoder calls.
 234  *
 235  * Input:
 236  *      - ISAC_main_inst    : ISAC instance.
 237  *      - CodingMode        : 0 -> Bit rate and frame length are automatically
 238  *                                 adjusted to available bandwidth on
 239  *                                 transmission channel.
 240  *                            1 -> User sets a frame length and a target bit
 241  *                                 rate which is taken as the maximum short-term
 242  *                                 average bit rate.
 243  *
 244  * Return value             :  0 - Ok
 245  *                            -1 - Error
 246  */
 247
 248 int16_t WebRtcIsacfix_EncoderInit(ISACFIX_MainStruct *ISAC_main_inst,
 249                                   int16_t  CodingMode)
 250 {
 251   int k;
 252   int16_t statusInit;
 253   ISACFIX_SubStruct *ISAC_inst;
 254
 255   statusInit = 0;
 256   /* typecast pointer to rela structure */
 257   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 258
 259   /* flag encoder init */
 260   ISAC_inst->initflag |= 2;
 261
 262   if (CodingMode == 0)
 263     /* Adaptive mode */
 264     ISAC_inst->ISACenc_obj.new_framelength  = INITIAL_FRAMESAMPLES;
 265   else if (CodingMode == 1)
 266     /* Instantaneous mode */
 267     ISAC_inst->ISACenc_obj.new_framelength = 480;    /* default for I-mode */
 268   else {
 269     ISAC_inst->errorcode = ISAC_DISALLOWED_CODING_MODE;
 270     statusInit = -1;
 271   }
 272
 273   ISAC_inst->CodingMode = CodingMode;
 274
 275   WebRtcIsacfix_InitMaskingEnc(&ISAC_inst->ISACenc_obj.maskfiltstr_obj);
 276   WebRtcIsacfix_InitPreFilterbank(&ISAC_inst->ISACenc_obj.prefiltbankstr_obj);
 277   WebRtcIsacfix_InitPitchFilter(&ISAC_inst->ISACenc_obj.pitchfiltstr_obj);
 278   WebRtcIsacfix_InitPitchAnalysis(&ISAC_inst->ISACenc_obj.pitchanalysisstr_obj);
 279
 280
 281   WebRtcIsacfix_InitBandwidthEstimator(&ISAC_inst->bwestimator_obj);
 282   WebRtcIsacfix_InitRateModel(&ISAC_inst->ISACenc_obj.rate_data_obj);
 283
 284
 285   ISAC_inst->ISACenc_obj.buffer_index   = 0;
 286   ISAC_inst->ISACenc_obj.frame_nb    = 0;
 287   ISAC_inst->ISACenc_obj.BottleNeck      = 32000; /* default for I-mode */
 288   ISAC_inst->ISACenc_obj.MaxDelay    = 10;    /* default for I-mode */
 289   ISAC_inst->ISACenc_obj.current_framesamples = 0;
 290   ISAC_inst->ISACenc_obj.s2nr     = 0;
 291   ISAC_inst->ISACenc_obj.MaxBits    = 0;
 292   ISAC_inst->ISACenc_obj.bitstr_seed   = 4447;
 293   ISAC_inst->ISACenc_obj.payloadLimitBytes30  = STREAM_MAXW16_30MS << 1;
 294   ISAC_inst->ISACenc_obj.payloadLimitBytes60  = STREAM_MAXW16_60MS << 1;
 295   ISAC_inst->ISACenc_obj.maxPayloadBytes      = STREAM_MAXW16_60MS << 1;
 296   ISAC_inst->ISACenc_obj.maxRateInBytes       = STREAM_MAXW16_30MS << 1;
 297   ISAC_inst->ISACenc_obj.enforceFrameSize     = 0;
 298
 299   /* Init the bistream data area to zero */
 300   for (k=0; k<STREAM_MAXW16_60MS; k++){
 301     ISAC_inst->ISACenc_obj.bitstr_obj.stream[k] = 0;
 302   }
 303
 304 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
 305   WebRtcIsacfix_InitPostFilterbank(&ISAC_inst->ISACenc_obj.interpolatorstr_obj);
 306 #endif
 307
 308   // Initiaze function pointers.
 309   WebRtcIsacfix_AutocorrFix = WebRtcIsacfix_AutocorrC;
 310   WebRtcIsacfix_FilterMaLoopFix = WebRtcIsacfix_FilterMaLoopC;
 311   WebRtcIsacfix_CalculateResidualEnergy =
 312       WebRtcIsacfix_CalculateResidualEnergyC;
 313   WebRtcIsacfix_AllpassFilter2FixDec16 = WebRtcIsacfix_AllpassFilter2FixDec16C;
 314   WebRtcIsacfix_HighpassFilterFixDec32 = WebRtcIsacfix_HighpassFilterFixDec32C;
 315   WebRtcIsacfix_Time2Spec = WebRtcIsacfix_Time2SpecC;
 316   WebRtcIsacfix_Spec2Time = WebRtcIsacfix_Spec2TimeC;
 317   WebRtcIsacfix_MatrixProduct1 = WebRtcIsacfix_MatrixProduct1C;
 318   WebRtcIsacfix_MatrixProduct2 = WebRtcIsacfix_MatrixProduct2C;
 319
 320 #ifdef WEBRTC_DETECT_ARM_NEON
 321   if ((WebRtc_GetCPUFeaturesARM() & kCPUFeatureNEON) != 0) {
 322     WebRtcIsacfix_InitNeon();
 323   }
 324 #elif defined(WEBRTC_ARCH_ARM_NEON)
 325   WebRtcIsacfix_InitNeon();
 326 #endif
 327
 328 #if defined(MIPS32_LE)
 329   WebRtcIsacfix_InitMIPS();
 330 #endif
 331
 332   return statusInit;
 333 }
 334
 335 /****************************************************************************
 336  * WebRtcIsacfix_Encode(...)
 337  *
 338  * This function encodes 10ms frame(s) and inserts it into a package.
 339  * Input speech length has to be 160 samples (10ms). The encoder buffers those
 340  * 10ms frames until it reaches the chosen Framesize (480 or 960 samples
 341  * corresponding to 30 or 60 ms frames), and then proceeds to the encoding.
 342  *
 343  * Input:
 344  *      - ISAC_main_inst    : ISAC instance.
 345  *      - speechIn          : input speech vector.
 346  *
 347  * Output:
 348  *      - encoded           : the encoded data vector
 349  *
 350  * Return value:
 351  *                          : >0 - Length (in bytes) of coded data
 352  *                          :  0 - The buffer didn't reach the chosen framesize
 353  *                            so it keeps buffering speech samples.
 354  *                          : -1 - Error
 355  */
 356
 357 int16_t WebRtcIsacfix_Encode(ISACFIX_MainStruct *ISAC_main_inst,
 358                              const int16_t    *speechIn,
 359                              uint8_t* encoded)
 360 {
 361   ISACFIX_SubStruct *ISAC_inst;
 362   int16_t stream_len, stream_len_even;
 363 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 364   int k;
 365 #endif
 366
 367   /* typecast pointer to rela structure */
 368   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 369
 370
 371   /* check if encoder initiated */
 372   if ((ISAC_inst->initflag & 2) != 2) {
 373     ISAC_inst->errorcode = ISAC_ENCODER_NOT_INITIATED;
 374     return (-1);
 375   }
 376
 377   stream_len = WebRtcIsacfix_EncodeImpl((int16_t*)speechIn,
 378                                         &ISAC_inst->ISACenc_obj,
 379                                         &ISAC_inst->bwestimator_obj,
 380                                         ISAC_inst->CodingMode);
 381   if (stream_len<0) {
 382     ISAC_inst->errorcode = - stream_len;
 383     return -1;
 384   }
 385
 386   /* One would think that only even stream lengths would make sense here. We do
 387      in fact observe odd lengths, however, and in those cases we copy an extra
 388      byte. */
 389   stream_len_even = stream_len % 2 == 0 ? stream_len : stream_len + 1;
 390
 391 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 392   /* The encoded data vector is supposesd to be big-endian, but our internal
 393      representation is little-endian. So byteswap. */
 394   for (k = 0; k < stream_len_even / 2; ++k) {
 395     uint16_t s = ISAC_inst->ISACenc_obj.bitstr_obj.stream[k];
 396     /* In big-endian, we have... */
 397     encoded[2 * k] = s >> 8;  /* ...most significant byte at low address... */
 398     encoded[2 * k + 1] = s;  /* ...least significant byte at high address. */
 399   }
 400 #else
 401   /* The encoded data vector and our internal representation are both
 402      big-endian. */
 403   memcpy(encoded, ISAC_inst->ISACenc_obj.bitstr_obj.stream, stream_len_even);
 404 #endif
 405
 406
 407
 408   return stream_len;
 409
 410 }
 411
 412
 413
 414
 415 /****************************************************************************
 416  * WebRtcIsacfix_EncodeNb(...)
 417  *
 418  * This function encodes 10ms narrow band (8 kHz sampling) frame(s) and inserts
 419  * it into a package. Input speech length has to be 80 samples (10ms). The encoder
 420  * interpolates into wide-band (16 kHz sampling) buffers those
 421  * 10ms frames until it reaches the chosen Framesize (480 or 960 wide-band samples
 422  * corresponding to 30 or 60 ms frames), and then proceeds to the encoding.
 423  *
 424  * The function is enabled if WEBRTC_ISAC_FIX_NB_CALLS_ENABLED is defined
 425  *
 426  * Input:
 427  *      - ISAC_main_inst    : ISAC instance.
 428  *      - speechIn          : input speech vector.
 429  *
 430  * Output:
 431  *      - encoded           : the encoded data vector
 432  *
 433  * Return value:
 434  *                          : >0 - Length (in bytes) of coded data
 435  *                          :  0 - The buffer didn't reach the chosen framesize
 436  *                            so it keeps buffering speech samples.
 437  *                          : -1 - Error
 438  */
 439 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
 440 int16_t WebRtcIsacfix_EncodeNb(ISACFIX_MainStruct *ISAC_main_inst,
 441                                const int16_t    *speechIn,
 442                                int16_t          *encoded)
 443 {
 444   ISACFIX_SubStruct *ISAC_inst;
 445   int16_t stream_len;
 446   int16_t speechInWB[FRAMESAMPLES_10ms];
 447   int16_t Vector_Word16_1[FRAMESAMPLES_10ms/2];
 448   int16_t Vector_Word16_2[FRAMESAMPLES_10ms/2];
 449
 450   int k;
 451
 452
 453   /* typecast pointer to rela structure */
 454   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 455
 456
 457   /* check if encoder initiated */
 458   if ((ISAC_inst->initflag & 2) != 2) {
 459     ISAC_inst->errorcode = ISAC_ENCODER_NOT_INITIATED;
 460     return (-1);
 461   }
 462
 463
 464   /* Oversample to WB */
 465
 466   /* Form polyphase signals, and compensate for DC offset */
 467   for (k=0;k<FRAMESAMPLES_10ms/2;k++) {
 468     Vector_Word16_1[k] = speechIn[k] + 1;
 469     Vector_Word16_2[k] = speechIn[k];
 470   }
 471   WebRtcIsacfix_FilterAndCombine2(Vector_Word16_1, Vector_Word16_2, speechInWB, &ISAC_inst->ISACenc_obj.interpolatorstr_obj, FRAMESAMPLES_10ms);
 472
 473
 474   /* Encode WB signal */
 475   stream_len = WebRtcIsacfix_EncodeImpl((int16_t*)speechInWB,
 476                                         &ISAC_inst->ISACenc_obj,
 477                                         &ISAC_inst->bwestimator_obj,
 478                                         ISAC_inst->CodingMode);
 479   if (stream_len<0) {
 480     ISAC_inst->errorcode = - stream_len;
 481     return -1;
 482   }
 483
 484
 485   /* convert from bytes to int16_t */
 486 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 487   for (k=0;k<(stream_len+1)>>1;k++) {
 488     encoded[k] = (int16_t)(((uint16_t)(ISAC_inst->ISACenc_obj.bitstr_obj).stream[k] >> 8)
 489                                  | (((ISAC_inst->ISACenc_obj.bitstr_obj).stream[k] & 0x00FF) << 8));
 490   }
 491
 492 #else
 493   WEBRTC_SPL_MEMCPY_W16(encoded, (ISAC_inst->ISACenc_obj.bitstr_obj).stream, (stream_len + 1)>>1);
 494 #endif
 495
 496
 497
 498   return stream_len;
 499 }
 500 #endif  /* WEBRTC_ISAC_FIX_NB_CALLS_ENABLED */
 501
 502
 503 /****************************************************************************
 504  * WebRtcIsacfix_GetNewBitStream(...)
 505  *
 506  * This function returns encoded data, with the recieved bwe-index in the
 507  * stream. It should always return a complete packet, i.e. only called once
 508  * even for 60 msec frames
 509  *
 510  * Input:
 511  *      - ISAC_main_inst    : ISAC instance.
 512  *      - bweIndex          : index of bandwidth estimate to put in new bitstream
 513  *
 514  * Output:
 515  *      - encoded           : the encoded data vector
 516  *
 517  * Return value:
 518  *                          : >0 - Length (in bytes) of coded data
 519  *                          : -1 - Error
 520  */
 521
 522 int16_t WebRtcIsacfix_GetNewBitStream(ISACFIX_MainStruct *ISAC_main_inst,
 523                                       int16_t      bweIndex,
 524                                       float              scale,
 525                                       int16_t        *encoded)
 526 {
 527   ISACFIX_SubStruct *ISAC_inst;
 528   int16_t stream_len;
 529 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 530   int k;
 531 #endif
 532
 533   /* typecast pointer to rela structure */
 534   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 535
 536
 537   /* check if encoder initiated */
 538   if ((ISAC_inst->initflag & 2) != 2) {
 539     ISAC_inst->errorcode = ISAC_ENCODER_NOT_INITIATED;
 540     return (-1);
 541   }
 542
 543   stream_len = WebRtcIsacfix_EncodeStoredData(&ISAC_inst->ISACenc_obj,
 544                                               bweIndex,
 545                                               scale);
 546   if (stream_len<0) {
 547     ISAC_inst->errorcode = - stream_len;
 548     return -1;
 549   }
 550
 551 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 552   for (k=0;k<(stream_len+1)>>1;k++) {
 553     encoded[k] = (int16_t)( ( (uint16_t)(ISAC_inst->ISACenc_obj.bitstr_obj).stream[k] >> 8 )
 554                                   | (((ISAC_inst->ISACenc_obj.bitstr_obj).stream[k] & 0x00FF) << 8));
 555   }
 556
 557 #else
 558   WEBRTC_SPL_MEMCPY_W16(encoded, (ISAC_inst->ISACenc_obj.bitstr_obj).stream, (stream_len + 1)>>1);
 559 #endif
 560
 561   return stream_len;
 562
 563 }
 564
 565
 566
 567 /****************************************************************************
 568  * WebRtcIsacfix_DecoderInit(...)
 569  *
 570  * This function initializes a ISAC instance prior to the decoder calls.
 571  *
 572  * Input:
 573  *      - ISAC_main_inst    : ISAC instance.
 574  *
 575  * Return value
 576  *                          :  0 - Ok
 577  *                            -1 - Error
 578  */
 579
 580 int16_t WebRtcIsacfix_DecoderInit(ISACFIX_MainStruct *ISAC_main_inst)
 581 {
 582   ISACFIX_SubStruct *ISAC_inst;
 583
 584   /* typecast pointer to real structure */
 585   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 586
 587   /* flag decoder init */
 588   ISAC_inst->initflag |= 1;
 589
 590   WebRtcIsacfix_InitMaskingDec(&ISAC_inst->ISACdec_obj.maskfiltstr_obj);
 591   WebRtcIsacfix_InitPostFilterbank(&ISAC_inst->ISACdec_obj.postfiltbankstr_obj);
 592   WebRtcIsacfix_InitPitchFilter(&ISAC_inst->ISACdec_obj.pitchfiltstr_obj);
 593
 594   /* TS */
 595   WebRtcIsacfix_InitPlc( &ISAC_inst->ISACdec_obj.plcstr_obj );
 596
 597
 598 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
 599   WebRtcIsacfix_InitPreFilterbank(&ISAC_inst->ISACdec_obj.decimatorstr_obj);
 600 #endif
 601
 602   return 0;
 603 }
 604
 605
 606 /****************************************************************************
 607  * WebRtcIsacfix_UpdateBwEstimate1(...)
 608  *
 609  * This function updates the estimate of the bandwidth.
 610  *
 611  * Input:
 612  *      - ISAC_main_inst    : ISAC instance.
 613  *      - encoded           : encoded ISAC frame(s).
 614  *      - packet_size       : size of the packet.
 615  *      - rtp_seq_number    : the RTP number of the packet.
 616  *      - arr_ts            : the arrival time of the packet (from NetEq)
 617  *                            in samples.
 618  *
 619  * Return value             :  0 - Ok
 620  *                            -1 - Error
 621  */
 622
 623 int16_t WebRtcIsacfix_UpdateBwEstimate1(ISACFIX_MainStruct *ISAC_main_inst,
 624                                         const uint16_t   *encoded,
 625                                         int32_t          packet_size,
 626                                         uint16_t         rtp_seq_number,
 627                                         uint32_t         arr_ts)
 628 {
 629   ISACFIX_SubStruct *ISAC_inst;
 630   Bitstr_dec streamdata;
 631 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 632   int k;
 633 #endif
 634   int16_t err;
 635
 636   /* typecast pointer to real structure */
 637   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 638
 639   /* Sanity check of packet length */
 640   if (packet_size <= 0) {
 641     /* return error code if the packet length is null or less */
 642     ISAC_inst->errorcode = ISAC_EMPTY_PACKET;
 643     return -1;
 644   } else if (packet_size > (STREAM_MAXW16<<1)) {
 645     /* return error code if length of stream is too long */
 646     ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 647     return -1;
 648   }
 649
 650   /* check if decoder initiated */
 651   if ((ISAC_inst->initflag & 1) != 1) {
 652     ISAC_inst->errorcode = ISAC_DECODER_NOT_INITIATED;
 653     return (-1);
 654   }
 655
 656   streamdata.W_upper = 0xFFFFFFFF;
 657   streamdata.streamval = 0;
 658   streamdata.stream_index = 0;
 659   streamdata.full = 1;
 660
 661 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 662   for (k=0; k<5; k++) {
 663     streamdata.stream[k] = (uint16_t) (((uint16_t)encoded[k] >> 8)|((encoded[k] & 0xFF)<<8));
 664   }
 665 #else
 666   memcpy(streamdata.stream, encoded, 5);
 667 #endif
 668
 669   err = WebRtcIsacfix_EstimateBandwidth(&ISAC_inst->bwestimator_obj,
 670                                         &streamdata,
 671                                         packet_size,
 672                                         rtp_seq_number,
 673                                         0,
 674                                         arr_ts);
 675
 676
 677   if (err < 0)
 678   {
 679     /* return error code if something went wrong */
 680     ISAC_inst->errorcode = -err;
 681     return -1;
 682   }
 683
 684
 685   return 0;
 686 }
 687
 688 /****************************************************************************
 689  * WebRtcIsacfix_UpdateBwEstimate(...)
 690  *
 691  * This function updates the estimate of the bandwidth.
 692  *
 693  * Input:
 694  *      - ISAC_main_inst    : ISAC instance.
 695  *      - encoded           : encoded ISAC frame(s).
 696  *      - packet_size       : size of the packet.
 697  *      - rtp_seq_number    : the RTP number of the packet.
 698  *      - send_ts           : Send Time Stamp from RTP header
 699  *      - arr_ts            : the arrival time of the packet (from NetEq)
 700  *                            in samples.
 701  *
 702  * Return value             :  0 - Ok
 703  *                            -1 - Error
 704  */
 705
 706 int16_t WebRtcIsacfix_UpdateBwEstimate(ISACFIX_MainStruct *ISAC_main_inst,
 707                                        const uint16_t   *encoded,
 708                                        int32_t          packet_size,
 709                                        uint16_t         rtp_seq_number,
 710                                        uint32_t         send_ts,
 711                                        uint32_t         arr_ts)
 712 {
 713   ISACFIX_SubStruct *ISAC_inst;
 714   Bitstr_dec streamdata;
 715 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 716   int k;
 717 #endif
 718   int16_t err;
 719
 720   /* typecast pointer to real structure */
 721   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 722
 723   /* Sanity check of packet length */
 724   if (packet_size <= 0) {
 725     /* return error code if the packet length is null  or less */
 726     ISAC_inst->errorcode = ISAC_EMPTY_PACKET;
 727     return -1;
 728   } else if (packet_size > (STREAM_MAXW16<<1)) {
 729     /* return error code if length of stream is too long */
 730     ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 731     return -1;
 732   }
 733
 734   /* check if decoder initiated */
 735   if ((ISAC_inst->initflag & 1) != 1) {
 736     ISAC_inst->errorcode = ISAC_DECODER_NOT_INITIATED;
 737     return (-1);
 738   }
 739
 740   streamdata.W_upper = 0xFFFFFFFF;
 741   streamdata.streamval = 0;
 742   streamdata.stream_index = 0;
 743   streamdata.full = 1;
 744
 745 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 746   for (k=0; k<5; k++) {
 747     streamdata.stream[k] = (uint16_t) ((encoded[k] >> 8)|((encoded[k] & 0xFF)<<8));
 748   }
 749 #else
 750   memcpy(streamdata.stream, encoded, 5);
 751 #endif
 752
 753   err = WebRtcIsacfix_EstimateBandwidth(&ISAC_inst->bwestimator_obj,
 754                                         &streamdata,
 755                                         packet_size,
 756                                         rtp_seq_number,
 757                                         send_ts,
 758                                         arr_ts);
 759
 760   if (err < 0)
 761   {
 762     /* return error code if something went wrong */
 763     ISAC_inst->errorcode = -err;
 764     return -1;
 765   }
 766
 767
 768   return 0;
 769 }
 770
 771 /****************************************************************************
 772  * WebRtcIsacfix_Decode(...)
 773  *
 774  * This function decodes a ISAC frame. Output speech length
 775  * will be a multiple of 480 samples: 480 or 960 samples,
 776  * depending on the framesize (30 or 60 ms).
 777  *
 778  * Input:
 779  *      - ISAC_main_inst    : ISAC instance.
 780  *      - encoded           : encoded ISAC frame(s)
 781  *      - len               : bytes in encoded vector
 782  *
 783  * Output:
 784  *      - decoded           : The decoded vector
 785  *
 786  * Return value             : >0 - number of samples in decoded vector
 787  *                            -1 - Error
 788  */
 789
 790
 791 int16_t WebRtcIsacfix_Decode(ISACFIX_MainStruct *ISAC_main_inst,
 792                              const uint16_t   *encoded,
 793                              int16_t          len,
 794                              int16_t          *decoded,
 795                              int16_t     *speechType)
 796 {
 797   ISACFIX_SubStruct *ISAC_inst;
 798   /* number of samples (480 or 960), output from decoder */
 799   /* that were actually used in the encoder/decoder (determined on the fly) */
 800   int16_t     number_of_samples;
 801 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 802   int k;
 803 #endif
 804   int16_t declen = 0;
 805
 806   /* typecast pointer to real structure */
 807   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 808
 809   /* check if decoder initiated */
 810   if ((ISAC_inst->initflag & 1) != 1) {
 811     ISAC_inst->errorcode = ISAC_DECODER_NOT_INITIATED;
 812     return (-1);
 813   }
 814
 815   /* Sanity check of packet length */
 816   if (len <= 0) {
 817     /* return error code if the packet length is null  or less */
 818     ISAC_inst->errorcode = ISAC_EMPTY_PACKET;
 819     return -1;
 820   } else if (len > (STREAM_MAXW16<<1)) {
 821     /* return error code if length of stream is too long */
 822     ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 823     return -1;
 824   }
 825
 826   ISAC_inst->ISACdec_obj.bitstr_obj.stream_size = (len + 1) >> 1;
 827
 828   /* convert bitstream from int16_t to bytes */
 829 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 830   for (k=0; k<(len>>1); k++) {
 831     (ISAC_inst->ISACdec_obj.bitstr_obj).stream[k] = (uint16_t) ((encoded[k] >> 8)|((encoded[k] & 0xFF)<<8));
 832   }
 833   if (len & 0x0001)
 834     (ISAC_inst->ISACdec_obj.bitstr_obj).stream[k] = (uint16_t) ((encoded[k] & 0xFF)<<8);
 835 #endif
 836
 837   /* added for NetEq purposes (VAD/DTX related) */
 838   *speechType=1;
 839
 840   declen = WebRtcIsacfix_DecodeImpl(decoded,&ISAC_inst->ISACdec_obj, &number_of_samples);
 841
 842   if (declen < 0) {
 843     /* Some error inside the decoder */
 844     ISAC_inst->errorcode = -declen;
 845     memset(decoded, 0, sizeof(int16_t) * MAX_FRAMESAMPLES);
 846     return -1;
 847   }
 848
 849   /* error check */
 850
 851   if (declen & 0x0001) {
 852     if (len != declen && len != declen + (((ISAC_inst->ISACdec_obj.bitstr_obj).stream[declen>>1]) & 0x00FF) ) {
 853       ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 854       memset(decoded, 0, sizeof(int16_t) * number_of_samples);
 855       return -1;
 856     }
 857   } else {
 858     if (len != declen && len != declen + (((ISAC_inst->ISACdec_obj.bitstr_obj).stream[declen>>1]) >> 8) ) {
 859       ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 860       memset(decoded, 0, sizeof(int16_t) * number_of_samples);
 861       return -1;
 862     }
 863   }
 864
 865   return number_of_samples;
 866 }
 867
 868
 869
 870
 871
 872 /****************************************************************************
 873  * WebRtcIsacfix_DecodeNb(...)
 874  *
 875  * This function decodes a ISAC frame in narrow-band (8 kHz sampling).
 876  * Output speech length will be a multiple of 240 samples: 240 or 480 samples,
 877  * depending on the framesize (30 or 60 ms).
 878  *
 879  * The function is enabled if WEBRTC_ISAC_FIX_NB_CALLS_ENABLED is defined
 880  *
 881  * Input:
 882  *      - ISAC_main_inst    : ISAC instance.
 883  *      - encoded           : encoded ISAC frame(s)
 884  *      - len               : bytes in encoded vector
 885  *
 886  * Output:
 887  *      - decoded           : The decoded vector
 888  *
 889  * Return value             : >0 - number of samples in decoded vector
 890  *                            -1 - Error
 891  */
 892
 893 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
 894 int16_t WebRtcIsacfix_DecodeNb(ISACFIX_MainStruct *ISAC_main_inst,
 895                                const uint16_t   *encoded,
 896                                int16_t          len,
 897                                int16_t          *decoded,
 898                                int16_t    *speechType)
 899 {
 900   ISACFIX_SubStruct *ISAC_inst;
 901   /* twice the number of samples (480 or 960), output from decoder */
 902   /* that were actually used in the encoder/decoder (determined on the fly) */
 903   int16_t     number_of_samples;
 904 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 905   int k;
 906 #endif
 907   int16_t declen = 0;
 908   int16_t dummy[FRAMESAMPLES/2];
 909
 910
 911   /* typecast pointer to real structure */
 912   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
 913
 914   /* check if decoder initiated */
 915   if ((ISAC_inst->initflag & 1) != 1) {
 916     ISAC_inst->errorcode = ISAC_DECODER_NOT_INITIATED;
 917     return (-1);
 918   }
 919
 920   if (len == 0)
 921   {  /* return error code if the packet length is null */
 922
 923     ISAC_inst->errorcode = ISAC_EMPTY_PACKET;
 924     return -1;
 925   }
 926
 927   ISAC_inst->ISACdec_obj.bitstr_obj.stream_size = (len + 1) >> 1;
 928
 929   /* convert bitstream from int16_t to bytes */
 930 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 931   for (k=0; k<(len>>1); k++) {
 932     (ISAC_inst->ISACdec_obj.bitstr_obj).stream[k] = (uint16_t) ((encoded[k] >> 8)|((encoded[k] & 0xFF)<<8));
 933   }
 934   if (len & 0x0001)
 935     (ISAC_inst->ISACdec_obj.bitstr_obj).stream[k] = (uint16_t) ((encoded[k] & 0xFF)<<8);
 936 #endif
 937
 938   /* added for NetEq purposes (VAD/DTX related) */
 939   *speechType=1;
 940
 941   declen = WebRtcIsacfix_DecodeImpl(decoded,&ISAC_inst->ISACdec_obj, &number_of_samples);
 942
 943   if (declen < 0) {
 944     /* Some error inside the decoder */
 945     ISAC_inst->errorcode = -declen;
 946     memset(decoded, 0, sizeof(int16_t) * FRAMESAMPLES);
 947     return -1;
 948   }
 949
 950   /* error check */
 951
 952   if (declen & 0x0001) {
 953     if (len != declen && len != declen + (((ISAC_inst->ISACdec_obj.bitstr_obj).stream[declen>>1]) & 0x00FF) ) {
 954       ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 955       memset(decoded, 0, sizeof(int16_t) * number_of_samples);
 956       return -1;
 957     }
 958   } else {
 959     if (len != declen && len != declen + (((ISAC_inst->ISACdec_obj.bitstr_obj).stream[declen>>1]) >> 8) ) {
 960       ISAC_inst->errorcode = ISAC_LENGTH_MISMATCH;
 961       memset(decoded, 0, sizeof(int16_t) * number_of_samples);
 962       return -1;
 963     }
 964   }
 965
 966   WebRtcIsacfix_SplitAndFilter2(decoded, decoded, dummy, &ISAC_inst->ISACdec_obj.decimatorstr_obj);
 967
 968   if (number_of_samples>FRAMESAMPLES) {
 969     WebRtcIsacfix_SplitAndFilter2(decoded + FRAMESAMPLES, decoded + FRAMESAMPLES/2,
 970                                   dummy, &ISAC_inst->ISACdec_obj.decimatorstr_obj);
 971   }
 972
 973   return number_of_samples/2;
 974 }
 975 #endif /* WEBRTC_ISAC_FIX_NB_CALLS_ENABLED */
 976
 977
 978 /****************************************************************************
 979  * WebRtcIsacfix_DecodePlcNb(...)
 980  *
 981  * This function conducts PLC for ISAC frame(s) in narrow-band (8kHz sampling).
 982  * Output speech length  will be "240*noOfLostFrames" samples
 983  * that is equevalent of "30*noOfLostFrames" millisecond.
 984  *
 985  * The function is enabled if WEBRTC_ISAC_FIX_NB_CALLS_ENABLED is defined
 986  *
 987  * Input:
 988  *      - ISAC_main_inst    : ISAC instance.
 989  *      - noOfLostFrames    : Number of PLC frames (240 sample=30ms) to produce
 990  *
 991  * Output:
 992  *      - decoded           : The decoded vector
 993  *
 994  * Return value             : >0 - number of samples in decoded PLC vector
 995  *                            -1 - Error
 996  */
 997
 998 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
 999 int16_t WebRtcIsacfix_DecodePlcNb(ISACFIX_MainStruct *ISAC_main_inst,
1000                                   int16_t          *decoded,
1001                                   int16_t noOfLostFrames )
1002 {
1003   int16_t no_of_samples, declen, k, ok;
1004   int16_t outframeNB[FRAMESAMPLES];
1005   int16_t outframeWB[FRAMESAMPLES];
1006   int16_t dummy[FRAMESAMPLES/2];
1007
1008
1009   ISACFIX_SubStruct *ISAC_inst;
1010   /* typecast pointer to real structure */
1011   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1012
1013   /* Limit number of frames to two = 60 msec. Otherwise we exceed data vectors */
1014   if (noOfLostFrames > 2){
1015     noOfLostFrames = 2;
1016   }
1017
1018   k = 0;
1019   declen = 0;
1020   while( noOfLostFrames > 0 )
1021   {
1022     ok = WebRtcIsacfix_DecodePlcImpl( outframeWB, &ISAC_inst->ISACdec_obj, &no_of_samples );
1023     if(ok)
1024       return -1;
1025
1026     WebRtcIsacfix_SplitAndFilter2(outframeWB, &(outframeNB[k*240]), dummy, &ISAC_inst->ISACdec_obj.decimatorstr_obj);
1027
1028     declen += no_of_samples;
1029     noOfLostFrames--;
1030     k++;
1031   }
1032
1033   declen>>=1;
1034
1035   for (k=0;k<declen;k++) {
1036     decoded[k] = outframeNB[k];
1037   }
1038
1039   return declen;
1040 }
1041 #endif /* WEBRTC_ISAC_FIX_NB_CALLS_ENABLED */
1042
1043
1044
1045
1046 /****************************************************************************
1047  * WebRtcIsacfix_DecodePlc(...)
1048  *
1049  * This function conducts PLC for ISAC frame(s) in wide-band (16kHz sampling).
1050  * Output speech length  will be "480*noOfLostFrames" samples
1051  * that is equevalent of "30*noOfLostFrames" millisecond.
1052  *
1053  * Input:
1054  *      - ISAC_main_inst    : ISAC instance.
1055  *      - noOfLostFrames    : Number of PLC frames (480sample = 30ms)
1056  *                                to produce
1057  *
1058  * Output:
1059  *      - decoded           : The decoded vector
1060  *
1061  * Return value             : >0 - number of samples in decoded PLC vector
1062  *                            -1 - Error
1063  */
1064
1065 int16_t WebRtcIsacfix_DecodePlc(ISACFIX_MainStruct *ISAC_main_inst,
1066                                 int16_t          *decoded,
1067                                 int16_t noOfLostFrames)
1068 {
1069
1070   int16_t no_of_samples, declen, k, ok;
1071   int16_t outframe16[MAX_FRAMESAMPLES];
1072
1073   ISACFIX_SubStruct *ISAC_inst;
1074   /* typecast pointer to real structure */
1075   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1076
1077   /* Limit number of frames to two = 60 msec. Otherwise we exceed data vectors */
1078   if (noOfLostFrames > 2) {
1079     noOfLostFrames = 2;
1080   }
1081   k = 0;
1082   declen = 0;
1083   while( noOfLostFrames > 0 )
1084   {
1085     ok = WebRtcIsacfix_DecodePlcImpl( &(outframe16[k*480]), &ISAC_inst->ISACdec_obj, &no_of_samples );
1086     if(ok)
1087       return -1;
1088     declen += no_of_samples;
1089     noOfLostFrames--;
1090     k++;
1091   }
1092
1093   for (k=0;k<declen;k++) {
1094     decoded[k] = outframe16[k];
1095   }
1096
1097   return declen;
1098 }
1099
1100
1101 /****************************************************************************
1102  * WebRtcIsacfix_Control(...)
1103  *
1104  * This function sets the limit on the short-term average bit rate and the
1105  * frame length. Should be used only in Instantaneous mode.
1106  *
1107  * Input:
1108  *      - ISAC_main_inst    : ISAC instance.
1109  *      - rate              : limit on the short-term average bit rate,
1110  *                            in bits/second (between 10000 and 32000)
1111  *      - framesize         : number of milliseconds per frame (30 or 60)
1112  *
1113  * Return value             : 0  - ok
1114  *                            -1 - Error
1115  */
1116
1117 int16_t WebRtcIsacfix_Control(ISACFIX_MainStruct *ISAC_main_inst,
1118                               int16_t          rate,
1119                               int16_t          framesize)
1120 {
1121   ISACFIX_SubStruct *ISAC_inst;
1122   /* typecast pointer to real structure */
1123   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1124
1125   if (ISAC_inst->CodingMode == 0)
1126   {
1127     /* in adaptive mode */
1128     ISAC_inst->errorcode = ISAC_MODE_MISMATCH;
1129     return -1;
1130   }
1131
1132
1133   if (rate >= 10000 && rate <= 32000)
1134     ISAC_inst->ISACenc_obj.BottleNeck = rate;
1135   else {
1136     ISAC_inst->errorcode = ISAC_DISALLOWED_BOTTLENECK;
1137     return -1;
1138   }
1139
1140
1141
1142   if (framesize  == 30 || framesize == 60)
1143     ISAC_inst->ISACenc_obj.new_framelength = (FS/1000) * framesize;
1144   else {
1145     ISAC_inst->errorcode = ISAC_DISALLOWED_FRAME_LENGTH;
1146     return -1;
1147   }
1148
1149   return 0;
1150 }
1151
1152
1153 /****************************************************************************
1154  * WebRtcIsacfix_ControlBwe(...)
1155  *
1156  * This function sets the initial values of bottleneck and frame-size if
1157  * iSAC is used in channel-adaptive mode. Through this API, users can
1158  * enforce a frame-size for all values of bottleneck. Then iSAC will not
1159  * automatically change the frame-size.
1160  *
1161  *
1162  * Input:
1163  *  - ISAC_main_inst : ISAC instance.
1164  *      - rateBPS           : initial value of bottleneck in bits/second
1165  *                            10000 <= rateBPS <= 32000 is accepted
1166  *                            For default bottleneck set rateBPS = 0
1167  *      - frameSizeMs       : number of milliseconds per frame (30 or 60)
1168  *      - enforceFrameSize  : 1 to enforce the given frame-size through out
1169  *                            the adaptation process, 0 to let iSAC change
1170  *                            the frame-size if required.
1171  *
1172  * Return value    : 0  - ok
1173  *         -1 - Error
1174  */
1175
1176 int16_t WebRtcIsacfix_ControlBwe(ISACFIX_MainStruct *ISAC_main_inst,
1177                                  int16_t rateBPS,
1178                                  int16_t frameSizeMs,
1179                                  int16_t enforceFrameSize)
1180 {
1181   ISACFIX_SubStruct *ISAC_inst;
1182   /* Typecast pointer to real structure */
1183   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1184
1185   /* check if encoder initiated */
1186   if ((ISAC_inst->initflag & 2) != 2) {
1187     ISAC_inst->errorcode = ISAC_ENCODER_NOT_INITIATED;
1188     return (-1);
1189   }
1190
1191   /* Check that we are in channel-adaptive mode, otherwise, return -1 */
1192   if (ISAC_inst->CodingMode != 0) {
1193     ISAC_inst->errorcode = ISAC_MODE_MISMATCH;
1194     return (-1);
1195   }
1196
1197   /* Set struct variable if enforceFrameSize is set. ISAC will then keep the */
1198   /* chosen frame size.                                                      */
1199   ISAC_inst->ISACenc_obj.enforceFrameSize = (enforceFrameSize != 0)? 1:0;
1200
1201   /* Set initial rate, if value between 10000 and 32000,                */
1202   /* if rateBPS is 0, keep the default initial bottleneck value (15000) */
1203   if ((rateBPS >= 10000) && (rateBPS <= 32000)) {
1204     ISAC_inst->bwestimator_obj.sendBwAvg = (((uint32_t)rateBPS) << 7);
1205   } else if (rateBPS != 0) {
1206     ISAC_inst->errorcode = ISAC_DISALLOWED_BOTTLENECK;
1207     return -1;
1208   }
1209
1210   /* Set initial framesize. If enforceFrameSize is set the frame size will not change */
1211   if ((frameSizeMs  == 30) || (frameSizeMs == 60)) {
1212     ISAC_inst->ISACenc_obj.new_framelength = (FS/1000) * frameSizeMs;
1213   } else {
1214     ISAC_inst->errorcode = ISAC_DISALLOWED_FRAME_LENGTH;
1215     return -1;
1216   }
1217
1218   return 0;
1219 }
1220
1221
1222
1223
1224
1225 /****************************************************************************
1226  * WebRtcIsacfix_GetDownLinkBwIndex(...)
1227  *
1228  * This function returns index representing the Bandwidth estimate from
1229  * other side to this side.
1230  *
1231  * Input:
1232  *      - ISAC_main_inst: iSAC struct
1233  *
1234  * Output:
1235  *      - rateIndex     : Bandwidth estimate to transmit to other side.
1236  *
1237  */
1238
1239 int16_t WebRtcIsacfix_GetDownLinkBwIndex(ISACFIX_MainStruct* ISAC_main_inst,
1240                                          int16_t*     rateIndex)
1241 {
1242   ISACFIX_SubStruct *ISAC_inst;
1243
1244   /* typecast pointer to real structure */
1245   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1246
1247   /* Call function to get Bandwidth Estimate */
1248   *rateIndex = WebRtcIsacfix_GetDownlinkBwIndexImpl(&ISAC_inst->bwestimator_obj);
1249
1250   return 0;
1251 }
1252
1253
1254 /****************************************************************************
1255  * WebRtcIsacfix_UpdateUplinkBw(...)
1256  *
1257  * This function takes an index representing the Bandwidth estimate from
1258  * this side to other side and updates BWE.
1259  *
1260  * Input:
1261  *      - ISAC_main_inst: iSAC struct
1262  *      - rateIndex     : Bandwidth estimate from other side.
1263  *
1264  */
1265
1266 int16_t WebRtcIsacfix_UpdateUplinkBw(ISACFIX_MainStruct* ISAC_main_inst,
1267                                      int16_t     rateIndex)
1268 {
1269   int16_t err = 0;
1270   ISACFIX_SubStruct *ISAC_inst;
1271
1272   /* typecast pointer to real structure */
1273   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1274
1275   /* Call function to update BWE with received Bandwidth Estimate */
1276   err = WebRtcIsacfix_UpdateUplinkBwRec(&ISAC_inst->bwestimator_obj, rateIndex);
1277   if (err < 0) {
1278     ISAC_inst->errorcode = -err;
1279     return (-1);
1280   }
1281
1282   return 0;
1283 }
1284
1285 /****************************************************************************
1286  * WebRtcIsacfix_ReadFrameLen(...)
1287  *
1288  * This function returns the length of the frame represented in the packet.
1289  *
1290  * Input:
1291  *      - encoded       : Encoded bitstream
1292  *
1293  * Output:
1294  *      - frameLength   : Length of frame in packet (in samples)
1295  *
1296  */
1297
1298 int16_t WebRtcIsacfix_ReadFrameLen(const int16_t* encoded,
1299                                    int16_t* frameLength)
1300 {
1301   Bitstr_dec streamdata;
1302 #ifndef WEBRTC_ARCH_BIG_ENDIAN
1303   int k;
1304 #endif
1305   int16_t err;
1306
1307   streamdata.W_upper = 0xFFFFFFFF;
1308   streamdata.streamval = 0;
1309   streamdata.stream_index = 0;
1310   streamdata.full = 1;
1311
1312 #ifndef WEBRTC_ARCH_BIG_ENDIAN
1313   for (k=0; k<5; k++) {
1314     streamdata.stream[k] = (uint16_t) (((uint16_t)encoded[k] >> 8)|((encoded[k] & 0xFF)<<8));
1315   }
1316 #else
1317   memcpy(streamdata.stream, encoded, 5);
1318 #endif
1319
1320   /* decode frame length */
1321   err = WebRtcIsacfix_DecodeFrameLen(&streamdata, frameLength);
1322   if (err<0)  // error check
1323     return err;
1324
1325   return 0;
1326 }
1327
1328
1329 /****************************************************************************
1330  * WebRtcIsacfix_ReadBwIndex(...)
1331  *
1332  * This function returns the index of the Bandwidth estimate from the bitstream.
1333  *
1334  * Input:
1335  *      - encoded       : Encoded bitstream
1336  *
1337  * Output:
1338  *      - frameLength   : Length of frame in packet (in samples)
1339  *      - rateIndex     : Bandwidth estimate in bitstream
1340  *
1341  */
1342
1343 int16_t WebRtcIsacfix_ReadBwIndex(const int16_t* encoded,
1344                                   int16_t* rateIndex)
1345 {
1346   Bitstr_dec streamdata;
1347 #ifndef WEBRTC_ARCH_BIG_ENDIAN
1348   int k;
1349 #endif
1350   int16_t err;
1351
1352   streamdata.W_upper = 0xFFFFFFFF;
1353   streamdata.streamval = 0;
1354   streamdata.stream_index = 0;
1355   streamdata.full = 1;
1356
1357 #ifndef WEBRTC_ARCH_BIG_ENDIAN
1358   for (k=0; k<5; k++) {
1359     streamdata.stream[k] = (uint16_t) (((uint16_t)encoded[k] >> 8)|((encoded[k] & 0xFF)<<8));
1360   }
1361 #else
1362   memcpy(streamdata.stream, encoded, 5);
1363 #endif
1364
1365   /* decode frame length, needed to get to the rateIndex in the bitstream */
1366   err = WebRtcIsacfix_DecodeFrameLen(&streamdata, rateIndex);
1367   if (err<0)  // error check
1368     return err;
1369
1370   /* decode BW estimation */
1371   err = WebRtcIsacfix_DecodeSendBandwidth(&streamdata, rateIndex);
1372   if (err<0)  // error check
1373     return err;
1374
1375   return 0;
1376 }
1377
1378
1379
1380
1381 /****************************************************************************
1382  * WebRtcIsacfix_GetErrorCode(...)
1383  *
1384  * This function can be used to check the error code of an iSAC instance. When
1385  * a function returns -1 a error code will be set for that instance. The
1386  * function below extract the code of the last error that occured in the
1387  * specified instance.
1388  *
1389  * Input:
1390  *      - ISAC_main_inst    : ISAC instance
1391  *
1392  * Return value             : Error code
1393  */
1394
1395 int16_t WebRtcIsacfix_GetErrorCode(ISACFIX_MainStruct *ISAC_main_inst)
1396 {
1397   ISACFIX_SubStruct *ISAC_inst;
1398   /* typecast pointer to real structure */
1399   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1400
1401   return ISAC_inst->errorcode;
1402 }
1403
1404
1405
1406 /****************************************************************************
1407  * WebRtcIsacfix_GetUplinkBw(...)
1408  *
1409  * This function returns the inst quantized iSAC send bitrate
1410  *
1411  * Input:
1412  *      - ISAC_main_inst    : iSAC instance
1413  *
1414  * Return value             : bitrate
1415  */
1416
1417 int32_t WebRtcIsacfix_GetUplinkBw(ISACFIX_MainStruct *ISAC_main_inst)
1418 {
1419   ISACFIX_SubStruct *ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1420   BwEstimatorstr * bw = (BwEstimatorstr*)&(ISAC_inst->bwestimator_obj);
1421
1422   return (int32_t) WebRtcIsacfix_GetUplinkBandwidth(bw);
1423 }
1424
1425 /****************************************************************************
1426  * WebRtcIsacfix_GetNewFrameLen(...)
1427  *
1428  * This function return the next frame length (in samples) of iSAC.
1429  *
1430  * Input:
1431  *      - ISAC_main_inst    : iSAC instance
1432  *
1433  * Return value             :  frame lenght in samples
1434  */
1435
1436 int16_t WebRtcIsacfix_GetNewFrameLen(ISACFIX_MainStruct *ISAC_main_inst)
1437 {
1438   ISACFIX_SubStruct *ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1439   return ISAC_inst->ISACenc_obj.new_framelength;
1440 }
1441
1442
1443 /****************************************************************************
1444  * WebRtcIsacfix_SetMaxPayloadSize(...)
1445  *
1446  * This function sets a limit for the maximum payload size of iSAC. The same
1447  * value is used both for 30 and 60 msec packets.
1448  * The absolute max will be valid until next time the function is called.
1449  * NOTE! This function may override the function WebRtcIsacfix_SetMaxRate()
1450  *
1451  * Input:
1452  *      - ISAC_main_inst    : iSAC instance
1453  *      - maxPayloadBytes   : maximum size of the payload in bytes
1454  *                            valid values are between 100 and 400 bytes
1455  *
1456  *
1457  * Return value             : 0 if sucessful
1458  *                           -1 if error happens
1459  */
1460
1461 int16_t WebRtcIsacfix_SetMaxPayloadSize(ISACFIX_MainStruct *ISAC_main_inst,
1462                                         int16_t maxPayloadBytes)
1463 {
1464   ISACFIX_SubStruct *ISAC_inst;
1465
1466   /* typecast pointer to real structure */
1467   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1468
1469   if((maxPayloadBytes < 100) || (maxPayloadBytes > 400))
1470   {
1471     /* maxPayloadBytes is out of valid range */
1472     return -1;
1473   }
1474   else
1475   {
1476     /* Set new absolute max, which will not change unless this function
1477        is called again with a new value */
1478     ISAC_inst->ISACenc_obj.maxPayloadBytes = maxPayloadBytes;
1479
1480     /* Set new maximum values for 30 and 60 msec packets */
1481     if (maxPayloadBytes < ISAC_inst->ISACenc_obj.maxRateInBytes) {
1482       ISAC_inst->ISACenc_obj.payloadLimitBytes30 = maxPayloadBytes;
1483     } else {
1484       ISAC_inst->ISACenc_obj.payloadLimitBytes30 = ISAC_inst->ISACenc_obj.maxRateInBytes;
1485     }
1486
1487     if ( maxPayloadBytes < (ISAC_inst->ISACenc_obj.maxRateInBytes << 1)) {
1488       ISAC_inst->ISACenc_obj.payloadLimitBytes60 = maxPayloadBytes;
1489     } else {
1490       ISAC_inst->ISACenc_obj.payloadLimitBytes60 = (ISAC_inst->ISACenc_obj.maxRateInBytes << 1);
1491     }
1492   }
1493   return 0;
1494 }
1495
1496
1497 /****************************************************************************
1498  * WebRtcIsacfix_SetMaxRate(...)
1499  *
1500  * This function sets the maximum rate which the codec may not exceed for a
1501  * singel packet. The maximum rate is set in bits per second.
1502  * The codec has an absolute maximum rate of 53400 bits per second (200 bytes
1503  * per 30 msec).
1504  * It is possible to set a maximum rate between 32000 and 53400 bits per second.
1505  *
1506  * The rate limit is valid until next time the function is called.
1507  *
1508  * NOTE! Packet size will never go above the value set if calling
1509  * WebRtcIsacfix_SetMaxPayloadSize() (default max packet size is 400 bytes).
1510  *
1511  * Input:
1512  *      - ISAC_main_inst    : iSAC instance
1513  *      - maxRateInBytes    : maximum rate in bits per second,
1514  *                            valid values are 32000 to 53400 bits
1515  *
1516  * Return value             : 0 if sucessful
1517  *                           -1 if error happens
1518  */
1519
1520 int16_t WebRtcIsacfix_SetMaxRate(ISACFIX_MainStruct *ISAC_main_inst,
1521                                  int32_t maxRate)
1522 {
1523   ISACFIX_SubStruct *ISAC_inst;
1524   int16_t maxRateInBytes;
1525
1526   /* typecast pointer to real structure */
1527   ISAC_inst = (ISACFIX_SubStruct *)ISAC_main_inst;
1528
1529   if((maxRate < 32000) || (maxRate > 53400))
1530   {
1531     /* maxRate is out of valid range */
1532     return -1;
1533   }
1534   else
1535   {
1536     /* Calculate maximum number of bytes per 30 msec packets for the given
1537        maximum rate. Multiply with 30/1000 to get number of bits per 30 msec,
1538        divide by 8 to get number of bytes per 30 msec:
1539        maxRateInBytes = floor((maxRate * 30/1000) / 8); */
1540     maxRateInBytes = (int16_t)( WebRtcSpl_DivW32W16ResW16(WEBRTC_SPL_MUL(maxRate, 3), 800) );
1541
1542     /* Store the value for usage in the WebRtcIsacfix_SetMaxPayloadSize-function */
1543     ISAC_inst->ISACenc_obj.maxRateInBytes = maxRateInBytes;
1544
1545     /* For 30 msec packets: if the new limit is below the maximum
1546        payload size, set a new limit */
1547     if (maxRateInBytes < ISAC_inst->ISACenc_obj.maxPayloadBytes) {
1548       ISAC_inst->ISACenc_obj.payloadLimitBytes30 = maxRateInBytes;
1549     } else {
1550       ISAC_inst->ISACenc_obj.payloadLimitBytes30 = ISAC_inst->ISACenc_obj.maxPayloadBytes;
1551     }
1552
1553     /* For 60 msec packets: if the new limit (times 2) is below the
1554        maximum payload size, set a new limit */
1555     if ( (maxRateInBytes << 1) < ISAC_inst->ISACenc_obj.maxPayloadBytes) {
1556       ISAC_inst->ISACenc_obj.payloadLimitBytes60 = (maxRateInBytes << 1);
1557     } else {
1558       ISAC_inst->ISACenc_obj.payloadLimitBytes60 = ISAC_inst->ISACenc_obj.maxPayloadBytes;
1559     }
1560   }
1561
1562   return 0;
1563 }
1564
1565
1566
1567 /****************************************************************************
1568  * WebRtcIsacfix_version(...)
1569  *
1570  * This function returns the version number.
1571  *
1572  * Output:
1573  *      - version  : Pointer to character string
1574  *
1575  */
1576
1577 void WebRtcIsacfix_version(char *version)
1578 {
1579   strcpy(version, "3.6.0");
1580 }