| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| /**************************************************************************************** |
| Portions of this file are derived from the following 3GPP standard: |
| |
| 3GPP TS 26.073 |
| ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec |
| Available from http://www.3gpp.org |
| |
| (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC) |
| Permission to distribute, modify and use this file under the standard license |
| terms listed above has been obtained from the copyright holder. |
| ****************************************************************************************/ |
| /* |
| ------------------------------------------------------------------------------ |
| |
| |
| |
| Pathname: ./audio/gsm-amr/c/src/cod_amr.c |
| Funtions: cod_amr_init |
| cod_amr_reset |
| cod_amr_exit |
| cod_amr_first |
| cod_amr |
| |
| Date: 06/09/2000 |
| |
| ------------------------------------------------------------------------------ |
| REVISION HISTORY |
| |
| Description: Made changes based on comments from the review meeting. |
| |
| Description: Synchronized file with UMTS version 3.2.0. Updated coding |
| template. Removed unnecessary include files. |
| |
| Description: Added initialization of the overflow flag in cod_amr_init() |
| and in cod_amr_reset(). This overflow flag is now part of |
| the cod_amrState structure. |
| |
| Description: Cleaned up INCLUDES. removed inclusion of basic_op.h and repeat |
| inclusion of copy.h |
| |
| Description: Updated function call to dtx_enc |
| |
| Description: For cod_amr_first() and cod_amr() |
| 1. Replaced copy() function with memcpy() |
| |
| Description: Replaced OSCL mem type functions and eliminated include |
| files that now are chosen by OSCL definitions |
| |
| Description: Replaced "int" and/or "char" with OSCL defined types. |
| |
| Description: |
| |
| ------------------------------------------------------------------------------ |
| MODULE DESCRIPTION |
| |
| These functions comprise the main encoder routine operating on a frame basis. |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; INCLUDES |
| ----------------------------------------------------------------------------*/ |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "cod_amr.h" |
| #include "typedef.h" |
| #include "cnst.h" |
| #include "copy.h" |
| #include "qua_gain.h" |
| #include "lpc.h" |
| #include "lsp.h" |
| #include "pre_big.h" |
| #include "ol_ltp.h" |
| #include "p_ol_wgh.h" |
| #include "spreproc.h" |
| #include "cl_ltp.h" |
| #include "pred_lt.h" |
| #include "spstproc.h" |
| #include "cbsearch.h" |
| #include "gain_q.h" |
| #include "convolve.h" |
| #include "ton_stab.h" |
| #include "vad.h" |
| #include "dtx_enc.h" |
| |
| /*---------------------------------------------------------------------------- |
| ; MACROS |
| ; Define module specific macros here |
| ----------------------------------------------------------------------------*/ |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; DEFINES |
| ; Include all pre-processor statements here. Include conditional |
| ; compile variables also. |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL FUNCTION DEFINITIONS |
| ; Function Prototype declaration |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL VARIABLE DEFINITIONS |
| ; Variable declaration - defined here and used outside this module |
| ----------------------------------------------------------------------------*/ |
| |
| /* Spectral expansion factors */ |
| |
| static const Word16 gamma1[M] = |
| { |
| 30802, 28954, 27217, 25584, 24049, |
| 22606, 21250, 19975, 18777, 17650 |
| }; |
| |
| /* gamma1 differs for the 12k2 coder */ |
| static const Word16 gamma1_12k2[M] = |
| { |
| 29491, 26542, 23888, 21499, 19349, |
| 17414, 15672, 14105, 12694, 11425 |
| }; |
| |
| static const Word16 gamma2[M] = |
| { |
| 19661, 11797, 7078, 4247, 2548, |
| 1529, 917, 550, 330, 198 |
| }; |
| |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: cod_amr_init |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| state = pointer to a pointer to a structure of type cod_amrState |
| |
| Outputs: |
| Structure pointed to by the pointer pointed to by state is |
| initialized to its reset value |
| state points to the allocated memory |
| |
| Returns: |
| Returns 0 if memory was successfully initialized, |
| otherwise returns -1. |
| |
| Global Variables Used: |
| None. |
| |
| Local Variables Needed: |
| None. |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| This function allocates memory and initializes state variables. |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None. |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| cod_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 |
| |
| ------------------------------------------------------------------------------ |
| PSEUDO-CODE |
| |
| int cod_amr_init (cod_amrState **state, Flag dtx) |
| { |
| cod_amrState* s; |
| |
| if (state == (cod_amrState **) NULL){ |
| fprintf(stderr, "cod_amr_init: invalid parameter\n"); |
| return -1; |
| } |
| *state = NULL; |
| |
| // allocate memory |
| if ((s= (cod_amrState *) malloc(sizeof(cod_amrState))) == NULL){ |
| fprintf(stderr, "cod_amr_init: can not malloc state structure\n"); |
| return -1; |
| } |
| |
| s->lpcSt = NULL; |
| s->lspSt = NULL; |
| s->clLtpSt = NULL; |
| s->gainQuantSt = NULL; |
| s->pitchOLWghtSt = NULL; |
| s->tonStabSt = NULL; |
| s->vadSt = NULL; |
| s->dtx_encSt = NULL; |
| s->dtx = dtx; |
| |
| // Init sub states |
| if (cl_ltp_init(&s->clLtpSt) || |
| lsp_init(&s->lspSt) || |
| gainQuant_init(&s->gainQuantSt) || |
| p_ol_wgh_init(&s->pitchOLWghtSt) || |
| ton_stab_init(&s->tonStabSt) || |
| #ifndef VAD2 |
| vad1_init(&s->vadSt) || |
| #else |
| vad2_init(&s->vadSt) || |
| #endif |
| dtx_enc_init(&s->dtx_encSt) || |
| lpc_init(&s->lpcSt)) { |
| cod_amr_exit(&s); |
| return -1; |
| } |
| |
| cod_amr_reset(s); |
| |
| *state = s; |
| |
| return 0; |
| } |
| |
| ------------------------------------------------------------------------------ |
| RESOURCES USED [optional] |
| |
| When the code is written for a specific target processor the |
| the resources used should be documented below. |
| |
| HEAP MEMORY USED: x bytes |
| |
| STACK MEMORY USED: x bytes |
| |
| CLOCK CYCLES: (cycle count equation for this function) + (variable |
| used to represent cycle count for each subroutine |
| called) |
| where: (cycle count variable) = cycle count for [subroutine |
| name] |
| |
| ------------------------------------------------------------------------------ |
| CAUTION [optional] |
| [State any special notes, constraints or cautions for users of this function] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| Word16 cod_amr_init(cod_amrState **state, Flag dtx) |
| { |
| cod_amrState* s; |
| |
| if (state == (cod_amrState **) NULL) |
| { |
| /* fprint(stderr, "cod_amr_init: invalid parameter\n"); */ |
| return(-1); |
| } |
| *state = NULL; |
| |
| /* allocate memory */ |
| if ((s = (cod_amrState *) malloc(sizeof(cod_amrState))) == NULL) |
| { |
| /* fprint(stderr, "cod_amr_init: |
| can not malloc state structure\n"); */ |
| return(-1); |
| } |
| |
| s->lpcSt = NULL; |
| s->lspSt = NULL; |
| s->clLtpSt = NULL; |
| s->gainQuantSt = NULL; |
| s->pitchOLWghtSt = NULL; |
| s->tonStabSt = NULL; |
| s->vadSt = NULL; |
| s->dtx_encSt = NULL; |
| s->dtx = dtx; |
| |
| /* Initialize overflow Flag */ |
| |
| s->overflow = 0; |
| |
| |
| /* Init sub states */ |
| if (cl_ltp_init(&s->clLtpSt) || |
| lsp_init(&s->lspSt) || |
| gainQuant_init(&s->gainQuantSt) || |
| p_ol_wgh_init(&s->pitchOLWghtSt) || |
| ton_stab_init(&s->tonStabSt) || |
| #ifndef VAD2 |
| vad1_init(&s->vadSt) || |
| #else |
| vad2_init(&s->vadSt) || |
| #endif |
| dtx_enc_init(&s->dtx_encSt) || |
| lpc_init(&s->lpcSt)) |
| { |
| cod_amr_exit(&s); |
| return(-1); |
| } |
| |
| cod_amr_reset(s); |
| |
| *state = s; |
| |
| return(0); |
| } |
| |
| /****************************************************************************/ |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: cod_amr_reset |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| state = pointer to a structure of type cod_amrState |
| |
| Outputs: |
| Structure pointed to by state is initialized to initial values. |
| |
| Returns: |
| Returns 0 if memory was successfully initialized, |
| otherwise returns -1. |
| |
| Global Variables Used: |
| None. |
| |
| Local Variables Needed: |
| None. |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| This function resets the state memory for cod_amr. |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None. |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| cod_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 |
| |
| ------------------------------------------------------------------------------ |
| PSEUDO-CODE |
| |
| int cod_amr_reset (cod_amrState *st) |
| { |
| Word16 i; |
| |
| if (st == (cod_amrState *) NULL){ |
| fprintf(stderr, "cod_amr_reset: invalid parameter\n"); |
| return -1; |
| } |
| |
| *-----------------------------------------------------------------------* |
| * Initialize pointers to speech vector. * |
| *-----------------------------------------------------------------------* |
| |
| st->new_speech = st->old_speech + L_TOTAL - L_FRAME; // New speech |
| |
| st->speech = st->new_speech - L_NEXT; // Present frame |
| |
| st->p_window = st->old_speech + L_TOTAL - L_WINDOW; // For LPC window |
| st->p_window_12k2 = st->p_window - L_NEXT; // EFR LPC window: no lookahead |
| |
| // Initialize static pointers |
| |
| st->wsp = st->old_wsp + PIT_MAX; |
| st->exc = st->old_exc + PIT_MAX + L_INTERPOL; |
| st->zero = st->ai_zero + MP1; |
| st->error = st->mem_err + M; |
| st->h1 = &st->hvec[L_SUBFR]; |
| |
| // Static vectors to zero |
| |
| Set_zero(st->old_speech, L_TOTAL); |
| Set_zero(st->old_exc, PIT_MAX + L_INTERPOL); |
| Set_zero(st->old_wsp, PIT_MAX); |
| Set_zero(st->mem_syn, M); |
| Set_zero(st->mem_w, M); |
| Set_zero(st->mem_w0, M); |
| Set_zero(st->mem_err, M); |
| Set_zero(st->zero, L_SUBFR); |
| Set_zero(st->hvec, L_SUBFR); // set to zero "h1[-L_SUBFR..-1]" |
| |
| // OL LTP states |
| for (i = 0; i < 5; i++) |
| { |
| st->old_lags[i] = 40; |
| } |
| |
| // Reset lpc states |
| lpc_reset(st->lpcSt); |
| |
| // Reset lsp states |
| lsp_reset(st->lspSt); |
| |
| // Reset clLtp states |
| cl_ltp_reset(st->clLtpSt); |
| |
| gainQuant_reset(st->gainQuantSt); |
| |
| p_ol_wgh_reset(st->pitchOLWghtSt); |
| |
| ton_stab_reset(st->tonStabSt); |
| |
| #ifndef VAD2 |
| vad1_reset(st->vadSt); |
| #else |
| vad2_reset(st->vadSt); |
| #endif |
| |
| dtx_enc_reset(st->dtx_encSt); |
| |
| st->sharp = SHARPMIN; |
| |
| return 0; |
| } |
| |
| ------------------------------------------------------------------------------ |
| RESOURCES USED [optional] |
| |
| When the code is written for a specific target processor the |
| the resources used should be documented below. |
| |
| HEAP MEMORY USED: x bytes |
| |
| STACK MEMORY USED: x bytes |
| |
| CLOCK CYCLES: (cycle count equation for this function) + (variable |
| used to represent cycle count for each subroutine |
| called) |
| where: (cycle count variable) = cycle count for [subroutine |
| name] |
| |
| ------------------------------------------------------------------------------ |
| CAUTION [optional] |
| [State any special notes, constraints or cautions for users of this function] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| Word16 cod_amr_reset(cod_amrState *st) |
| { |
| Word16 i; |
| |
| if (st == (cod_amrState *) NULL) |
| { |
| /* fprint(stderr, "cod_amr_reset: invalid parameter\n"); */ |
| return(-1); |
| } |
| |
| /*-----------------------------------------------------------------------* |
| * Initialize pointers to speech vector. * |
| *-----------------------------------------------------------------------*/ |
| |
| st->new_speech = st->old_speech + L_TOTAL - L_FRAME; /* New speech */ |
| |
| st->speech = st->new_speech - L_NEXT; /* Present frame */ |
| |
| st->p_window = st->old_speech + L_TOTAL - L_WINDOW; /* For LPC window */ |
| st->p_window_12k2 = st->p_window - L_NEXT; /* EFR LPC window: no lookahead */ |
| |
| /* Initialize static pointers */ |
| |
| st->wsp = st->old_wsp + PIT_MAX; |
| st->exc = st->old_exc + PIT_MAX + L_INTERPOL; |
| st->zero = st->ai_zero + MP1; |
| st->error = st->mem_err + M; |
| st->h1 = &st->hvec[L_SUBFR]; |
| |
| /* Initialize overflow Flag */ |
| |
| st->overflow = 0; |
| |
| /* Static vectors to zero */ |
| memset(st->old_speech, 0, sizeof(Word16)*L_TOTAL); |
| memset(st->old_exc, 0, sizeof(Word16)*(PIT_MAX + L_INTERPOL)); |
| memset(st->old_wsp, 0, sizeof(Word16)*PIT_MAX); |
| memset(st->mem_syn, 0, sizeof(Word16)*M); |
| memset(st->mem_w, 0, sizeof(Word16)*M); |
| memset(st->mem_w0, 0, sizeof(Word16)*M); |
| memset(st->mem_err, 0, sizeof(Word16)*M); |
| memset(st->zero, 0, sizeof(Word16)*L_SUBFR); |
| memset(st->hvec, 0, sizeof(Word16)*L_SUBFR); /* set to zero "h1[-L_SUBFR..-1]" */ |
| |
| /* OL LTP states */ |
| for (i = 0; i < 5; i++) |
| { |
| st->old_lags[i] = 40; |
| } |
| |
| /* Reset lpc states */ |
| lpc_reset(st->lpcSt); |
| |
| /* Reset lsp states */ |
| lsp_reset(st->lspSt); |
| |
| /* Reset clLtp states */ |
| cl_ltp_reset(st->clLtpSt); |
| |
| gainQuant_reset(st->gainQuantSt); |
| |
| p_ol_wgh_reset(st->pitchOLWghtSt); |
| |
| ton_stab_reset(st->tonStabSt); |
| |
| #ifndef VAD2 |
| vad1_reset(st->vadSt); |
| #else |
| vad2_reset(st->vadSt); |
| #endif |
| |
| dtx_enc_reset(st->dtx_encSt); |
| |
| st->sharp = SHARPMIN; |
| |
| return(0); |
| } |
| |
| /****************************************************************************/ |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: cod_amr_exit |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| state = pointer to a pointer to a structure of type cod_amrState |
| |
| Outputs: |
| state points to a NULL address |
| |
| Returns: |
| None. |
| |
| Global Variables Used: |
| None. |
| |
| Local Variables Needed: |
| None. |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| This function frees the memory used for state memory. |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None. |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| cod_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 |
| |
| ------------------------------------------------------------------------------ |
| PSEUDO-CODE |
| |
| void cod_amr_exit (cod_amrState **state) |
| { |
| if (state == NULL || *state == NULL) |
| return; |
| |
| // dealloc members |
| lpc_exit(&(*state)->lpcSt); |
| lsp_exit(&(*state)->lspSt); |
| gainQuant_exit(&(*state)->gainQuantSt); |
| cl_ltp_exit(&(*state)->clLtpSt); |
| p_ol_wgh_exit(&(*state)->pitchOLWghtSt); |
| ton_stab_exit(&(*state)->tonStabSt); |
| #ifndef VAD2 |
| vad1_exit(&(*state)->vadSt); |
| #else |
| vad2_exit(&(*state)->vadSt); |
| #endif |
| dtx_enc_exit(&(*state)->dtx_encSt); |
| |
| // deallocate memory |
| free(*state); |
| *state = NULL; |
| |
| return; |
| } |
| |
| ------------------------------------------------------------------------------ |
| RESOURCES USED [optional] |
| |
| When the code is written for a specific target processor the |
| the resources used should be documented below. |
| |
| HEAP MEMORY USED: x bytes |
| |
| STACK MEMORY USED: x bytes |
| |
| CLOCK CYCLES: (cycle count equation for this function) + (variable |
| used to represent cycle count for each subroutine |
| called) |
| where: (cycle count variable) = cycle count for [subroutine |
| name] |
| |
| ------------------------------------------------------------------------------ |
| CAUTION [optional] |
| [State any special notes, constraints or cautions for users of this function] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| void cod_amr_exit(cod_amrState **state) |
| { |
| if (state == NULL || *state == NULL) |
| { |
| return; |
| } |
| |
| /* dealloc members */ |
| lpc_exit(&(*state)->lpcSt); |
| lsp_exit(&(*state)->lspSt); |
| gainQuant_exit(&(*state)->gainQuantSt); |
| cl_ltp_exit(&(*state)->clLtpSt); |
| p_ol_wgh_exit(&(*state)->pitchOLWghtSt); |
| ton_stab_exit(&(*state)->tonStabSt); |
| #ifndef VAD2 |
| vad1_exit(&(*state)->vadSt); |
| #else |
| vad2_exit(&(*state)->vadSt); |
| #endif |
| dtx_enc_exit(&(*state)->dtx_encSt); |
| |
| /* deallocate memory */ |
| free(*state); // BX |
| *state = NULL; |
| |
| return; |
| } |
| |
| /****************************************************************************/ |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: cod_amr_first |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| st = pointer to a structure of type cod_amrState |
| new_speech = pointer to buffer of length L_FRAME that contains |
| the speech input (Word16) |
| |
| Outputs: |
| The structure of type cod_amrState pointed to by st is updated. |
| |
| Returns: |
| return_value = 0 (int) |
| |
| Global Variables Used: |
| None. |
| |
| Local Variables Needed: |
| None. |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| This function copes with look-ahead and calls cod_amr. |
| No input argument are passed to this function. However, before |
| calling this function, 40 new speech data should be copied to the |
| vector new_speech[]. This is a global pointer which is declared in |
| this file (it points to the end of speech buffer minus 200). |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None. |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| cod_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 |
| |
| ------------------------------------------------------------------------------ |
| PSEUDO-CODE |
| |
| int cod_amr_first(cod_amrState *st, // i/o : State struct |
| Word16 new_speech[]) // i : speech input (L_FRAME) |
| { |
| Copy(new_speech,&st->new_speech[-L_NEXT], L_NEXT); |
| // Copy(new_speech,st->new_speech,L_FRAME); |
| |
| return 0; |
| } |
| |
| ------------------------------------------------------------------------------ |
| RESOURCES USED [optional] |
| |
| When the code is written for a specific target processor the |
| the resources used should be documented below. |
| |
| HEAP MEMORY USED: x bytes |
| |
| STACK MEMORY USED: x bytes |
| |
| CLOCK CYCLES: (cycle count equation for this function) + (variable |
| used to represent cycle count for each subroutine |
| called) |
| where: (cycle count variable) = cycle count for [subroutine |
| name] |
| |
| ------------------------------------------------------------------------------ |
| CAUTION [optional] |
| [State any special notes, constraints or cautions for users of this function] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| Word16 cod_amr_first(cod_amrState *st, /* i/o : State struct */ |
| Word16 new_speech[]) /* i : speech input (L_FRAME) */ |
| { |
| |
| memcpy(&st->new_speech[-L_NEXT], new_speech, L_NEXT*sizeof(Word16)); |
| |
| /* Copy(new_speech,st->new_speech,L_FRAME); */ |
| |
| return(0); |
| } |
| |
| /****************************************************************************/ |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: cod_amr |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| st = pointer to a structure of type cod_amrState |
| mode = AMR mode of type enum Mode |
| new_speech = pointer to buffer of length L_FRAME that contains |
| the speech input of type Word16 |
| ana = pointer to the analysis parameters of type Word16 |
| usedMode = pointer to the used mode of type enum Mode |
| synth = pointer to a buffer containing the local synthesis speech of |
| type Word16 |
| |
| Outputs: |
| The structure of type cod_amrState pointed to by st is updated. |
| The analysis parameter buffer pointed to by ana is updated. |
| The value pointed to by usedMode is updated. |
| The local synthesis speech buffer pointed to by synth is updated. |
| |
| Returns: |
| return_value = 0 (int) |
| |
| Global Variables Used: |
| None. |
| |
| Local Variables Needed: |
| None. |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| This function is the main encoder routine. It is called every 20 ms speech |
| frame, operating on the newly read 160 speech samples. It performs the |
| principle encoding functions to produce the set of encoded parameters |
| which include the LSP, adaptive codebook, and fixed codebook |
| quantization indices (addresses and gains). |
| |
| Before calling this function, 160 new speech data should be copied to the |
| vector new_speech[]. This is a global pointer which is declared in |
| this file (it points to the end of speech buffer minus 160). |
| |
| The outputs of the function are: |
| ana[]: vector of analysis parameters. |
| synth[]: Local synthesis speech (for debugging purposes) |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None. |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| cod_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 |
| |
| ------------------------------------------------------------------------------ |
| PSEUDO-CODE |
| |
| int cod_amr( |
| cod_amrState *st, // i/o : State struct |
| enum Mode mode, // i : AMR mode |
| Word16 new_speech[], // i : speech input (L_FRAME) |
| Word16 ana[], // o : Analysis parameters |
| enum Mode *usedMode, // o : used mode |
| Word16 synth[] // o : Local synthesis |
| ) |
| { |
| // LPC coefficients |
| Word16 A_t[(MP1) * 4]; // A(z) unquantized for the 4 subframes |
| Word16 Aq_t[(MP1) * 4]; // A(z) quantized for the 4 subframes |
| Word16 *A, *Aq; // Pointer on A_t and Aq_t |
| Word16 lsp_new[M]; |
| |
| // Other vectors |
| Word16 xn[L_SUBFR]; // Target vector for pitch search |
| Word16 xn2[L_SUBFR]; // Target vector for codebook search |
| Word16 code[L_SUBFR]; // Fixed codebook excitation |
| Word16 y1[L_SUBFR]; // Filtered adaptive excitation |
| Word16 y2[L_SUBFR]; // Filtered fixed codebook excitation |
| Word16 gCoeff[6]; // Correlations between xn, y1, & y2: |
| Word16 res[L_SUBFR]; // Short term (LPC) prediction residual |
| Word16 res2[L_SUBFR]; // Long term (LTP) prediction residual |
| |
| // Vector and scalars needed for the MR475 |
| Word16 xn_sf0[L_SUBFR]; // Target vector for pitch search |
| Word16 y2_sf0[L_SUBFR]; // Filtered codebook innovation |
| Word16 code_sf0[L_SUBFR]; // Fixed codebook excitation |
| Word16 h1_sf0[L_SUBFR]; // The impulse response of sf0 |
| Word16 mem_syn_save[M]; // Filter memory |
| Word16 mem_w0_save[M]; // Filter memory |
| Word16 mem_err_save[M]; // Filter memory |
| Word16 sharp_save; // Sharpening |
| Word16 evenSubfr; // Even subframe indicator |
| Word16 T0_sf0 = 0; // Integer pitch lag of sf0 |
| Word16 T0_frac_sf0 = 0; // Fractional pitch lag of sf0 |
| Word16 i_subfr_sf0 = 0; // Position in exc[] for sf0 |
| Word16 gain_pit_sf0; // Quantized pitch gain for sf0 |
| Word16 gain_code_sf0; // Quantized codebook gain for sf0 |
| |
| // Scalars |
| Word16 i_subfr, subfrNr; |
| Word16 T_op[L_FRAME/L_FRAME_BY2]; |
| Word16 T0, T0_frac; |
| Word16 gain_pit, gain_code; |
| |
| // Flags |
| Word16 lsp_flag = 0; // indicates resonance in LPC filter |
| Word16 gp_limit; // pitch gain limit value |
| Word16 vad_flag; // VAD decision flag |
| Word16 compute_sid_flag; // SID analysis flag |
| |
| Copy(new_speech, st->new_speech, L_FRAME); |
| |
| *usedMode = mode; |
| |
| // DTX processing |
| if (st->dtx) |
| { // no test() call since this if is only in simulation env |
| // Find VAD decision |
| |
| #ifdef VAD2 |
| vad_flag = vad2 (st->new_speech, st->vadSt); |
| vad_flag = vad2 (st->new_speech+80, st->vadSt) || vad_flag; |
| #else |
| vad_flag = vad1(st->vadSt, st->new_speech); |
| #endif |
| |
| // NB! usedMode may change here |
| compute_sid_flag = tx_dtx_handler(st->dtx_encSt, |
| vad_flag, |
| usedMode); |
| } |
| else |
| { |
| compute_sid_flag = 0; |
| } |
| |
| *------------------------------------------------------------------------* |
| * - Perform LPC analysis: * |
| * * autocorrelation + lag windowing * |
| * * Levinson-durbin algorithm to find a[] * |
| * * convert a[] to lsp[] * |
| * * quantize and code the LSPs * |
| * * find the interpolated LSPs and convert to a[] for all * |
| * subframes (both quantized and unquantized) * |
| *------------------------------------------------------------------------* |
| |
| // LP analysis |
| lpc(st->lpcSt, mode, st->p_window, st->p_window_12k2, A_t); |
| |
| |
| // From A(z) to lsp. LSP quantization and interpolation |
| lsp(st->lspSt, mode, *usedMode, A_t, Aq_t, lsp_new, &ana); |
| |
| |
| // Buffer lsp's and energy |
| dtx_buffer(st->dtx_encSt, |
| lsp_new, |
| st->new_speech); |
| |
| // Check if in DTX mode |
| if (sub(*usedMode, MRDTX) == 0) |
| { |
| dtx_enc(st->dtx_encSt, |
| compute_sid_flag, |
| st->lspSt->qSt, |
| st->gainQuantSt->gc_predSt, |
| &ana); |
| |
| Set_zero(st->old_exc, PIT_MAX + L_INTERPOL); |
| Set_zero(st->mem_w0, M); |
| Set_zero(st->mem_err, M); |
| Set_zero(st->zero, L_SUBFR); |
| Set_zero(st->hvec, L_SUBFR); // set to zero "h1[-L_SUBFR..-1]" |
| // Reset lsp states |
| lsp_reset(st->lspSt); |
| Copy(lsp_new, st->lspSt->lsp_old, M); |
| Copy(lsp_new, st->lspSt->lsp_old_q, M); |
| |
| // Reset clLtp states |
| cl_ltp_reset(st->clLtpSt); |
| st->sharp = SHARPMIN; |
| } |
| else |
| { |
| // check resonance in the filter |
| lsp_flag = check_lsp(st->tonStabSt, st->lspSt->lsp_old); |
| } |
| |
| *----------------------------------------------------------------------* |
| * - Find the weighted input speech w_sp[] for the whole speech frame * |
| * - Find the open-loop pitch delay for first 2 subframes * |
| * - Set the range for searching closed-loop pitch in 1st subframe * |
| * - Find the open-loop pitch delay for last 2 subframes * |
| *----------------------------------------------------------------------* |
| |
| #ifdef VAD2 |
| if (st->dtx) |
| { // no test() call since this if is only in simulation env |
| st->vadSt->L_Rmax = 0; |
| st->vadSt->L_R0 = 0; |
| } |
| #endif |
| for(subfrNr = 0, i_subfr = 0; |
| subfrNr < L_FRAME/L_FRAME_BY2; |
| subfrNr++, i_subfr += L_FRAME_BY2) |
| { |
| // Pre-processing on 80 samples |
| pre_big(mode, gamma1, gamma1_12k2, gamma2, A_t, i_subfr, st->speech, |
| st->mem_w, st->wsp); |
| |
| if ((sub(mode, MR475) != 0) && (sub(mode, MR515) != 0)) |
| { |
| // Find open loop pitch lag for two subframes |
| ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[i_subfr], |
| &T_op[subfrNr], st->old_lags, st->ol_gain_flg, subfrNr, |
| st->dtx); |
| } |
| } |
| |
| if ((sub(mode, MR475) == 0) || (sub(mode, MR515) == 0)) |
| { |
| // Find open loop pitch lag for ONE FRAME ONLY |
| // search on 160 samples |
| |
| ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[0], &T_op[0], |
| st->old_lags, st->ol_gain_flg, 1, st->dtx); |
| T_op[1] = T_op[0]; |
| } |
| |
| #ifdef VAD2 |
| if (st->dtx) |
| { // no test() call since this if is only in simulation env |
| LTP_flag_update(st->vadSt, mode); |
| } |
| #endif |
| |
| #ifndef VAD2 |
| // run VAD pitch detection |
| if (st->dtx) |
| { // no test() call since this if is only in simulation env |
| vad_pitch_detection(st->vadSt, T_op); |
| } |
| #endif |
| |
| if (sub(*usedMode, MRDTX) == 0) |
| { |
| goto the_end; |
| } |
| |
| *------------------------------------------------------------------------* |
| * Loop for every subframe in the analysis frame * |
| *------------------------------------------------------------------------* |
| * To find the pitch and innovation parameters. The subframe size is * |
| * L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times. * |
| * - find the weighted LPC coefficients * |
| * - find the LPC residual signal res[] * |
| * - compute the target signal for pitch search * |
| * - compute impulse response of weighted synthesis filter (h1[]) * |
| * - find the closed-loop pitch parameters * |
| * - encode the pitch dealy * |
| * - update the impulse response h1[] by including fixed-gain pitch * |
| * - find target vector for codebook search * |
| * - codebook search * |
| * - encode codebook address * |
| * - VQ of pitch and codebook gains * |
| * - find synthesis speech * |
| * - update states of weighting filter * |
| *------------------------------------------------------------------------* |
| |
| A = A_t; // pointer to interpolated LPC parameters |
| Aq = Aq_t; // pointer to interpolated quantized LPC parameters |
| |
| evenSubfr = 0; |
| subfrNr = -1; |
| for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) |
| { |
| subfrNr = add(subfrNr, 1); |
| evenSubfr = sub(1, evenSubfr); |
| |
| // Save states for the MR475 mode |
| if ((evenSubfr != 0) && (sub(*usedMode, MR475) == 0)) |
| { |
| Copy(st->mem_syn, mem_syn_save, M); |
| Copy(st->mem_w0, mem_w0_save, M); |
| Copy(st->mem_err, mem_err_save, M); |
| sharp_save = st->sharp; |
| } |
| |
| *-----------------------------------------------------------------* |
| * - Preprocessing of subframe * |
| *-----------------------------------------------------------------* |
| if (sub(*usedMode, MR475) != 0) |
| { |
| subframePreProc(*usedMode, gamma1, gamma1_12k2, |
| gamma2, A, Aq, &st->speech[i_subfr], |
| st->mem_err, st->mem_w0, st->zero, |
| st->ai_zero, &st->exc[i_subfr], |
| st->h1, xn, res, st->error); |
| } |
| else |
| { // MR475 |
| subframePreProc(*usedMode, gamma1, gamma1_12k2, |
| gamma2, A, Aq, &st->speech[i_subfr], |
| st->mem_err, mem_w0_save, st->zero, |
| st->ai_zero, &st->exc[i_subfr], |
| st->h1, xn, res, st->error); |
| |
| // save impulse response (modified in cbsearch) |
| if (evenSubfr != 0) |
| { |
| Copy (st->h1, h1_sf0, L_SUBFR); |
| } |
| } |
| |
| // copy the LP residual (res2 is modified in the CL LTP search) |
| Copy (res, res2, L_SUBFR); |
| |
| |
| *-----------------------------------------------------------------* |
| * - Closed-loop LTP search * |
| *-----------------------------------------------------------------* |
| cl_ltp(st->clLtpSt, st->tonStabSt, *usedMode, i_subfr, T_op, st->h1, |
| &st->exc[i_subfr], res2, xn, lsp_flag, xn2, y1, |
| &T0, &T0_frac, &gain_pit, gCoeff, &ana, |
| &gp_limit); |
| |
| // update LTP lag history |
| if ((subfrNr == 0) && (st->ol_gain_flg[0] > 0)) |
| { |
| st->old_lags[1] = T0; |
| } |
| |
| if ((sub(subfrNr, 3) == 0) && (st->ol_gain_flg[1] > 0)) |
| { |
| st->old_lags[0] = T0; |
| } |
| |
| |
| *-----------------------------------------------------------------* |
| * - Inovative codebook search (find index and gain) * |
| *-----------------------------------------------------------------* |
| cbsearch(xn2, st->h1, T0, st->sharp, gain_pit, res2, |
| code, y2, &ana, *usedMode, subfrNr); |
| |
| *------------------------------------------------------* |
| * - Quantization of gains. * |
| *------------------------------------------------------* |
| gainQuant(st->gainQuantSt, *usedMode, res, &st->exc[i_subfr], code, |
| xn, xn2, y1, y2, gCoeff, evenSubfr, gp_limit, |
| &gain_pit_sf0, &gain_code_sf0, |
| &gain_pit, &gain_code, &ana); |
| |
| // update gain history |
| update_gp_clipping(st->tonStabSt, gain_pit); |
| |
| if (sub(*usedMode, MR475) != 0) |
| { |
| // Subframe Post Porcessing |
| subframePostProc(st->speech, *usedMode, i_subfr, gain_pit, |
| gain_code, Aq, synth, xn, code, y1, y2, st->mem_syn, |
| st->mem_err, st->mem_w0, st->exc, &st->sharp); |
| } |
| else |
| { |
| if (evenSubfr != 0) |
| { |
| i_subfr_sf0 = i_subfr; |
| Copy(xn, xn_sf0, L_SUBFR); |
| Copy(y2, y2_sf0, L_SUBFR); |
| Copy(code, code_sf0, L_SUBFR); |
| T0_sf0 = T0; |
| T0_frac_sf0 = T0_frac; |
| |
| // Subframe Post Porcessing |
| subframePostProc(st->speech, *usedMode, i_subfr, gain_pit, |
| gain_code, Aq, synth, xn, code, y1, y2, |
| mem_syn_save, st->mem_err, mem_w0_save, |
| st->exc, &st->sharp); |
| st->sharp = sharp_save; |
| } |
| else |
| { |
| // update both subframes for the MR475 |
| |
| // Restore states for the MR475 mode |
| Copy(mem_err_save, st->mem_err, M); |
| |
| // re-build excitation for sf 0 |
| Pred_lt_3or6(&st->exc[i_subfr_sf0], T0_sf0, T0_frac_sf0, |
| L_SUBFR, 1); |
| Convolve(&st->exc[i_subfr_sf0], h1_sf0, y1, L_SUBFR); |
| |
| Aq -= MP1; |
| subframePostProc(st->speech, *usedMode, i_subfr_sf0, |
| gain_pit_sf0, gain_code_sf0, Aq, |
| synth, xn_sf0, code_sf0, y1, y2_sf0, |
| st->mem_syn, st->mem_err, st->mem_w0, st->exc, |
| &sharp_save); // overwrites sharp_save |
| Aq += MP1; |
| |
| // re-run pre-processing to get xn right (needed by postproc) |
| // (this also reconstructs the unsharpened h1 for sf 1) |
| subframePreProc(*usedMode, gamma1, gamma1_12k2, |
| gamma2, A, Aq, &st->speech[i_subfr], |
| st->mem_err, st->mem_w0, st->zero, |
| st->ai_zero, &st->exc[i_subfr], |
| st->h1, xn, res, st->error); |
| |
| // re-build excitation sf 1 (changed if lag < L_SUBFR) |
| Pred_lt_3or6(&st->exc[i_subfr], T0, T0_frac, L_SUBFR, 1); |
| Convolve(&st->exc[i_subfr], st->h1, y1, L_SUBFR); |
| |
| subframePostProc(st->speech, *usedMode, i_subfr, gain_pit, |
| gain_code, Aq, synth, xn, code, y1, y2, |
| st->mem_syn, st->mem_err, st->mem_w0, |
| st->exc, &st->sharp); |
| } |
| } |
| |
| |
| A += MP1; // interpolated LPC parameters for next subframe |
| Aq += MP1; |
| } |
| |
| Copy(&st->old_exc[L_FRAME], &st->old_exc[0], PIT_MAX + L_INTERPOL); |
| |
| the_end: |
| |
| *--------------------------------------------------* |
| * Update signal for next frame. * |
| *--------------------------------------------------* |
| Copy(&st->old_wsp[L_FRAME], &st->old_wsp[0], PIT_MAX); |
| |
| Copy(&st->old_speech[L_FRAME], &st->old_speech[0], L_TOTAL - L_FRAME); |
| |
| return 0; |
| } |
| ------------------------------------------------------------------------------ |
| RESOURCES USED [optional] |
| |
| When the code is written for a specific target processor the |
| the resources used should be documented below. |
| |
| HEAP MEMORY USED: x bytes |
| |
| STACK MEMORY USED: x bytes |
| |
| CLOCK CYCLES: (cycle count equation for this function) + (variable |
| used to represent cycle count for each subroutine |
| called) |
| where: (cycle count variable) = cycle count for [subroutine |
| name] |
| |
| ------------------------------------------------------------------------------ |
| CAUTION [optional] |
| [State any special notes, constraints or cautions for users of this function] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| Word16 cod_amr( |
| cod_amrState *st, /* i/o : State struct */ |
| enum Mode mode, /* i : AMR mode */ |
| Word16 new_speech[], /* i : speech input (L_FRAME) */ |
| Word16 ana[], /* o : Analysis parameters */ |
| enum Mode *usedMode, /* o : used mode */ |
| Word16 synth[] /* o : Local synthesis */ |
| ) |
| { |
| /* LPC coefficients */ |
| Word16 A_t[(MP1) * 4]; /* A(z) unquantized for the 4 subframes */ |
| Word16 Aq_t[(MP1) * 4]; /* A(z) quantized for the 4 subframes */ |
| Word16 *A, *Aq; /* Pointer on A_t and Aq_t */ |
| Word16 lsp_new[M]; |
| |
| /* Other vectors */ |
| Word16 xn[L_SUBFR]; /* Target vector for pitch search */ |
| Word16 xn2[L_SUBFR]; /* Target vector for codebook search */ |
| Word16 code[L_SUBFR]; /* Fixed codebook excitation */ |
| Word16 y1[L_SUBFR]; /* Filtered adaptive excitation */ |
| Word16 y2[L_SUBFR]; /* Filtered fixed codebook excitation */ |
| Word16 gCoeff[6]; /* Correlations between xn, y1, & y2: */ |
| Word16 res[L_SUBFR]; /* Short term (LPC) prediction residual */ |
| Word16 res2[L_SUBFR]; /* Long term (LTP) prediction residual */ |
| |
| /* Vector and scalars needed for the MR475 */ |
| Word16 xn_sf0[L_SUBFR]; /* Target vector for pitch search */ |
| Word16 y2_sf0[L_SUBFR]; /* Filtered codebook innovation */ |
| Word16 code_sf0[L_SUBFR]; /* Fixed codebook excitation */ |
| Word16 h1_sf0[L_SUBFR]; /* The impulse response of sf0 */ |
| Word16 mem_syn_save[M]; /* Filter memory */ |
| Word16 mem_w0_save[M]; /* Filter memory */ |
| Word16 mem_err_save[M]; /* Filter memory */ |
| Word16 sharp_save; /* Sharpening */ |
| Word16 evenSubfr; /* Even subframe indicator */ |
| Word16 T0_sf0 = 0; /* Integer pitch lag of sf0 */ |
| Word16 T0_frac_sf0 = 0; /* Fractional pitch lag of sf0 */ |
| Word16 i_subfr_sf0 = 0; /* Position in exc[] for sf0 */ |
| Word16 gain_pit_sf0; /* Quantized pitch gain for sf0 */ |
| Word16 gain_code_sf0; /* Quantized codebook gain for sf0 */ |
| |
| /* Scalars */ |
| Word16 i_subfr, subfrNr; |
| Word16 T_op[L_FRAME/L_FRAME_BY2]; |
| Word16 T0, T0_frac; |
| Word16 gain_pit, gain_code; |
| |
| /* Flags */ |
| Word16 lsp_flag = 0; /* indicates resonance in LPC filter */ |
| Word16 gp_limit; /* pitch gain limit value */ |
| Word16 vad_flag; /* VAD decision flag */ |
| Word16 compute_sid_flag; /* SID analysis flag */ |
| Flag *pOverflow = &(st->overflow); /* Overflow flag */ |
| |
| |
| memcpy(st->new_speech, new_speech, L_FRAME*sizeof(Word16)); |
| |
| *usedMode = mode; |
| |
| /* DTX processing */ |
| if (st->dtx) |
| { |
| /* Find VAD decision */ |
| #ifdef VAD2 |
| vad_flag = vad2(st->new_speech, st->vadSt, pOverflow); |
| vad_flag = vad2(st->new_speech + 80, st->vadSt, pOverflow) || vad_flag; |
| #else |
| vad_flag = vad1(st->vadSt, st->new_speech, pOverflow); |
| #endif |
| |
| /* NB! usedMode may change here */ |
| compute_sid_flag = tx_dtx_handler(st->dtx_encSt, |
| vad_flag, |
| usedMode, pOverflow); |
| } |
| else |
| { |
| compute_sid_flag = 0; |
| } |
| |
| /*------------------------------------------------------------------------* |
| * - Perform LPC analysis: * |
| * * autocorrelation + lag windowing * |
| * * Levinson-durbin algorithm to find a[] * |
| * * convert a[] to lsp[] * |
| * * quantize and code the LSPs * |
| * * find the interpolated LSPs and convert to a[] for all * |
| * subframes (both quantized and unquantized) * |
| *------------------------------------------------------------------------*/ |
| |
| /* LP analysis */ |
| lpc(st->lpcSt, mode, st->p_window, st->p_window_12k2, A_t, pOverflow); |
| |
| /* From A(z) to lsp. LSP quantization and interpolation */ |
| lsp(st->lspSt, mode, *usedMode, A_t, Aq_t, lsp_new, &ana, pOverflow); |
| |
| /* Buffer lsp's and energy */ |
| dtx_buffer(st->dtx_encSt, |
| lsp_new, |
| st->new_speech, pOverflow); |
| |
| /* Check if in DTX mode */ |
| |
| if (*usedMode == MRDTX) |
| { |
| dtx_enc(st->dtx_encSt, |
| compute_sid_flag, |
| st->lspSt->qSt, |
| &(st->gainQuantSt->gc_predSt), |
| &ana, pOverflow); |
| |
| memset(st->old_exc, 0, sizeof(Word16)*(PIT_MAX + L_INTERPOL)); |
| memset(st->mem_w0, 0, sizeof(Word16)*M); |
| memset(st->mem_err, 0, sizeof(Word16)*M); |
| memset(st->zero, 0, sizeof(Word16)*L_SUBFR); |
| memset(st->hvec, 0, sizeof(Word16)*L_SUBFR); /* set to zero "h1[-L_SUBFR..-1]" */ |
| /* Reset lsp states */ |
| lsp_reset(st->lspSt); |
| |
| memcpy(st->lspSt->lsp_old, lsp_new, M*sizeof(Word16)); |
| memcpy(st->lspSt->lsp_old_q, lsp_new, M*sizeof(Word16)); |
| |
| /* Reset clLtp states */ |
| cl_ltp_reset(st->clLtpSt); |
| st->sharp = SHARPMIN; |
| } |
| else |
| { |
| /* check resonance in the filter */ |
| lsp_flag = check_lsp(st->tonStabSt, st->lspSt->lsp_old, pOverflow); |
| } |
| |
| /*----------------------------------------------------------------------* |
| * - Find the weighted input speech w_sp[] for the whole speech frame * |
| * - Find the open-loop pitch delay for first 2 subframes * |
| * - Set the range for searching closed-loop pitch in 1st subframe * |
| * - Find the open-loop pitch delay for last 2 subframes * |
| *----------------------------------------------------------------------*/ |
| |
| #ifdef VAD2 |
| if (st->dtx) |
| { |
| st->vadSt->L_Rmax = 0; |
| st->vadSt->L_R0 = 0; |
| } |
| #endif |
| |
| for (subfrNr = 0, i_subfr = 0; |
| subfrNr < L_FRAME / L_FRAME_BY2; |
| subfrNr++, i_subfr += L_FRAME_BY2) |
| { |
| /* Pre-processing on 80 samples */ |
| pre_big(mode, gamma1, gamma1_12k2, gamma2, A_t, i_subfr, st->speech, |
| st->mem_w, st->wsp, pOverflow); |
| |
| |
| if ((mode != MR475) && (mode != MR515)) |
| { |
| /* Find open loop pitch lag for two subframes */ |
| ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[i_subfr], |
| &T_op[subfrNr], st->old_lags, st->ol_gain_flg, subfrNr, |
| st->dtx, pOverflow); |
| } |
| } |
| |
| if ((mode == MR475) || (mode == MR515)) |
| { |
| /* Find open loop pitch lag for ONE FRAME ONLY */ |
| /* search on 160 samples */ |
| |
| ol_ltp(st->pitchOLWghtSt, st->vadSt, mode, &st->wsp[0], &T_op[0], |
| st->old_lags, st->ol_gain_flg, 1, st->dtx, pOverflow); |
| T_op[1] = T_op[0]; |
| } |
| |
| #ifdef VAD2 |
| if (st->dtx) |
| { |
| LTP_flag_update(st->vadSt, (Word16) mode, pOverflow); |
| } |
| #endif |
| |
| #ifndef VAD2 |
| /* run VAD pitch detection */ |
| if (st->dtx) |
| { |
| vad_pitch_detection(st->vadSt, T_op, pOverflow); |
| } |
| #endif |
| |
| if (*usedMode == MRDTX) |
| { |
| goto the_end; |
| } |
| |
| /*------------------------------------------------------------------------* |
| * Loop for every subframe in the analysis frame * |
| *------------------------------------------------------------------------* |
| * To find the pitch and innovation parameters. The subframe size is * |
| * L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times. * |
| * - find the weighted LPC coefficients * |
| * - find the LPC residual signal res[] * |
| * - compute the target signal for pitch search * |
| * - compute impulse response of weighted synthesis filter (h1[]) * |
| * - find the closed-loop pitch parameters * |
| * - encode the pitch dealy * |
| * - update the impulse response h1[] by including fixed-gain pitch * |
| * - find target vector for codebook search * |
| * - codebook search * |
| * - encode codebook address * |
| * - VQ of pitch and codebook gains * |
| * - find synthesis speech * |
| * - update states of weighting filter * |
| *------------------------------------------------------------------------*/ |
| |
| A = A_t; /* pointer to interpolated LPC parameters */ |
| Aq = Aq_t; /* pointer to interpolated quantized LPC parameters */ |
| |
| evenSubfr = 0; |
| subfrNr = -1; |
| for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) |
| { |
| subfrNr++; |
| evenSubfr = 1 - evenSubfr; |
| |
| /* Save states for the MR475 mode */ |
| |
| if ((evenSubfr != 0) && (*usedMode == MR475)) |
| { |
| memcpy(mem_syn_save, st->mem_syn, M*sizeof(Word16)); |
| memcpy(mem_w0_save, st->mem_w0, M*sizeof(Word16)); |
| memcpy(mem_err_save, st->mem_err, M*sizeof(Word16)); |
| |
| sharp_save = st->sharp; |
| } |
| |
| /*-----------------------------------------------------------------* |
| * - Preprocessing of subframe * |
| *-----------------------------------------------------------------*/ |
| |
| if (*usedMode != MR475) |
| { |
| subframePreProc(*usedMode, gamma1, gamma1_12k2, |
| gamma2, A, Aq, &st->speech[i_subfr], |
| st->mem_err, st->mem_w0, st->zero, |
| st->ai_zero, &st->exc[i_subfr], |
| st->h1, xn, res, st->error); |
| } |
| else |
| { /* MR475 */ |
| subframePreProc(*usedMode, gamma1, gamma1_12k2, |
| gamma2, A, Aq, &st->speech[i_subfr], |
| st->mem_err, mem_w0_save, st->zero, |
| st->ai_zero, &st->exc[i_subfr], |
| st->h1, xn, res, st->error); |
| |
| /* save impulse response (modified in cbsearch) */ |
| |
| if (evenSubfr != 0) |
| { |
| memcpy(h1_sf0, st->h1, L_SUBFR*sizeof(Word16)); |
| |
| } |
| } |
| |
| /* copy the LP residual (res2 is modified in the CL LTP search) */ |
| memcpy(res2, res, L_SUBFR*sizeof(Word16)); |
| |
| /*-----------------------------------------------------------------* |
| * - Closed-loop LTP search * |
| *-----------------------------------------------------------------*/ |
| cl_ltp(st->clLtpSt, st->tonStabSt, *usedMode, i_subfr, T_op, st->h1, |
| &st->exc[i_subfr], res2, xn, lsp_flag, xn2, y1, |
| &T0, &T0_frac, &gain_pit, gCoeff, &ana, |
| &gp_limit, pOverflow); |
| |
| /* update LTP lag history */ |
| |
| if ((subfrNr == 0) && (st->ol_gain_flg[0] > 0)) |
| { |
| st->old_lags[1] = T0; |
| } |
| |
| |
| if ((subfrNr == 3) && (st->ol_gain_flg[1] > 0)) |
| { |
| st->old_lags[0] = T0; |
| } |
| |
| /*-----------------------------------------------------------------* |
| * - Inovative codebook search (find index and gain) * |
| *-----------------------------------------------------------------*/ |
| cbsearch(xn2, st->h1, T0, st->sharp, gain_pit, res2, |
| code, y2, &ana, *usedMode, subfrNr, pOverflow); |
| |
| /*------------------------------------------------------* |
| * - Quantization of gains. * |
| *------------------------------------------------------*/ |
| gainQuant(st->gainQuantSt, *usedMode, res, &st->exc[i_subfr], code, |
| xn, xn2, y1, y2, gCoeff, evenSubfr, gp_limit, |
| &gain_pit_sf0, &gain_code_sf0, |
| &gain_pit, &gain_code, &ana, pOverflow); |
| |
| /* update gain history */ |
| update_gp_clipping(st->tonStabSt, gain_pit, pOverflow); |
| |
| |
| if (*usedMode != MR475) |
| { |
| /* Subframe Post Porcessing */ |
| subframePostProc(st->speech, *usedMode, i_subfr, gain_pit, |
| gain_code, Aq, synth, xn, code, y1, y2, st->mem_syn, |
| st->mem_err, st->mem_w0, st->exc, &st->sharp, pOverflow); |
| } |
| else |
| { |
| |
| if (evenSubfr != 0) |
| { |
| i_subfr_sf0 = i_subfr; |
| |
| memcpy(xn_sf0, xn, L_SUBFR*sizeof(Word16)); |
| memcpy(y2_sf0, y2, L_SUBFR*sizeof(Word16)); |
| memcpy(code_sf0, code, L_SUBFR*sizeof(Word16)); |
| |
| T0_sf0 = T0; |
| T0_frac_sf0 = T0_frac; |
| |
| /* Subframe Post Porcessing */ |
| subframePostProc(st->speech, *usedMode, i_subfr, gain_pit, |
| gain_code, Aq, synth, xn, code, y1, y2, |
| mem_syn_save, st->mem_err, mem_w0_save, |
| st->exc, &st->sharp, pOverflow); |
| st->sharp = sharp_save; |
| } |
| else |
| { |
| /* update both subframes for the MR475 */ |
| |
| /* Restore states for the MR475 mode */ |
| memcpy(st->mem_err, mem_err_save, M*sizeof(Word16)); |
| |
| |
| /* re-build excitation for sf 0 */ |
| Pred_lt_3or6(&st->exc[i_subfr_sf0], T0_sf0, T0_frac_sf0, |
| L_SUBFR, 1, pOverflow); |
| Convolve(&st->exc[i_subfr_sf0], h1_sf0, y1, L_SUBFR); |
| |
| Aq -= MP1; |
| subframePostProc(st->speech, *usedMode, i_subfr_sf0, |
| gain_pit_sf0, gain_code_sf0, Aq, |
| synth, xn_sf0, code_sf0, y1, y2_sf0, |
| st->mem_syn, st->mem_err, st->mem_w0, st->exc, |
| &sharp_save, pOverflow); /* overwrites sharp_save */ |
| Aq += MP1; |
| |
| /* re-run pre-processing to get xn right (needed by postproc) */ |
| /* (this also reconstructs the unsharpened h1 for sf 1) */ |
| subframePreProc(*usedMode, gamma1, gamma1_12k2, |
| gamma2, A, Aq, &st->speech[i_subfr], |
| st->mem_err, st->mem_w0, st->zero, |
| st->ai_zero, &st->exc[i_subfr], |
| st->h1, xn, res, st->error); |
| |
| /* re-build excitation sf 1 (changed if lag < L_SUBFR) */ |
| Pred_lt_3or6(&st->exc[i_subfr], T0, T0_frac, L_SUBFR, 1, pOverflow); |
| Convolve(&st->exc[i_subfr], st->h1, y1, L_SUBFR); |
| |
| subframePostProc(st->speech, *usedMode, i_subfr, gain_pit, |
| gain_code, Aq, synth, xn, code, y1, y2, |
| st->mem_syn, st->mem_err, st->mem_w0, |
| st->exc, &st->sharp, pOverflow); |
| } |
| } |
| |
| A += MP1; /* interpolated LPC parameters for next subframe */ |
| Aq += MP1; |
| } |
| |
| memcpy(&st->old_exc[0], &st->old_exc[L_FRAME], (PIT_MAX + L_INTERPOL)*sizeof(Word16)); |
| |
| the_end: |
| |
| /*--------------------------------------------------* |
| * Update signal for next frame. * |
| *--------------------------------------------------*/ |
| |
| memcpy(&st->old_wsp[0], &st->old_wsp[L_FRAME], PIT_MAX*sizeof(Word16)); |
| memcpy(&st->old_speech[0], &st->old_speech[L_FRAME], (L_TOTAL - L_FRAME)*sizeof(Word16)); |
| |
| return(0); |
| } |
| |
| |
