more file version tags
[asterisk/asterisk.git] / codecs / codec_g726.c
1 /* codec_g726.c - translate between signed linear and ITU G.726-32kbps
2  * 
3  * Asterisk -- A telephony toolkit for Linux.
4  *
5  * Based on frompcm.c and topcm.c from the Emiliano MIPL browser/
6  * interpreter.  See http://www.bsdtelephony.com.mx
7  *
8  * Copyright (c) 2004 - 2005, Digium, Inc.
9  *
10  * Mark Spencer <markster@digium.com>
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License
14  */
15
16 #include <fcntl.h>
17 #include <netinet/in.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <unistd.h>
22
23 #include "asterisk.h"
24
25 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
26
27 #include "asterisk/lock.h"
28 #include "asterisk/logger.h"
29 #include "asterisk/module.h"
30 #include "asterisk/config.h"
31 #include "asterisk/options.h"
32 #include "asterisk/translate.h"
33 #include "asterisk/channel.h"
34
35 #define WANT_ASM
36 #include "log2comp.h"
37
38 /* define NOT_BLI to use a faster but not bit-level identical version */
39 /* #define NOT_BLI */
40
41 #if defined(NOT_BLI)
42 #       if defined(_MSC_VER)
43 typedef __int64 sint64;
44 #       elif defined(__GNUC__)
45 typedef long long sint64;
46 #       else
47 #               error 64-bit integer type is not defined for your compiler/platform
48 #       endif
49 #endif
50
51 #define BUFFER_SIZE   8096      /* size for the translation buffers */
52 #define BUF_SHIFT       5
53
54 AST_MUTEX_DEFINE_STATIC(localuser_lock);
55 static int localusecnt = 0;
56
57 static char *tdesc = "ITU G.726-32kbps G726 Transcoder";
58
59 static int useplc = 0;
60
61 /* Sample frame data */
62
63 #include "slin_g726_ex.h"
64 #include "g726_slin_ex.h"
65
66 /*
67  * The following is the definition of the state structure
68  * used by the G.721/G.723 encoder and decoder to preserve their internal
69  * state between successive calls.  The meanings of the majority
70  * of the state structure fields are explained in detail in the
71  * CCITT Recommendation G.721.  The field names are essentially indentical
72  * to variable names in the bit level description of the coding algorithm
73  * included in this Recommendation.
74  */
75 struct g726_state {
76         long yl;        /* Locked or steady state step size multiplier. */
77         int yu;         /* Unlocked or non-steady state step size multiplier. */
78         int dms;        /* Short term energy estimate. */
79         int dml;        /* Long term energy estimate. */
80         int ap;         /* Linear weighting coefficient of 'yl' and 'yu'. */
81
82         int a[2];       /* Coefficients of pole portion of prediction filter.
83                                  * stored as fixed-point 1==2^14 */
84         int b[6];       /* Coefficients of zero portion of prediction filter.
85                                  * stored as fixed-point 1==2^14 */
86         int pk[2];      /* Signs of previous two samples of a partially
87                          * reconstructed signal.
88                          */
89         int dq[6];  /* Previous 6 samples of the quantized difference signal
90                                  * stored as fixed point 1==2^12,
91                                  * or in internal floating point format */
92         int sr[2];      /* Previous 2 samples of the quantized difference signal
93                                  * stored as fixed point 1==2^12,
94                                  * or in internal floating point format */
95         int td; /* delayed tone detect, new in 1988 version */
96 };
97
98
99
100 static int qtab_721[7] = {-124, 80, 178, 246, 300, 349, 400};
101 /*
102  * Maps G.721 code word to reconstructed scale factor normalized log
103  * magnitude values.
104  */
105 static int _dqlntab[16] = {-2048, 4, 135, 213, 273, 323, 373, 425,
106                                 425, 373, 323, 273, 213, 135, 4, -2048};
107
108 /* Maps G.721 code word to log of scale factor multiplier. */
109 static int _witab[16] = {-12, 18, 41, 64, 112, 198, 355, 1122,
110                                 1122, 355, 198, 112, 64, 41, 18, -12};
111 /*
112  * Maps G.721 code words to a set of values whose long and short
113  * term averages are computed and then compared to give an indication
114  * how stationary (steady state) the signal is.
115  */
116 static int _fitab[16] = {0, 0, 0, 0x200, 0x200, 0x200, 0x600, 0xE00,
117                                 0xE00, 0x600, 0x200, 0x200, 0x200, 0, 0, 0};
118
119 /* Deprecated
120 static int power2[15] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80,
121                         0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000};
122 */
123
124 /*
125  * g72x_init_state()
126  *
127  * This routine initializes and/or resets the g726_state structure
128  * pointed to by 'state_ptr'.
129  * All the initial state values are specified in the CCITT G.721 document.
130  */
131 static void g726_init_state(struct g726_state *state_ptr)
132 {
133         int             cnta;
134
135         state_ptr->yl = 34816;
136         state_ptr->yu = 544;
137         state_ptr->dms = 0;
138         state_ptr->dml = 0;
139         state_ptr->ap = 0;
140         for (cnta = 0; cnta < 2; cnta++)
141         {
142                 state_ptr->a[cnta] = 0;
143                 state_ptr->pk[cnta] = 0;
144 #ifdef NOT_BLI
145                 state_ptr->sr[cnta] = 1;
146 #else
147                 state_ptr->sr[cnta] = 32;
148 #endif
149         }
150         for (cnta = 0; cnta < 6; cnta++)
151         {
152                 state_ptr->b[cnta] = 0;
153 #ifdef NOT_BLI
154                 state_ptr->dq[cnta] = 1;
155 #else
156                 state_ptr->dq[cnta] = 32;
157 #endif
158         }
159         state_ptr->td = 0;
160 }
161
162 /*
163  * quan()
164  *
165  * quantizes the input val against the table of integers.
166  * It returns i if table[i - 1] <= val < table[i].
167  *
168  * Using linear search for simple coding.
169  */
170 static int quan(int val, int *table, int size)
171 {
172         int             i;
173
174         for (i = 0; i < size && val >= *table; ++i, ++table)
175                 ;
176         return (i);
177 }
178
179 #ifdef NOT_BLI /* faster non-identical version */
180
181 /*
182  * predictor_zero()
183  *
184  * computes the estimated signal from 6-zero predictor.
185  *
186  */
187 static int predictor_zero(struct g726_state *state_ptr)
188 {       /* divide by 2 is necessary here to handle negative numbers correctly */
189         int i;
190         sint64 sezi;
191         for (sezi = 0, i = 0; i < 6; i++)                       /* ACCUM */
192                 sezi += (sint64)state_ptr->b[i] * state_ptr->dq[i];
193         return (int)(sezi >> 13) / 2 /* 2^14 */;
194 }
195
196 /*
197  * predictor_pole()
198  *
199  * computes the estimated signal from 2-pole predictor.
200  *
201  */
202 static int predictor_pole(struct g726_state *state_ptr)
203 {       /* divide by 2 is necessary here to handle negative numbers correctly */
204         return (int)(((sint64)state_ptr->a[1] * state_ptr->sr[1] +
205                       (sint64)state_ptr->a[0] * state_ptr->sr[0]) >> 13) / 2 /* 2^14 */;
206 }
207
208 #else /* NOT_BLI - identical version */
209 /*
210  * fmult()
211  *
212  * returns the integer product of the fixed-point number "an" (1==2^12) and
213  * "floating point" representation (4-bit exponent, 6-bit mantessa) "srn".
214  */
215 static int fmult(int an, int srn)
216 {
217         int             anmag, anexp, anmant;
218         int             wanexp, wanmant;
219         int             retval;
220
221         anmag = (an > 0) ? an : ((-an) & 0x1FFF);
222         anexp = ilog2(anmag) - 5;
223         anmant = (anmag == 0) ? 32 :
224             (anexp >= 0) ? anmag >> anexp : anmag << -anexp;
225         wanexp = anexp + ((srn >> 6) & 0xF) - 13;
226
227         wanmant = (anmant * (srn & 077) + 0x30) >> 4;
228         retval = (wanexp >= 0) ? ((wanmant << wanexp) & 0x7FFF) :
229             (wanmant >> -wanexp);
230
231         return (((an ^ srn) < 0) ? -retval : retval);
232 }
233
234 static int predictor_zero(struct g726_state *state_ptr)
235 {
236         int             i;
237         int             sezi;
238         for (sezi = 0, i = 0; i < 6; i++)                       /* ACCUM */
239                 sezi += fmult(state_ptr->b[i] >> 2, state_ptr->dq[i]);
240         return sezi;
241 }
242
243 static int predictor_pole(struct g726_state *state_ptr)
244 {
245         return (fmult(state_ptr->a[1] >> 2, state_ptr->sr[1]) +
246                         fmult(state_ptr->a[0] >> 2, state_ptr->sr[0]));
247 }
248
249 #endif /* NOT_BLI */
250
251 /*
252  * step_size()
253  *
254  * computes the quantization step size of the adaptive quantizer.
255  *
256  */
257 static int step_size(struct g726_state *state_ptr)
258 {
259         int             y;
260         int             dif;
261         int             al;
262
263         if (state_ptr->ap >= 256)
264                 return (state_ptr->yu);
265         else {
266                 y = state_ptr->yl >> 6;
267                 dif = state_ptr->yu - y;
268                 al = state_ptr->ap >> 2;
269                 if (dif > 0)
270                         y += (dif * al) >> 6;
271                 else if (dif < 0)
272                         y += (dif * al + 0x3F) >> 6;
273                 return (y);
274         }
275 }
276
277 /*
278  * quantize()
279  *
280  * Given a raw sample, 'd', of the difference signal and a
281  * quantization step size scale factor, 'y', this routine returns the
282  * ADPCM codeword to which that sample gets quantized.  The step
283  * size scale factor division operation is done in the log base 2 domain
284  * as a subtraction.
285  */
286 static int quantize(
287         int             d,      /* Raw difference signal sample */
288         int             y,      /* Step size multiplier */
289         int             *table, /* quantization table */
290         int             size)   /* table size of integers */
291 {
292         int             dqm;    /* Magnitude of 'd' */
293         int             exp;    /* Integer part of base 2 log of 'd' */
294         int             mant;   /* Fractional part of base 2 log */
295         int             dl;             /* Log of magnitude of 'd' */
296         int             dln;    /* Step size scale factor normalized log */
297         int             i;
298
299         /*
300          * LOG
301          *
302          * Compute base 2 log of 'd', and store in 'dl'.
303          */
304         dqm = abs(d);
305         exp = ilog2(dqm);
306         if (exp < 0)
307                 exp = 0;
308         mant = ((dqm << 7) >> exp) & 0x7F;      /* Fractional portion. */
309         dl = (exp << 7) | mant;
310
311         /*
312          * SUBTB
313          *
314          * "Divide" by step size multiplier.
315          */
316         dln = dl - (y >> 2);
317
318         /*
319          * QUAN
320          *
321          * Obtain codword i for 'd'.
322          */
323         i = quan(dln, table, size);
324         if (d < 0)                      /* take 1's complement of i */
325                 return ((size << 1) + 1 - i);
326         else if (i == 0)                /* take 1's complement of 0 */
327                 return ((size << 1) + 1); /* new in 1988 */
328         else
329                 return (i);
330 }
331
332 /*
333  * reconstruct()
334  *
335  * Returns reconstructed difference signal 'dq' obtained from
336  * codeword 'i' and quantization step size scale factor 'y'.
337  * Multiplication is performed in log base 2 domain as addition.
338  */
339 static int reconstruct(
340         int             sign,   /* 0 for non-negative value */
341         int             dqln,   /* G.72x codeword */
342         int             y)      /* Step size multiplier */
343 {
344         int             dql;    /* Log of 'dq' magnitude */
345         int             dex;    /* Integer part of log */
346         int             dqt;
347         int             dq;     /* Reconstructed difference signal sample */
348
349         dql = dqln + (y >> 2);  /* ADDA */
350
351         if (dql < 0) {
352 #ifdef NOT_BLI
353                 return (sign) ? -1 : 1;
354 #else
355                 return (sign) ? -0x8000 : 0;
356 #endif
357         } else {                /* ANTILOG */
358                 dex = (dql >> 7) & 15;
359                 dqt = 128 + (dql & 127);
360 #ifdef NOT_BLI
361                 dq = ((dqt << 19) >> (14 - dex));
362                 return (sign) ? -dq : dq;
363 #else
364                 dq = (dqt << 7) >> (14 - dex);
365                 return (sign) ? (dq - 0x8000) : dq;
366 #endif
367         }
368 }
369
370 /*
371  * update()
372  *
373  * updates the state variables for each output code
374  */
375 static void update(
376         int             code_size,      /* distinguish 723_40 with others */
377         int             y,              /* quantizer step size */
378         int             wi,             /* scale factor multiplier */
379         int             fi,             /* for long/short term energies */
380         int             dq,             /* quantized prediction difference */
381         int             sr,             /* reconstructed signal */
382         int             dqsez,          /* difference from 2-pole predictor */
383         struct g726_state *state_ptr)   /* coder state pointer */
384 {
385         int             cnt;
386         int             mag;            /* Adaptive predictor, FLOAT A */
387 #ifndef NOT_BLI
388         int             exp;
389 #endif
390         int             a2p=0;          /* LIMC */
391         int             a1ul;           /* UPA1 */
392         int             pks1;           /* UPA2 */
393         int             fa1;
394         int             tr;                     /* tone/transition detector */
395         int             ylint, thr2, dqthr;
396         int             ylfrac, thr1;
397         int             pk0;
398
399         pk0 = (dqsez < 0) ? 1 : 0;      /* needed in updating predictor poles */
400
401 #ifdef NOT_BLI
402         mag = abs(dq / 0x1000); /* prediction difference magnitude */
403 #else
404         mag = dq & 0x7FFF;              /* prediction difference magnitude */
405 #endif
406         /* TRANS */
407         ylint = state_ptr->yl >> 15;    /* exponent part of yl */
408         ylfrac = (state_ptr->yl >> 10) & 0x1F;  /* fractional part of yl */
409         thr1 = (32 + ylfrac) << ylint;          /* threshold */
410         thr2 = (ylint > 9) ? 31 << 10 : thr1;   /* limit thr2 to 31 << 10 */
411         dqthr = (thr2 + (thr2 >> 1)) >> 1;      /* dqthr = 0.75 * thr2 */
412         if (state_ptr->td == 0)         /* signal supposed voice */
413                 tr = 0;
414         else if (mag <= dqthr)          /* supposed data, but small mag */
415                 tr = 0;                 /* treated as voice */
416         else                            /* signal is data (modem) */
417                 tr = 1;
418
419         /*
420          * Quantizer scale factor adaptation.
421          */
422
423         /* FUNCTW & FILTD & DELAY */
424         /* update non-steady state step size multiplier */
425         state_ptr->yu = y + ((wi - y) >> 5);
426
427         /* LIMB */
428         if (state_ptr->yu < 544)        /* 544 <= yu <= 5120 */
429                 state_ptr->yu = 544;
430         else if (state_ptr->yu > 5120)
431                 state_ptr->yu = 5120;
432
433         /* FILTE & DELAY */
434         /* update steady state step size multiplier */
435         state_ptr->yl += state_ptr->yu + ((-state_ptr->yl) >> 6);
436
437         /*
438          * Adaptive predictor coefficients.
439          */
440         if (tr == 1) {                  /* reset a's and b's for modem signal */
441                 state_ptr->a[0] = 0;
442                 state_ptr->a[1] = 0;
443                 state_ptr->b[0] = 0;
444                 state_ptr->b[1] = 0;
445                 state_ptr->b[2] = 0;
446                 state_ptr->b[3] = 0;
447                 state_ptr->b[4] = 0;
448                 state_ptr->b[5] = 0;
449         } else {                        /* update a's and b's */
450                 pks1 = pk0 ^ state_ptr->pk[0];          /* UPA2 */
451
452                 /* update predictor pole a[1] */
453                 a2p = state_ptr->a[1] - (state_ptr->a[1] >> 7);
454                 if (dqsez != 0) {
455                         fa1 = (pks1) ? state_ptr->a[0] : -state_ptr->a[0];
456                         if (fa1 < -8191)        /* a2p = function of fa1 */
457                                 a2p -= 0x100;
458                         else if (fa1 > 8191)
459                                 a2p += 0xFF;
460                         else
461                                 a2p += fa1 >> 5;
462
463                         if (pk0 ^ state_ptr->pk[1])
464                                 /* LIMC */
465                                 if (a2p <= -12160)
466                                         a2p = -12288;
467                                 else if (a2p >= 12416)
468                                         a2p = 12288;
469                                 else
470                                         a2p -= 0x80;
471                         else if (a2p <= -12416)
472                                 a2p = -12288;
473                         else if (a2p >= 12160)
474                                 a2p = 12288;
475                         else
476                                 a2p += 0x80;
477                 }
478
479                 /* TRIGB & DELAY */
480                 state_ptr->a[1] = a2p;
481
482                 /* UPA1 */
483                 /* update predictor pole a[0] */
484                 state_ptr->a[0] -= state_ptr->a[0] >> 8;
485                 if (dqsez != 0) {
486                         if (pks1 == 0)
487                                 state_ptr->a[0] += 192;
488                         else
489                                 state_ptr->a[0] -= 192;
490                 }
491                 /* LIMD */
492                 a1ul = 15360 - a2p;
493                 if (state_ptr->a[0] < -a1ul)
494                         state_ptr->a[0] = -a1ul;
495                 else if (state_ptr->a[0] > a1ul)
496                         state_ptr->a[0] = a1ul;
497
498                 /* UPB : update predictor zeros b[6] */
499                 for (cnt = 0; cnt < 6; cnt++) {
500                         if (code_size == 5)             /* for 40Kbps G.723 */
501                                 state_ptr->b[cnt] -= state_ptr->b[cnt] >> 9;
502                         else                    /* for G.721 and 24Kbps G.723 */
503                                 state_ptr->b[cnt] -= state_ptr->b[cnt] >> 8;
504                         if (mag)
505                         {       /* XOR */
506                                 if ((dq ^ state_ptr->dq[cnt]) >= 0)
507                                         state_ptr->b[cnt] += 128;
508                                 else
509                                         state_ptr->b[cnt] -= 128;
510                         }
511                 }
512         }
513
514         for (cnt = 5; cnt > 0; cnt--)
515                 state_ptr->dq[cnt] = state_ptr->dq[cnt-1];
516 #ifdef NOT_BLI
517         state_ptr->dq[0] = dq;
518 #else
519         /* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */
520         if (mag == 0) {
521                 state_ptr->dq[0] = (dq >= 0) ? 0x20 : 0x20 - 0x400;
522         } else {
523                 exp = ilog2(mag) + 1;
524                 state_ptr->dq[0] = (dq >= 0) ?
525                     (exp << 6) + ((mag << 6) >> exp) :
526                     (exp << 6) + ((mag << 6) >> exp) - 0x400;
527         }
528 #endif
529
530         state_ptr->sr[1] = state_ptr->sr[0];
531 #ifdef NOT_BLI
532         state_ptr->sr[0] = sr;
533 #else
534         /* FLOAT B : convert sr to 4-bit exp., 6-bit mantissa f.p. */
535         if (sr == 0) {
536                 state_ptr->sr[0] = 0x20;
537         } else if (sr > 0) {
538                 exp = ilog2(sr) + 1;
539                 state_ptr->sr[0] = (exp << 6) + ((sr << 6) >> exp);
540         } else if (sr > -0x8000) {
541                 mag = -sr;
542                 exp = ilog2(mag) + 1;
543                 state_ptr->sr[0] =  (exp << 6) + ((mag << 6) >> exp) - 0x400;
544         } else
545                 state_ptr->sr[0] = 0x20 - 0x400;
546 #endif
547
548         /* DELAY A */
549         state_ptr->pk[1] = state_ptr->pk[0];
550         state_ptr->pk[0] = pk0;
551
552         /* TONE */
553         if (tr == 1)            /* this sample has been treated as data */
554                 state_ptr->td = 0;      /* next one will be treated as voice */
555         else if (a2p < -11776)  /* small sample-to-sample correlation */
556                 state_ptr->td = 1;      /* signal may be data */
557         else                            /* signal is voice */
558                 state_ptr->td = 0;
559
560         /*
561          * Adaptation speed control.
562          */
563         state_ptr->dms += (fi - state_ptr->dms) >> 5;           /* FILTA */
564         state_ptr->dml += (((fi << 2) - state_ptr->dml) >> 7);  /* FILTB */
565
566         if (tr == 1)
567                 state_ptr->ap = 256;
568         else if (y < 1536)                                      /* SUBTC */
569                 state_ptr->ap += (0x200 - state_ptr->ap) >> 4;
570         else if (state_ptr->td == 1)
571                 state_ptr->ap += (0x200 - state_ptr->ap) >> 4;
572         else if (abs((state_ptr->dms << 2) - state_ptr->dml) >=
573             (state_ptr->dml >> 3))
574                 state_ptr->ap += (0x200 - state_ptr->ap) >> 4;
575         else
576                 state_ptr->ap += (-state_ptr->ap) >> 4;
577 }
578
579 /*
580  * g726_decode()
581  *
582  * Description:
583  *
584  * Decodes a 4-bit code of G.726-32 encoded data of i and
585  * returns the resulting linear PCM, A-law or u-law value.
586  * return -1 for unknown out_coding value.
587  */
588 static int g726_decode(int      i, struct g726_state *state_ptr)
589 {
590         int             sezi, sez, se;  /* ACCUM */
591         int             y;                      /* MIX */
592         int             sr;                     /* ADDB */
593         int             dq;
594         int             dqsez;
595
596         i &= 0x0f;                      /* mask to get proper bits */
597 #ifdef NOT_BLI
598         sezi = predictor_zero(state_ptr);
599         sez = sezi;
600         se = sezi + predictor_pole(state_ptr);  /* estimated signal */
601 #else
602         sezi = predictor_zero(state_ptr);
603         sez = sezi >> 1;
604         se = (sezi + predictor_pole(state_ptr)) >> 1;   /* estimated signal */
605 #endif
606
607         y = step_size(state_ptr);       /* dynamic quantizer step size */
608
609         dq = reconstruct(i & 8, _dqlntab[i], y); /* quantized diff. */
610
611 #ifdef NOT_BLI
612         sr = se + dq;                           /* reconst. signal */
613         dqsez = dq + sez;                       /* pole prediction diff. */
614 #else
615         sr = (dq < 0) ? se - (dq & 0x3FFF) : se + dq;   /* reconst. signal */
616         dqsez = sr - se + sez;          /* pole prediction diff. */
617 #endif
618
619         update(4, y, _witab[i] << 5, _fitab[i], dq, sr, dqsez, state_ptr);
620
621 #ifdef NOT_BLI
622         return (sr >> 10);      /* sr was 26-bit dynamic range */
623 #else
624         return (sr << 2);       /* sr was 14-bit dynamic range */
625 #endif
626 }
627
628 /*
629  * g726_encode()
630  *
631  * Encodes the input vale of linear PCM, A-law or u-law data sl and returns
632  * the resulting code. -1 is returned for unknown input coding value.
633  */
634 static int g726_encode(int sl, struct g726_state *state_ptr)
635 {
636         int             sezi, se, sez;          /* ACCUM */
637         int             d;                      /* SUBTA */
638         int             sr;                     /* ADDB */
639         int             y;                      /* MIX */
640         int             dqsez;                  /* ADDC */
641         int             dq, i;
642
643 #ifdef NOT_BLI
644         sl <<= 10;                      /* 26-bit dynamic range */
645
646         sezi = predictor_zero(state_ptr);
647         sez = sezi;
648         se = sezi + predictor_pole(state_ptr);  /* estimated signal */
649 #else
650         sl >>= 2;                       /* 14-bit dynamic range */
651
652         sezi = predictor_zero(state_ptr);
653         sez = sezi >> 1;
654         se = (sezi + predictor_pole(state_ptr)) >> 1;   /* estimated signal */
655 #endif
656
657         d = sl - se;                            /* estimation difference */
658
659         /* quantize the prediction difference */
660         y = step_size(state_ptr);               /* quantizer step size */
661 #ifdef NOT_BLI
662         d /= 0x1000;
663 #endif
664         i = quantize(d, y, qtab_721, 7);        /* i = G726 code */
665
666         dq = reconstruct(i & 8, _dqlntab[i], y);        /* quantized est diff */
667
668 #ifdef NOT_BLI
669         sr = se + dq;                           /* reconst. signal */
670         dqsez = dq + sez;                       /* pole prediction diff. */
671 #else
672         sr = (dq < 0) ? se - (dq & 0x3FFF) : se + dq;   /* reconst. signal */
673         dqsez = sr - se + sez;                  /* pole prediction diff. */
674 #endif
675
676         update(4, y, _witab[i] << 5, _fitab[i], dq, sr, dqsez, state_ptr);
677
678         return (i);
679 }
680
681 /*
682  * Private workspace for translating signed linear signals to G726.
683  */
684
685 struct g726_encoder_pvt
686 {
687   struct ast_frame f;
688   char offset[AST_FRIENDLY_OFFSET];   /* Space to build offset */
689   unsigned char outbuf[BUFFER_SIZE];  /* Encoded G726, two nibbles to a word */
690   unsigned char next_flag;
691   struct g726_state g726;
692   int tail;
693 };
694
695 /*
696  * Private workspace for translating G726 signals to signed linear.
697  */
698
699 struct g726_decoder_pvt
700 {
701   struct ast_frame f;
702   char offset[AST_FRIENDLY_OFFSET];     /* Space to build offset */
703   short outbuf[BUFFER_SIZE];    /* Decoded signed linear values */
704   struct g726_state g726;
705   int tail;
706   plc_state_t plc;
707 };
708
709 /*
710  * G726ToLin_New
711  *  Create a new instance of g726_decoder_pvt.
712  *
713  * Results:
714  *  Returns a pointer to the new instance.
715  *
716  * Side effects:
717  *  None.
718  */
719
720 static struct ast_translator_pvt *
721 g726tolin_new (void)
722 {
723   struct g726_decoder_pvt *tmp;
724   tmp = malloc (sizeof (struct g726_decoder_pvt));
725   if (tmp)
726     {
727           memset(tmp, 0, sizeof(*tmp));
728       tmp->tail = 0;
729       plc_init(&tmp->plc);
730       localusecnt++;
731           g726_init_state(&tmp->g726);
732       ast_update_use_count ();
733     }
734   return (struct ast_translator_pvt *) tmp;
735 }
736
737 /*
738  * LinToG726_New
739  *  Create a new instance of g726_encoder_pvt.
740  *
741  * Results:
742  *  Returns a pointer to the new instance.
743  *
744  * Side effects:
745  *  None.
746  */
747
748 static struct ast_translator_pvt *
749 lintog726_new (void)
750 {
751   struct g726_encoder_pvt *tmp;
752   tmp = malloc (sizeof (struct g726_encoder_pvt));
753   if (tmp)
754     {
755           memset(tmp, 0, sizeof(*tmp));
756       localusecnt++;
757       tmp->tail = 0;
758           g726_init_state(&tmp->g726);
759       ast_update_use_count ();
760     }
761   return (struct ast_translator_pvt *) tmp;
762 }
763
764 /*
765  * G726ToLin_FrameIn
766  *  Fill an input buffer with packed 4-bit G726 values if there is room
767  *  left.
768  *
769  * Results:
770  *  Foo
771  *
772  * Side effects:
773  *  tmp->tail is the number of packed values in the buffer.
774  */
775
776 static int
777 g726tolin_framein (struct ast_translator_pvt *pvt, struct ast_frame *f)
778 {
779   struct g726_decoder_pvt *tmp = (struct g726_decoder_pvt *) pvt;
780   unsigned char *b;
781   int x;
782
783   if(f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */
784         if((tmp->tail + 160) > BUFFER_SIZE) {
785             ast_log(LOG_WARNING, "Out of buffer space\n");
786             return -1;
787         }
788         if(useplc) {
789             plc_fillin(&tmp->plc, tmp->outbuf+tmp->tail, 160);
790             tmp->tail += 160;
791         }
792         return 0;
793   }
794
795   b = f->data;
796   for (x=0;x<f->datalen;x++) {
797         if (tmp->tail >= BUFFER_SIZE) {
798                 ast_log(LOG_WARNING, "Out of buffer space!\n");
799                 return -1;
800         }
801         tmp->outbuf[tmp->tail++] = g726_decode((b[x] >> 4) & 0xf, &tmp->g726);
802         if (tmp->tail >= BUFFER_SIZE) {
803                 ast_log(LOG_WARNING, "Out of buffer space!\n");
804                 return -1;
805         }
806         tmp->outbuf[tmp->tail++] = g726_decode(b[x] & 0x0f, &tmp->g726);
807   }
808
809   if(useplc) plc_rx(&tmp->plc, tmp->outbuf+tmp->tail-f->datalen*2, f->datalen*2);
810
811   return 0;
812 }
813
814 /*
815  * G726ToLin_FrameOut
816  *  Convert 4-bit G726 encoded signals to 16-bit signed linear.
817  *
818  * Results:
819  *  Converted signals are placed in tmp->f.data, tmp->f.datalen
820  *  and tmp->f.samples are calculated.
821  *
822  * Side effects:
823  *  None.
824  */
825
826 static struct ast_frame *
827 g726tolin_frameout (struct ast_translator_pvt *pvt)
828 {
829   struct g726_decoder_pvt *tmp = (struct g726_decoder_pvt *) pvt;
830
831   if (!tmp->tail)
832     return NULL;
833
834   tmp->f.frametype = AST_FRAME_VOICE;
835   tmp->f.subclass = AST_FORMAT_SLINEAR;
836   tmp->f.datalen = tmp->tail * 2;
837   tmp->f.samples = tmp->tail;
838   tmp->f.mallocd = 0;
839   tmp->f.offset = AST_FRIENDLY_OFFSET;
840   tmp->f.src = __PRETTY_FUNCTION__;
841   tmp->f.data = tmp->outbuf;
842   tmp->tail = 0;
843   return &tmp->f;
844 }
845
846 /*
847  * LinToG726_FrameIn
848  *  Fill an input buffer with 16-bit signed linear PCM values.
849  *
850  * Results:
851  *  None.
852  *
853  * Side effects:
854  *  tmp->tail is number of signal values in the input buffer.
855  */
856
857 static int
858 lintog726_framein (struct ast_translator_pvt *pvt, struct ast_frame *f)
859 {
860   struct g726_encoder_pvt *tmp = (struct g726_encoder_pvt *) pvt;
861   short *s = f->data;
862   int samples = f->datalen / 2;
863   int x;
864   for (x=0;x<samples;x++) {
865         if (tmp->next_flag & 0x80) {
866                 if (tmp->tail >= BUFFER_SIZE) {
867                         ast_log(LOG_WARNING, "Out of buffer space\n");
868                         return -1;
869                 }
870                 tmp->outbuf[tmp->tail++] = ((tmp->next_flag & 0xf)<< 4) | g726_encode(s[x], &tmp->g726);
871                 tmp->next_flag = 0;
872         } else {
873                 tmp->next_flag = 0x80 | g726_encode(s[x], &tmp->g726);
874         }
875   }
876   return 0;
877 }
878
879 /*
880  * LinToG726_FrameOut
881  *  Convert a buffer of raw 16-bit signed linear PCM to a buffer
882  *  of 4-bit G726 packed two to a byte (Big Endian).
883  *
884  * Results:
885  *  Foo
886  *
887  * Side effects:
888  *  Leftover inbuf data gets packed, tail gets updated.
889  */
890
891 static struct ast_frame *
892 lintog726_frameout (struct ast_translator_pvt *pvt)
893 {
894   struct g726_encoder_pvt *tmp = (struct g726_encoder_pvt *) pvt;
895   
896   if (!tmp->tail)
897         return NULL;
898   tmp->f.frametype = AST_FRAME_VOICE;
899   tmp->f.subclass = AST_FORMAT_G726;
900   tmp->f.samples = tmp->tail * 2;
901   tmp->f.mallocd = 0;
902   tmp->f.offset = AST_FRIENDLY_OFFSET;
903   tmp->f.src = __PRETTY_FUNCTION__;
904   tmp->f.data = tmp->outbuf;
905   tmp->f.datalen = tmp->tail;
906
907   tmp->tail = 0;
908   return &tmp->f;
909 }
910
911
912 /*
913  * G726ToLin_Sample
914  */
915
916 static struct ast_frame *
917 g726tolin_sample (void)
918 {
919   static struct ast_frame f;
920   f.frametype = AST_FRAME_VOICE;
921   f.subclass = AST_FORMAT_G726;
922   f.datalen = sizeof (g726_slin_ex);
923   f.samples = sizeof(g726_slin_ex) * 2;
924   f.mallocd = 0;
925   f.offset = 0;
926   f.src = __PRETTY_FUNCTION__;
927   f.data = g726_slin_ex;
928   return &f;
929 }
930
931 /*
932  * LinToG726_Sample
933  */
934
935 static struct ast_frame *
936 lintog726_sample (void)
937 {
938   static struct ast_frame f;
939   f.frametype = AST_FRAME_VOICE;
940   f.subclass = AST_FORMAT_SLINEAR;
941   f.datalen = sizeof (slin_g726_ex);
942   /* Assume 8000 Hz */
943   f.samples = sizeof (slin_g726_ex) / 2;
944   f.mallocd = 0;
945   f.offset = 0;
946   f.src = __PRETTY_FUNCTION__;
947   f.data = slin_g726_ex;
948   return &f;
949 }
950
951 /*
952  * G726_Destroy
953  *  Destroys a private workspace.
954  *
955  * Results:
956  *  It's gone!
957  *
958  * Side effects:
959  *  None.
960  */
961
962 static void
963 g726_destroy (struct ast_translator_pvt *pvt)
964 {
965   free (pvt);
966   localusecnt--;
967   ast_update_use_count ();
968 }
969
970 /*
971  * The complete translator for G726ToLin.
972  */
973
974 static struct ast_translator g726tolin = {
975   "g726tolin",
976   AST_FORMAT_G726,
977   AST_FORMAT_SLINEAR,
978   g726tolin_new,
979   g726tolin_framein,
980   g726tolin_frameout,
981   g726_destroy,
982   /* NULL */
983   g726tolin_sample
984 };
985
986 /*
987  * The complete translator for LinToG726.
988  */
989
990 static struct ast_translator lintog726 = {
991   "lintog726",
992   AST_FORMAT_SLINEAR,
993   AST_FORMAT_G726,
994   lintog726_new,
995   lintog726_framein,
996   lintog726_frameout,
997   g726_destroy,
998   /* NULL */
999   lintog726_sample
1000 };
1001
1002 static void 
1003 parse_config(void)
1004 {
1005   struct ast_config *cfg;
1006   struct ast_variable *var;
1007   if ((cfg = ast_config_load("codecs.conf"))) {
1008     if ((var = ast_variable_browse(cfg, "plc"))) {
1009       while (var) {
1010        if (!strcasecmp(var->name, "genericplc")) {
1011          useplc = ast_true(var->value) ? 1 : 0;
1012          if (option_verbose > 2)
1013            ast_verbose(VERBOSE_PREFIX_3 "codec_g726: %susing generic PLC\n", useplc ? "" : "not ");
1014        }
1015        var = var->next;
1016       }
1017     }
1018     ast_config_destroy(cfg);
1019   }
1020 }
1021
1022 int
1023 reload(void)
1024 {
1025   parse_config();
1026   return 0;
1027 }
1028
1029 int
1030 unload_module (void)
1031 {
1032   int res;
1033   ast_mutex_lock (&localuser_lock);
1034   res = ast_unregister_translator (&lintog726);
1035   if (!res)
1036     res = ast_unregister_translator (&g726tolin);
1037   if (localusecnt)
1038     res = -1;
1039   ast_mutex_unlock (&localuser_lock);
1040   return res;
1041 }
1042
1043 int
1044 load_module (void)
1045 {
1046   int res;
1047   parse_config();
1048   res = ast_register_translator (&g726tolin);
1049   if (!res)
1050     res = ast_register_translator (&lintog726);
1051   else
1052     ast_unregister_translator (&g726tolin);
1053   return res;
1054 }
1055
1056 /*
1057  * Return a description of this module.
1058  */
1059
1060 char *
1061 description (void)
1062 {
1063   return tdesc;
1064 }
1065
1066 int
1067 usecount (void)
1068 {
1069   int res;
1070   STANDARD_USECOUNT (res);
1071   return res;
1072 }
1073
1074 char *
1075 key ()
1076 {
1077   return ASTERISK_GPL_KEY;
1078 }