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