Make the menuselect category for Add-Ons consistent with the other directories (upper...
[asterisk/asterisk.git] / codecs / codec_ilbc.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * The iLBC code is from The IETF code base and is copyright The Internet Society (2004)
5  *
6  * Copyright (C) 1999 - 2005, Digium, Inc.
7  *
8  * Mark Spencer <markster@digium.com>
9  *
10  * See http://www.asterisk.org for more information about
11  * the Asterisk project. Please do not directly contact
12  * any of the maintainers of this project for assistance;
13  * the project provides a web site, mailing lists and IRC
14  * channels for your use.
15  *
16  * This program is free software, distributed under the terms of
17  * the GNU General Public License Version 2. See the LICENSE file
18  * at the top of the source tree.
19  */
20
21 /*! \file
22  *
23  * \brief Translate between signed linear and Internet Low Bitrate Codec
24  * 
25  * \ingroup codecs
26  */
27
28 /*** MODULEINFO
29         <defaultenabled>no</defaultenabled>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/translate.h"
37 #include "asterisk/module.h"
38 #include "asterisk/utils.h"
39
40 #include "ilbc/iLBC_encode.h"
41 #include "ilbc/iLBC_decode.h"
42
43 #define USE_ILBC_ENHANCER       0
44 #define ILBC_MS                         30
45 /* #define ILBC_MS                      20 */
46
47 #define ILBC_FRAME_LEN  50      /* apparently... */
48 #define ILBC_SAMPLES    240     /* 30ms at 8000 hz */
49 #define BUFFER_SAMPLES  8000
50
51 /* Sample frame data */
52 #include "asterisk/slin.h"
53 #include "ex_ilbc.h"
54
55 struct ilbc_coder_pvt {
56         iLBC_Enc_Inst_t enc;
57         iLBC_Dec_Inst_t dec;
58         /* Enough to store a full second */
59         int16_t buf[BUFFER_SAMPLES];
60 };
61
62 static int lintoilbc_new(struct ast_trans_pvt *pvt)
63 {
64         struct ilbc_coder_pvt *tmp = pvt->pvt;
65
66         initEncode(&tmp->enc, ILBC_MS);
67
68         return 0;
69 }
70
71 static int ilbctolin_new(struct ast_trans_pvt *pvt)
72 {
73         struct ilbc_coder_pvt *tmp = pvt->pvt;
74
75         initDecode(&tmp->dec, ILBC_MS, USE_ILBC_ENHANCER);
76
77         return 0;
78 }
79
80 /*! \brief decode a frame and store in outbuf */
81 static int ilbctolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
82 {
83         struct ilbc_coder_pvt *tmp = pvt->pvt;
84         int plc_mode = 1; /* 1 = normal data, 0 = plc */
85         /* Assuming there's space left, decode into the current buffer at
86            the tail location.  Read in as many frames as there are */
87         int x,i;
88         int16_t *dst = pvt->outbuf.i16;
89         float tmpf[ILBC_SAMPLES];
90
91         if (f->datalen == 0) { /* native PLC, set fake f->datalen and clear plc_mode */
92                 f->datalen = ILBC_FRAME_LEN;
93                 f->samples = ILBC_SAMPLES;
94                 plc_mode = 0;   /* do native plc */
95                 pvt->samples += ILBC_SAMPLES;
96         }
97
98         if (f->datalen % ILBC_FRAME_LEN) {
99                 ast_log(LOG_WARNING, "Huh?  An ilbc frame that isn't a multiple of 50 bytes long from %s (%d)?\n", f->src, f->datalen);
100                 return -1;
101         }
102         
103         for (x=0; x < f->datalen ; x += ILBC_FRAME_LEN) {
104                 if (pvt->samples + ILBC_SAMPLES > BUFFER_SAMPLES) {     
105                         ast_log(LOG_WARNING, "Out of buffer space\n");
106                         return -1;
107                 }               
108                 iLBC_decode(tmpf, plc_mode ? f->data.ptr + x : NULL, &tmp->dec, plc_mode);
109                 for ( i=0; i < ILBC_SAMPLES; i++)
110                         dst[pvt->samples + i] = tmpf[i];
111                 pvt->samples += ILBC_SAMPLES;
112                 pvt->datalen += 2*ILBC_SAMPLES;
113         }
114         return 0;
115 }
116
117 /*! \brief store a frame into a temporary buffer, for later decoding */
118 static int lintoilbc_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
119 {
120         struct ilbc_coder_pvt *tmp = pvt->pvt;
121
122         /* Just add the frames to our stream */
123         /* XXX We should look at how old the rest of our stream is, and if it
124            is too old, then we should overwrite it entirely, otherwise we can
125            get artifacts of earlier talk that do not belong */
126         memcpy(tmp->buf + pvt->samples, f->data.ptr, f->datalen);
127         pvt->samples += f->samples;
128         return 0;
129 }
130
131 /*! \brief encode the temporary buffer and generate a frame */
132 static struct ast_frame *lintoilbc_frameout(struct ast_trans_pvt *pvt)
133 {
134         struct ilbc_coder_pvt *tmp = pvt->pvt;
135         int datalen = 0;
136         int samples = 0;
137
138         /* We can't work on anything less than a frame in size */
139         if (pvt->samples < ILBC_SAMPLES)
140                 return NULL;
141         while (pvt->samples >= ILBC_SAMPLES) {
142                 float tmpf[ILBC_SAMPLES];
143                 int i;
144
145                 /* Encode a frame of data */
146                 for (i = 0 ; i < ILBC_SAMPLES ; i++)
147                         tmpf[i] = tmp->buf[samples + i];
148                 iLBC_encode( pvt->outbuf.uc + datalen, tmpf, &tmp->enc);
149
150                 datalen += ILBC_FRAME_LEN;
151                 samples += ILBC_SAMPLES;
152                 pvt->samples -= ILBC_SAMPLES;
153         }
154
155         /* Move the data at the end of the buffer to the front */
156         if (pvt->samples)
157                 memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2);
158
159         return ast_trans_frameout(pvt, datalen, samples);
160 }
161
162 static struct ast_translator ilbctolin = {
163         .name = "ilbctolin", 
164         .srcfmt = AST_FORMAT_ILBC,
165         .dstfmt = AST_FORMAT_SLINEAR,
166         .newpvt = ilbctolin_new,
167         .framein = ilbctolin_framein,
168         .sample = ilbc_sample,
169         .desc_size = sizeof(struct ilbc_coder_pvt),
170         .buf_size = BUFFER_SAMPLES * 2,
171         .native_plc = 1,
172 };
173
174 static struct ast_translator lintoilbc = {
175         .name = "lintoilbc", 
176         .srcfmt = AST_FORMAT_SLINEAR,
177         .dstfmt = AST_FORMAT_ILBC,
178         .newpvt = lintoilbc_new,
179         .framein = lintoilbc_framein,
180         .frameout = lintoilbc_frameout,
181         .sample = slin8_sample,
182         .desc_size = sizeof(struct ilbc_coder_pvt),
183         .buf_size = (BUFFER_SAMPLES * ILBC_FRAME_LEN + ILBC_SAMPLES - 1) / ILBC_SAMPLES,
184 };
185
186 static int unload_module(void)
187 {
188         int res;
189
190         res = ast_unregister_translator(&lintoilbc);
191         res |= ast_unregister_translator(&ilbctolin);
192
193         return res;
194 }
195
196 static int load_module(void)
197 {
198         int res;
199
200         res = ast_register_translator(&ilbctolin);
201         if (!res) 
202                 res=ast_register_translator(&lintoilbc);
203         else
204                 ast_unregister_translator(&ilbctolin);
205         if (res)
206                 return AST_MODULE_LOAD_FAILURE;
207         return AST_MODULE_LOAD_SUCCESS;
208 }
209
210 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "iLBC Coder/Decoder");