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