|
5
|
1 /*
|
|
|
2 * SpanDSP - a series of DSP components for telephony
|
|
|
3 *
|
|
|
4 * lpc10_encode.c - LPC10 low bit rate speech codec.
|
|
|
5 *
|
|
|
6 * Written by Steve Underwood <steveu@coppice.org>
|
|
|
7 *
|
|
|
8 * Copyright (C) 2006 Steve Underwood
|
|
|
9 *
|
|
|
10 * All rights reserved.
|
|
|
11 *
|
|
|
12 * This program is free software; you can redistribute it and/or modify
|
|
|
13 * it under the terms of the GNU General Public License version 2, as
|
|
|
14 * published by the Free Software Foundation.
|
|
|
15 *
|
|
|
16 * This program is distributed in the hope that it will be useful,
|
|
|
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
19 * GNU General Public License for more details.
|
|
|
20 *
|
|
|
21 * You should have received a copy of the GNU General Public License
|
|
|
22 * along with this program; if not, write to the Free Software
|
|
|
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
24 *
|
|
|
25 * This code is based on the U.S. Department of Defense reference
|
|
|
26 * implementation of the LPC-10 2400 bps Voice Coder. They do not
|
|
|
27 * exert copyright claims on their code, and it may be freely used.
|
|
|
28 *
|
|
|
29 * $Id: lpc10_encode.c,v 1.15 2006/11/21 13:57:40 steveu Exp $
|
|
|
30 */
|
|
|
31
|
|
|
32 #ifdef HAVE_CONFIG_H
|
|
|
33 #include <config.h>
|
|
|
34 #endif
|
|
|
35
|
|
|
36 #include <stdlib.h>
|
|
|
37 #include <stdio.h>
|
|
|
38 #include <inttypes.h>
|
|
|
39 #include <memory.h>
|
|
|
40 #if defined(HAVE_TGMATH_H)
|
|
|
41 #include <tgmath.h>
|
|
|
42 #endif
|
|
|
43 #if defined(HAVE_MATH_H)
|
|
|
44 #include <math.h>
|
|
|
45 #endif
|
|
|
46
|
|
|
47 #include "spandsp/telephony.h"
|
|
|
48 #include "spandsp/dc_restore.h"
|
|
|
49 #include "spandsp/lpc10.h"
|
|
|
50
|
|
|
51 #include "lpc10_encdecs.h"
|
|
|
52
|
|
|
53 static void lpc10_pack(lpc10_encode_state_t *s, uint8_t ibits[], lpc10_frame_t *t)
|
|
|
54 {
|
|
|
55 static const int iblist[53] =
|
|
|
56 {
|
|
|
57 13, 12, 11, 1, 2, 13, 12, 11, 1, 2,
|
|
|
58 13, 10, 11, 2, 1, 10, 13, 12, 11, 10,
|
|
|
59 2, 13, 12, 11, 10, 2, 1, 12, 7, 6,
|
|
|
60 1, 10, 9, 8, 7, 4, 6, 9, 8, 7,
|
|
|
61 5, 1, 9, 8, 4, 6, 1, 5, 9, 8,
|
|
|
62 7, 5, 6
|
|
|
63 };
|
|
|
64 int32_t itab[13];
|
|
|
65 int x;
|
|
|
66 int i;
|
|
|
67
|
|
|
68 /* ibits is 54 bits of LPC data ordered as follows: */
|
|
|
69 /* R1-0, R2-0, R3-0, P-0, A-0, */
|
|
|
70 /* R1-1, R2-1, R3-1, P-1, A-1, */
|
|
|
71 /* R1-2, R4-0, R3-2, A-2, P-2, R4-1, */
|
|
|
72 /* R1-3, R2-2, R3-3, R4-2, A-3, */
|
|
|
73 /* R1-4, R2-3, R3-4, R4-3, A-4, */
|
|
|
74 /* P-3, R2-4, R7-0, R8-0, P-4, R4-4, */
|
|
|
75 /* R5-0, R6-0, R7-1,R10-0, R8-1, */
|
|
|
76 /* R5-1, R6-1, R7-2, R9-0, P-5, */
|
|
|
77 /* R5-2, R6-2,R10-1, R8-2, P-6, R9-1, */
|
|
|
78 /* R5-3, R6-3, R7-3, R9-2, R8-3, SYNC */
|
|
|
79
|
|
|
80 itab[0] = t->ipitch;
|
|
|
81 itab[1] = t->irms;
|
|
|
82 itab[2] = 0;
|
|
|
83 for (i = 0; i < LPC10_ORDER; i++)
|
|
|
84 itab[i + 3] = t->irc[LPC10_ORDER - 1 - i] & 0x7FFF;
|
|
|
85 /* Put 54 bits into the output buffer */
|
|
|
86 x = 0;
|
|
|
87 for (i = 0; i < 53; i++)
|
|
|
88 {
|
|
|
89 x = (x << 1) | (itab[iblist[i] - 1] & 1);
|
|
|
90 if ((i & 7) == 7)
|
|
|
91 ibits[i >> 3] = x & 0xFF;
|
|
|
92 itab[iblist[i] - 1] >>= 1;
|
|
|
93 }
|
|
|
94 x = (x << 1) | (s->isync & 1);
|
|
|
95 s->isync ^= 1;
|
|
|
96 x <<= 2;
|
|
|
97 ibits[6] = x & 0xFF;
|
|
|
98 }
|
|
|
99 /*- End of function --------------------------------------------------------*/
|
|
|
100
|
|
|
101 /* Quantize LPC parameters for transmission */
|
|
|
102 static int encode(lpc10_encode_state_t *s,
|
|
|
103 lpc10_frame_t *t,
|
|
|
104 int32_t *voice,
|
|
|
105 int32_t pitch,
|
|
|
106 float rms,
|
|
|
107 float *rc)
|
|
|
108 {
|
|
|
109 static const int32_t enctab[16] =
|
|
|
110 {
|
|
|
111 0, 7, 11, 12, 13, 10, 6, 1, 14, 9, 5, 2, 3, 4, 8, 15
|
|
|
112 };
|
|
|
113 static const int32_t entau[60] =
|
|
|
114 {
|
|
|
115 19, 11, 27, 25, 29, 21, 23, 22, 30, 14, 15, 7, 39, 38, 46,
|
|
|
116 42, 43, 41, 45, 37, 53, 49, 51, 50, 54, 52, 60, 56, 58, 26,
|
|
|
117 90, 88, 92, 84, 86, 82, 83, 81, 85, 69, 77, 73, 75, 74, 78,
|
|
|
118 70, 71, 67, 99, 97, 113, 112, 114, 98, 106, 104, 108, 100,
|
|
|
119 101, 76
|
|
|
120 };
|
|
|
121 static const int32_t enadd[8] =
|
|
|
122 {
|
|
|
123 1920, -768, 2432, 1280, 3584, 1536, 2816, -1152
|
|
|
124 };
|
|
|
125 static const float enscl[8] =
|
|
|
126 {
|
|
|
127 0.0204f, 0.0167f, 0.0145f, 0.0147f, 0.0143f, 0.0135f, 0.0125f, 0.0112f
|
|
|
128 };
|
|
|
129 static const int32_t enbits[8] =
|
|
|
130 {
|
|
|
131 6, 5, 4, 4, 4, 4, 3, 3
|
|
|
132 };
|
|
|
133 static const int32_t entab6[64] =
|
|
|
134 {
|
|
|
135 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3,
|
|
|
136 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6,
|
|
|
137 7, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 10, 10, 11, 11, 12, 13, 14, 15
|
|
|
138 };
|
|
|
139 static const int32_t rmst[64] =
|
|
|
140 {
|
|
|
141 1024, 936, 856, 784, 718, 656, 600, 550, 502,
|
|
|
142 460, 420, 384, 352, 328, 294, 270, 246, 226,
|
|
|
143 206, 188, 172, 158, 144, 132, 120, 110, 102,
|
|
|
144 92, 84, 78, 70, 64, 60, 54, 50,
|
|
|
145 46, 42, 38, 34, 32, 30, 26, 24,
|
|
|
146 22, 20, 18, 17, 16, 15, 14, 13,
|
|
|
147 12, 11, 10, 9, 8, 7, 6, 5, 4,
|
|
|
148 3, 2, 1, 0
|
|
|
149 };
|
|
|
150
|
|
|
151 int32_t idel;
|
|
|
152 int32_t nbit;
|
|
|
153 int32_t i;
|
|
|
154 int32_t j;
|
|
|
155 int32_t i2;
|
|
|
156 int32_t i3;
|
|
|
157 int32_t mrk;
|
|
|
158
|
|
|
159 /* Scale RMS and RC's to int32_ts */
|
|
|
160 t->irms = rms;
|
|
|
161 for (i = 0; i < LPC10_ORDER; i++)
|
|
|
162 t->irc[i] = rc[i]*32768.0f;
|
|
|
163 if (voice[0] != 0 && voice[1] != 0)
|
|
|
164 {
|
|
|
165 t->ipitch = entau[pitch - 1];
|
|
|
166 }
|
|
|
167 else
|
|
|
168 {
|
|
|
169 if (s->error_correction)
|
|
|
170 {
|
|
|
171 t->ipitch = 0;
|
|
|
172 if (voice[0] != voice[1])
|
|
|
173 t->ipitch = 127;
|
|
|
174 }
|
|
|
175 else
|
|
|
176 {
|
|
|
177 t->ipitch = (voice[0] << 1) + voice[1];
|
|
|
178 }
|
|
|
179 }
|
|
|
180 /* Encode RMS by binary table search */
|
|
|
181 j = 32;
|
|
|
182 idel = 16;
|
|
|
183 t->irms = min(t->irms, 1023);
|
|
|
184 while (idel > 0)
|
|
|
185 {
|
|
|
186 if (t->irms > rmst[j - 1])
|
|
|
187 j -= idel;
|
|
|
188 if (t->irms < rmst[j - 1])
|
|
|
189 j += idel;
|
|
|
190 idel /= 2;
|
|
|
191 }
|
|
|
192 if (t->irms > rmst[j - 1])
|
|
|
193 --j;
|
|
|
194 t->irms = 31 - j/2;
|
|
|
195 /* Encode RC(1) and (2) as log-area-ratios */
|
|
|
196 for (i = 0; i < 2; i++)
|
|
|
197 {
|
|
|
198 i2 = t->irc[i];
|
|
|
199 mrk = 0;
|
|
|
200 if (i2 < 0)
|
|
|
201 {
|
|
|
202 i2 = -i2;
|
|
|
203 mrk = 1;
|
|
|
204 }
|
|
|
205 i2 = min(i2/512, 63);
|
|
|
206 i2 = entab6[i2];
|
|
|
207 if (mrk != 0)
|
|
|
208 i2 = -i2;
|
|
|
209 t->irc[i] = i2;
|
|
|
210 }
|
|
|
211 /* Encode RC(3) - (10) linearly, remove bias then scale */
|
|
|
212 for (i = 2; i < LPC10_ORDER; i++)
|
|
|
213 {
|
|
|
214 i2 = (t->irc[i]/2 + enadd[LPC10_ORDER - 1 - i])*enscl[LPC10_ORDER - 1 - i];
|
|
|
215 i2 = max(i2, -127);
|
|
|
216 i2 = min(i2, 127);
|
|
|
217 nbit = enbits[LPC10_ORDER - 1 - i];
|
|
|
218 i3 = (i2 < 0);
|
|
|
219 i2 /= pow_ii(2, nbit);
|
|
|
220 if (i3)
|
|
|
221 i2--;
|
|
|
222 t->irc[i] = i2;
|
|
|
223 }
|
|
|
224 /* Protect the most significant bits of the most
|
|
|
225 important parameters during non-voiced frames.
|
|
|
226 RC(1) - RC(4) are protected using 20 parity bits
|
|
|
227 replacing RC(5) - RC(10). */
|
|
|
228 if (s->error_correction)
|
|
|
229 {
|
|
|
230 if (t->ipitch == 0 || t->ipitch == 127)
|
|
|
231 {
|
|
|
232 t->irc[4] = enctab[(t->irc[0] & 0x1E) >> 1];
|
|
|
233 t->irc[5] = enctab[(t->irc[1] & 0x1E) >> 1];
|
|
|
234 t->irc[6] = enctab[(t->irc[2] & 0x1E) >> 1];
|
|
|
235 t->irc[7] = enctab[(t->irms & 0x1E) >> 1];
|
|
|
236 t->irc[8] = enctab[(t->irc[3] & 0x1E) >> 1] >> 1;
|
|
|
237 t->irc[9] = enctab[(t->irc[3] & 0x1E) >> 1] & 1;
|
|
|
238 }
|
|
|
239 }
|
|
|
240 return 0;
|
|
|
241 }
|
|
|
242 /*- End of function --------------------------------------------------------*/
|
|
|
243
|
|
|
244 static void high_pass_100hz(lpc10_encode_state_t *s, float speech[], int start, int len)
|
|
|
245 {
|
|
|
246 float si;
|
|
|
247 float err;
|
|
|
248 int i;
|
|
|
249
|
|
|
250 /* 100 Hz high pass filter */
|
|
|
251 for (i = start; i < len; i++)
|
|
|
252 {
|
|
|
253 si = speech[i];
|
|
|
254 err = si + s->z11*1.859076f - s->z21*0.8648249f;
|
|
|
255 si = err - s->z11*2.0f + s->z21;
|
|
|
256 s->z21 = s->z11;
|
|
|
257 s->z11 = err;
|
|
|
258 err = si + s->z12*1.935715f - s->z22*0.9417004f;
|
|
|
259 si = err - s->z12*2.0f + s->z22;
|
|
|
260 s->z22 = s->z12;
|
|
|
261 s->z12 = err;
|
|
|
262 speech[i] = si*0.902428f;
|
|
|
263 }
|
|
|
264 }
|
|
|
265 /*- End of function --------------------------------------------------------*/
|
|
|
266
|
|
|
267 lpc10_encode_state_t *lpc10_encode_init(lpc10_encode_state_t *s, int error_correction)
|
|
|
268 {
|
|
|
269 int i;
|
|
|
270 int j;
|
|
|
271
|
|
|
272 if (s == NULL)
|
|
|
273 {
|
|
|
274 if ((s = (lpc10_encode_state_t *) malloc(sizeof(lpc10_encode_state_t))) == NULL)
|
|
|
275 return NULL;
|
|
|
276 }
|
|
|
277
|
|
|
278 s->error_correction = error_correction;
|
|
|
279
|
|
|
280 /* State used only by function high_pass_100hz */
|
|
|
281 s->z11 = 0.0f;
|
|
|
282 s->z21 = 0.0f;
|
|
|
283 s->z12 = 0.0f;
|
|
|
284 s->z22 = 0.0f;
|
|
|
285
|
|
|
286 /* State used by function lpc10_analyse */
|
|
|
287 for (i = 0; i < 540; i++)
|
|
|
288 {
|
|
|
289 s->inbuf[i] = 0.0f;
|
|
|
290 s->pebuf[i] = 0.0f;
|
|
|
291 }
|
|
|
292 for (i = 0; i < 696; i++)
|
|
|
293 s->lpbuf[i] = 0.0f;
|
|
|
294 for (i = 0; i < 312; i++)
|
|
|
295 s->ivbuf[i] = 0.0f;
|
|
|
296 s->bias = 0.0f;
|
|
|
297 s->osptr = 1;
|
|
|
298 for (i = 0; i < 3; i++)
|
|
|
299 s->obound[i] = 0;
|
|
|
300 s->vwin[2][0] = 307;
|
|
|
301 s->vwin[2][1] = 462;
|
|
|
302 s->awin[2][0] = 307;
|
|
|
303 s->awin[2][1] = 462;
|
|
|
304 for (i = 0; i < 4; i++)
|
|
|
305 {
|
|
|
306 s->voibuf[i][0] = 0;
|
|
|
307 s->voibuf[i][1] = 0;
|
|
|
308 }
|
|
|
309 for (i = 0; i < 3; i++)
|
|
|
310 s->rmsbuf[i] = 0.0f;
|
|
|
311 for (i = 0; i < 3; i++)
|
|
|
312 {
|
|
|
313 for (j = 0; j < 10; j++)
|
|
|
314 s->rcbuf[i][j] = 0.0f;
|
|
|
315 }
|
|
|
316 s->zpre = 0.0f;
|
|
|
317
|
|
|
318 /* State used by function onset */
|
|
|
319 s->n = 0.0f;
|
|
|
320 s->d__ = 1.0f;
|
|
|
321 for (i = 0; i < 16; i++)
|
|
|
322 s->l2buf[i] = 0.0f;
|
|
|
323 s->l2sum1 = 0.0f;
|
|
|
324 s->l2ptr1 = 1;
|
|
|
325 s->l2ptr2 = 9;
|
|
|
326 s->hyst = FALSE;
|
|
|
327
|
|
|
328 /* State used by function lpc10_voicing */
|
|
|
329 s->dither = 20.0f;
|
|
|
330 s->maxmin = 0.0f;
|
|
|
331 for (i = 0; i < 3; i++)
|
|
|
332 {
|
|
|
333 s->voice[i][0] = 0.0f;
|
|
|
334 s->voice[i][1] = 0.0f;
|
|
|
335 }
|
|
|
336 s->lbve = 3000;
|
|
|
337 s->fbve = 3000;
|
|
|
338 s->fbue = 187;
|
|
|
339 s->ofbue = 187;
|
|
|
340 s->sfbue = 187;
|
|
|
341 s->lbue = 93;
|
|
|
342 s->olbue = 93;
|
|
|
343 s->slbue = 93;
|
|
|
344 s->snr = (float) (s->fbve / s->fbue << 6);
|
|
|
345
|
|
|
346 /* State used by function dynamic_pitch_tracking */
|
|
|
347 for (i = 0; i < 60; i++)
|
|
|
348 s->s[i] = 0.0f;
|
|
|
349 for (i = 0; i < 2; i++)
|
|
|
350 {
|
|
|
351 for (j = 0; j < 60; j++)
|
|
|
352 s->p[i][j] = 0;
|
|
|
353 }
|
|
|
354 s->ipoint = 0;
|
|
|
355 s->alphax = 0.0f;
|
|
|
356
|
|
|
357 /* State used by function lpc10_pack */
|
|
|
358 s->isync = 0;
|
|
|
359
|
|
|
360 return s;
|
|
|
361 }
|
|
|
362 /*- End of function --------------------------------------------------------*/
|
|
|
363
|
|
|
364 int lpc10_encode_release(lpc10_encode_state_t *s)
|
|
|
365 {
|
|
|
366 free(s);
|
|
|
367 return 0;
|
|
|
368 }
|
|
|
369 /*- End of function --------------------------------------------------------*/
|
|
|
370
|
|
|
371 int lpc10_encode(lpc10_encode_state_t *s, uint8_t code[], const int16_t amp[], int quant)
|
|
|
372 {
|
|
|
373 int32_t voice[2];
|
|
|
374 int32_t pitch;
|
|
|
375 float speech[LPC10_SAMPLES_PER_FRAME];
|
|
|
376 float rc[LPC10_ORDER];
|
|
|
377 float rms;
|
|
|
378 lpc10_frame_t frame;
|
|
|
379 int i;
|
|
|
380 int j;
|
|
|
381
|
|
|
382 for (i = 0; i < quant; i++)
|
|
|
383 {
|
|
|
384 for (j = 0; j < LPC10_SAMPLES_PER_FRAME; j++)
|
|
|
385 speech[j] = (float) amp[i*LPC10_SAMPLES_PER_FRAME + j]/32768.0f;
|
|
|
386 high_pass_100hz(s, speech, 0, LPC10_SAMPLES_PER_FRAME);
|
|
|
387 lpc10_analyse(s, speech, voice, &pitch, &rms, rc);
|
|
|
388 encode(s, &frame, voice, pitch, rms, rc);
|
|
|
389 lpc10_pack(s, &code[7*i], &frame);
|
|
|
390 }
|
|
|
391 return quant*7;
|
|
|
392 }
|
|
|
393 /*- End of function --------------------------------------------------------*/
|
|
|
394 /*- End of file ------------------------------------------------------------*/
|
