libgsmhr/libgsmhr.c

   1 /* HR (GSM 06.20) codec wrapper */
   2
   3 /*
   4  * This file is part of gapk (GSM Audio Pocket Knife).
   5  *
   6  * gapk is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * gapk is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with gapk.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdint.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <gsmhr/gsmhr.h>
  26
  27 #include "refsrc/typedefs.h"
  28 #include "refsrc/homing.h"
  29 #include "refsrc/sp_dec.h"
  30 #include "refsrc/sp_enc.h"
  31
  32
  33 #define EXPORT __attribute__((visibility("default")))
  34
  35 #define EHF_MASK 0x0008                /* Encoder Homing Frame pattern */
  36 #define LMAX 142                       /* largest lag (integer sense) */
  37 #define CG_INT_MACS 6                  /* Number of multiply-accumulates in
  38                                         * one interpolation           */
  39 #define NUM_CLOSED 3                   /* maximum number of lags searched */
  40 #define LPCSTARTINDEX 25               /* where the LPC analysis window
  41                                         * starts                        */
  42 #define INBUFFSZ LPCSTARTINDEX + A_LEN /* input buffer size */
  43 #define LTP_LEN         147            /* maximum ltp lag */
  44 #define LSMAX           (LMAX + CG_INT_MACS/2)
  45 #define HNW_BUFF_LEN    LSMAX
  46
  47   extern Shortword swOldR0;
  48   extern Shortword swOldR0Index;
  49
  50   extern struct NormSw psnsWSfrmEngSpace[];
  51
  52   extern Shortword pswHPFXState[];
  53   extern Shortword pswHPFYState[];
  54   extern Shortword pswOldFrmKs[];
  55   extern Shortword pswOldFrmAs[];
  56   extern Shortword pswOldFrmSNWCoefs[];
  57   extern Shortword pswWgtSpeechSpace[];
  58
  59   extern Shortword pswSpeech[];        /* input speech */
  60
  61   extern Shortword swPtch;
  62
  63   extern Shortword pswAnalysisState[NP];
  64
  65   extern Shortword pswWStateNum[NP],
  66          pswWStateDenom[NP];
  67
  68
  69   extern Shortword pswLtpStateBase[LTP_LEN + S_LEN];
  70   extern Shortword pswHState[NP];
  71   extern Shortword pswHNWState[HNW_BUFF_LEN];
  72   extern Shortword gswPostFiltAgcGain,
  73          gpswPostFiltStateNum[NP],
  74          gpswPostFiltStateDenom[NP],
  75          swPostEmphasisState,
  76          pswSynthFiltState[NP],
  77          pswOldFrmKsDec[NP],
  78          pswOldFrmAsDec[NP],
  79          pswOldFrmPFNum[NP],
  80          pswOldFrmPFDenom[NP],
  81          swOldR0Dec,
  82          pswLtpStateBaseDec[LTP_LEN + S_LEN],
  83          pswPPreState[LTP_LEN + S_LEN];
  84
  85   extern Shortword swMuteFlagOld;      /* error concealment */
  86
  87   extern Longword plSubfrEnergyMem[4]; /* error concealment */
  88   extern Shortword swLevelMem[4],
  89          lastR0,                       /* error concealment */
  90          pswLastGood[18],              /* error concealment */
  91          swState,
  92          swLastFlag;                   /* error concealment */
  93
  94 struct gsmhr {
  95         int dec_reset_flg;
  96
  97         struct {
  98                 Shortword swOldR0;
  99                 Shortword swOldR0Index;
 100                 struct NormSw psnsWSfrmEngSpace[2 * N_SUB];
 101                 Shortword pswHPFXState[4];
 102                 Shortword pswHPFYState[4];
 103                 Shortword pswOldFrmKs[NP];
 104                 Shortword pswOldFrmAs[NP];
 105                 Shortword pswOldFrmSNWCoefs[NP];
 106                 Shortword pswWgtSpeechSpace[F_LEN + LMAX + CG_INT_MACS / 2];
 107                 Shortword pswSpeech[INBUFFSZ];        /* input speech */
 108                 Shortword swPtch;
 109                 Shortword pswAnalysisState[NP];
 110                 Shortword pswWStateNum[NP],
 111                          pswWStateDenom[NP];
 112                 Shortword pswLtpStateBase[LTP_LEN + S_LEN];
 113                 Shortword pswHState[NP];
 114                 Shortword pswHNWState[HNW_BUFF_LEN];
 115         } encoder;
 116         struct {
 117                 Shortword gswPostFiltAgcGain,
 118                          gpswPostFiltStateNum[NP],
 119                          gpswPostFiltStateDenom[NP],
 120                          swPostEmphasisState,
 121                          pswSynthFiltState[NP],
 122                          pswOldFrmKsDec[NP],
 123                          pswOldFrmAsDec[NP],
 124                          pswOldFrmPFNum[NP],
 125                          pswOldFrmPFDenom[NP],
 126                          swOldR0Dec,
 127                          pswLtpStateBaseDec[LTP_LEN + S_LEN],
 128                          pswPPreState[LTP_LEN + S_LEN];
 129                 Shortword swMuteFlagOld;
 130                 Longword plSubfrEnergyMem[4];
 131                 Shortword swLevelMem[4],
 132                          lastR0,
 133                          pswLastGood[18],
 134                          swState,
 135                          swLastFlag;
 136         } decoder;
 137 };
 138
 139 EXPORT struct gsmhr *
 140 gsmhr_init(void)
 141 {
 142         struct gsmhr *state;
 143
 144         state = calloc(1, sizeof(struct gsmhr));
 145         if (!state)
 146                 return NULL;
 147
 148         state->dec_reset_flg = 1;
 149
 150         return state;
 151 }
 152
 153 EXPORT void
 154 gsmhr_exit(struct gsmhr *state)
 155 {
 156         free(state);
 157 }
 158
 159 EXPORT int
 160 gsmhr_encode(struct gsmhr *state, int16_t *hr_params, const int16_t *pcm)
 161 {
 162         int enc_reset_flg;
 163         Shortword pcm_b[F_LEN];
 164
 165         /* recall state */
 166         swOldR0 = swOldR0;
 167         swOldR0Index = swOldR0Index;
 168         memcpy(psnsWSfrmEngSpace, state->encoder.psnsWSfrmEngSpace, sizeof(struct NormSw) * 2 * N_SUB);
 169         memcpy(pswHPFXState, state->encoder.pswHPFXState, sizeof(Shortword) * 4);
 170         memcpy(pswHPFYState, state->encoder.pswHPFYState, sizeof(Shortword) * 4);
 171         memcpy(pswOldFrmKs, state->encoder.pswOldFrmKs, sizeof(Shortword) * NP);
 172         memcpy(pswOldFrmAs, state->encoder.pswOldFrmAs, sizeof(Shortword) * NP);
 173         memcpy(pswOldFrmSNWCoefs, state->encoder.pswOldFrmSNWCoefs, sizeof(Shortword) * NP);
 174         memcpy(pswWgtSpeechSpace, state->encoder.pswWgtSpeechSpace, sizeof(Shortword) * F_LEN + LMAX + CG_INT_MACS / 2);
 175         memcpy(pswSpeech, state->encoder.pswSpeech, sizeof(Shortword) * INBUFFSZ);
 176         swPtch = state->encoder.swPtch;
 177         memcpy(pswAnalysisState, state->encoder.pswAnalysisState, sizeof(Shortword) * NP);
 178         memcpy(pswWStateNum, state->encoder.pswWStateNum, sizeof(Shortword) * NP);
 179         memcpy(pswWStateDenom, state->encoder.pswWStateDenom, sizeof(Shortword) * NP);
 180         memcpy(pswLtpStateBase, state->encoder.pswLtpStateBase, sizeof(Shortword) * LTP_LEN + S_LEN);
 181         memcpy(pswHState, state->encoder.pswHState, sizeof(Shortword) * NP);
 182         memcpy(pswHNWState, state->encoder.pswHNWState, sizeof(Shortword) * HNW_BUFF_LEN);
 183
 184         memcpy(pcm_b, pcm, F_LEN*sizeof(int16_t));
 185
 186         enc_reset_flg = encoderHomingFrameTest(pcm_b);
 187
 188         speechEncoder(pcm_b, hr_params);
 189
 190         if (enc_reset_flg)
 191                 resetEnc();
 192
 193         /* store state */
 194         state->encoder.swOldR0 = swOldR0;
 195         state->encoder.swOldR0Index = swOldR0Index;
 196         memcpy(state->encoder.psnsWSfrmEngSpace, psnsWSfrmEngSpace, sizeof(struct NormSw) * 2 * N_SUB);
 197         memcpy(state->encoder.pswHPFXState, pswHPFXState, sizeof(Shortword) * 4);
 198         memcpy(state->encoder.pswHPFYState, pswHPFYState, sizeof(Shortword) * 4);
 199         memcpy(state->encoder.pswOldFrmKs, pswOldFrmKs, sizeof(Shortword) * NP);
 200         memcpy(state->encoder.pswOldFrmAs, pswOldFrmAs, sizeof(Shortword) * NP);
 201         memcpy(state->encoder.pswOldFrmSNWCoefs, pswOldFrmSNWCoefs, sizeof(Shortword) * NP);
 202         memcpy(state->encoder.pswWgtSpeechSpace, pswWgtSpeechSpace, sizeof(Shortword) * F_LEN + LMAX + CG_INT_MACS / 2);
 203         memcpy(state->encoder.pswSpeech, pswSpeech, sizeof(Shortword) * INBUFFSZ);
 204         state->encoder.swPtch = swPtch;
 205         memcpy(state->encoder.pswAnalysisState, pswAnalysisState, sizeof(Shortword) * NP);
 206         memcpy(state->encoder.pswWStateNum, pswWStateNum, sizeof(Shortword) * NP);
 207         memcpy(state->encoder.pswWStateDenom, pswWStateDenom, sizeof(Shortword) * NP);
 208         memcpy(state->encoder.pswLtpStateBase, pswLtpStateBase, sizeof(Shortword) * LTP_LEN + S_LEN);
 209         memcpy(state->encoder.pswHState, pswHState, sizeof(Shortword) * NP);
 210         memcpy(state->encoder.pswHNWState, pswHNWState, sizeof(Shortword) * HNW_BUFF_LEN);
 211
 212         return 0;
 213 }
 214
 215 EXPORT int
 216 gsmhr_decode(struct gsmhr *state, int16_t *pcm, const int16_t *hr_params)
 217 {
 218 #define WHOLE_FRAME             18
 219 #define TO_FIRST_SUBFRAME        9
 220
 221         int dec_reset_flg;
 222         Shortword hr_params_b[22];
 223
 224         /* recall state */
 225         gswPostFiltAgcGain = state->decoder.gswPostFiltAgcGain;
 226         memcpy(gpswPostFiltStateNum, state->decoder.gpswPostFiltStateNum, sizeof(Shortword) * NP);
 227         memcpy(gpswPostFiltStateDenom, state->decoder.gpswPostFiltStateDenom, sizeof(Shortword) * NP);
 228         swPostEmphasisState = state->decoder.swPostEmphasisState;
 229         memcpy(pswSynthFiltState, state->decoder.pswSynthFiltState, sizeof(Shortword) * NP);
 230         memcpy(pswOldFrmKsDec, state->decoder.pswOldFrmKsDec, sizeof(Shortword) * NP);
 231         memcpy(pswOldFrmAsDec, state->decoder.pswOldFrmAsDec, sizeof(Shortword) * NP);
 232         memcpy(pswOldFrmPFNum, state->decoder.pswOldFrmPFNum, sizeof(Shortword) * NP);
 233         memcpy(pswOldFrmPFDenom, state->decoder.pswOldFrmPFDenom, sizeof(Shortword) * NP);
 234         swOldR0Dec = state->decoder.swOldR0Dec;
 235         memcpy(pswLtpStateBaseDec, state->decoder.pswLtpStateBaseDec, sizeof(Shortword) * LTP_LEN + S_LEN);
 236         memcpy(pswPPreState, state->decoder.pswPPreState, sizeof(Shortword) * LTP_LEN + S_LEN);
 237         swMuteFlagOld = state->decoder.swMuteFlagOld;
 238         memcpy(plSubfrEnergyMem, state->decoder.plSubfrEnergyMem, sizeof(Longword) * 4);
 239         memcpy(swLevelMem, state->decoder.swLevelMem, sizeof(Shortword) * 4);
 240         lastR0 = state->decoder.lastR0;
 241         memcpy(pswLastGood, state->decoder.pswLastGood, sizeof(Shortword) * 18);
 242         swState = state->decoder.swState;
 243         swLastFlag = state->decoder.swLastFlag;
 244
 245         memcpy(hr_params_b, hr_params, 22*sizeof(int16_t));
 246
 247         if (state->dec_reset_flg)
 248                 dec_reset_flg = decoderHomingFrameTest(hr_params_b, TO_FIRST_SUBFRAME);
 249         else
 250                 dec_reset_flg = 0;
 251
 252         if (dec_reset_flg && state->dec_reset_flg) {
 253                 int i;
 254                 for (i=0; i<F_LEN; i++)
 255                         pcm[i] = EHF_MASK;
 256         } else {
 257                 speechDecoder(hr_params_b, pcm);
 258         }
 259
 260         if (!state->dec_reset_flg)
 261                 dec_reset_flg = decoderHomingFrameTest(hr_params_b, WHOLE_FRAME);
 262
 263         if (dec_reset_flg)
 264                 resetDec();
 265
 266         state->dec_reset_flg = dec_reset_flg;
 267
 268         /* store state */
 269         state->decoder.gswPostFiltAgcGain = gswPostFiltAgcGain;
 270         memcpy(state->decoder.gpswPostFiltStateNum, gpswPostFiltStateNum, sizeof(Shortword) * NP);
 271         memcpy(state->decoder.gpswPostFiltStateDenom, gpswPostFiltStateDenom, sizeof(Shortword) * NP);
 272         state->decoder.swPostEmphasisState = swPostEmphasisState;
 273         memcpy(state->decoder.pswSynthFiltState, pswSynthFiltState, sizeof(Shortword) * NP);
 274         memcpy(state->decoder.pswOldFrmKsDec, pswOldFrmKsDec, sizeof(Shortword) * NP);
 275         memcpy(state->decoder.pswOldFrmAsDec, pswOldFrmAsDec, sizeof(Shortword) * NP);
 276         memcpy(state->decoder.pswOldFrmPFNum, pswOldFrmPFNum, sizeof(Shortword) * NP);
 277         memcpy(state->decoder.pswOldFrmPFDenom, pswOldFrmPFDenom, sizeof(Shortword) * NP);
 278         state->decoder.swOldR0Dec = swOldR0Dec;
 279         memcpy(state->decoder.pswLtpStateBaseDec, pswLtpStateBaseDec, sizeof(Shortword) * LTP_LEN + S_LEN);
 280         memcpy(state->decoder.pswPPreState, pswPPreState, sizeof(Shortword) * LTP_LEN + S_LEN);
 281         state->decoder.swMuteFlagOld = swMuteFlagOld;
 282         memcpy(state->decoder.plSubfrEnergyMem, plSubfrEnergyMem, sizeof(Longword) * 4);
 283         memcpy(state->decoder.swLevelMem, swLevelMem, sizeof(Shortword) * 4);
 284         state->decoder.lastR0 = lastR0;
 285         memcpy(state->decoder.pswLastGood, pswLastGood, sizeof(Shortword) * 18);
 286         state->decoder.swState = swState;
 287         state->decoder.swLastFlag = swLastFlag;
 288
 289         return 0;
 290 }