7985a11d67d3711d927c4f50742014ea49b2db70
[asterisk/asterisk.git] / codecs / codec_lpc10.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * The lpc10 code is from a library used by nautilus, modified to be a bit
9  * nicer to the compiler.
10  * See http://www.arl.wustl.edu/~jaf/ 
11  *
12  * See http://www.asterisk.org for more information about
13  * the Asterisk project. Please do not directly contact
14  * any of the maintainers of this project for assistance;
15  * the project provides a web site, mailing lists and IRC
16  * channels for your use.
17  *
18  * This program is free software, distributed under the terms of
19  * the GNU General Public License Version 2. See the LICENSE file
20  * at the top of the source tree.
21  */
22
23 /*! \file
24  *
25  * \brief Translate between signed linear and LPC10 (Linear Predictor Code)
26  *
27  * \ingroup codecs
28  */
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include <fcntl.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <netinet/in.h>
38 #include <string.h>
39 #include <stdio.h>
40
41 #include "asterisk/lock.h"
42 #include "asterisk/translate.h"
43 #include "asterisk/config.h"
44 #include "asterisk/options.h"
45 #include "asterisk/module.h"
46 #include "asterisk/logger.h"
47 #include "asterisk/channel.h"
48 #include "asterisk/utils.h"
49
50 #include "lpc10/lpc10.h"
51
52 /* Sample frame data */
53 #include "slin_lpc10_ex.h"
54 #include "lpc10_slin_ex.h"
55
56 /* We use a very strange format here...  I have no idea why...  The frames are 180
57    samples long, which isn't even an even number of milliseconds...  Not only that
58    but we hvae to waste two bits of each frame to keep them ending on a byte boundary
59    because the frames are 54 bits long */
60
61 #define LPC10_BYTES_IN_COMPRESSED_FRAME (LPC10_BITS_IN_COMPRESSED_FRAME + 7)/8
62
63 #define BUFFER_SAMPLES  8000
64
65 struct lpc10_coder_pvt {
66         union {
67                 struct lpc10_encoder_state *enc;
68                 struct lpc10_decoder_state *dec;
69         } lpc10;
70         /* Enough to store a full second */
71         short buf[BUFFER_SAMPLES];
72         int longer;
73 };
74
75 static int lpc10_enc_new(struct ast_trans_pvt *pvt)
76 {
77         struct lpc10_coder_pvt *tmp = pvt->pvt;
78
79         return (tmp->lpc10.enc = create_lpc10_encoder_state()) ? 0 : -1;
80 }
81
82 static int lpc10_dec_new(struct ast_trans_pvt *pvt)
83 {
84         struct lpc10_coder_pvt *tmp = pvt->pvt;
85
86         return (tmp->lpc10.dec = create_lpc10_decoder_state()) ? 0 : -1;
87 }
88
89 static struct ast_frame *lintolpc10_sample(void)
90 {
91         static struct ast_frame f;
92         f.frametype = AST_FRAME_VOICE;
93         f.subclass = AST_FORMAT_SLINEAR;
94         f.datalen = sizeof(slin_lpc10_ex);
95         /* Assume 8000 Hz */
96         f.samples = LPC10_SAMPLES_PER_FRAME;
97         f.mallocd = 0;
98         f.offset = 0;
99         f.src = __PRETTY_FUNCTION__;
100         f.data = slin_lpc10_ex;
101         return &f;
102 }
103
104 static struct ast_frame *lpc10tolin_sample(void)
105 {
106         static struct ast_frame f;
107         f.frametype = AST_FRAME_VOICE;
108         f.subclass = AST_FORMAT_LPC10;
109         f.datalen = sizeof(lpc10_slin_ex);
110         /* All frames are 22 ms long (maybe a little more -- why did he choose
111            LPC10_SAMPLES_PER_FRAME sample frames anyway?? */
112         f.samples = LPC10_SAMPLES_PER_FRAME;
113         f.mallocd = 0;
114         f.offset = 0;
115         f.src = __PRETTY_FUNCTION__;
116         f.data = lpc10_slin_ex;
117         return &f;
118 }
119
120 static void extract_bits(INT32 *bits, unsigned char *c)
121 {
122         int x;
123         for (x=0;x<LPC10_BITS_IN_COMPRESSED_FRAME;x++) {
124                 if (*c & (0x80 >> (x & 7)))
125                         bits[x] = 1;
126                 else
127                         bits[x] = 0;
128                 if ((x & 7) == 7)
129                         c++;
130         }
131 }
132
133 /* XXX note lpc10_encode() produces one bit per word in bits[] */
134 static void build_bits(unsigned char *c, INT32 *bits)
135 {
136         unsigned char mask=0x80;
137         int x;
138         *c = 0;
139         for (x=0;x<LPC10_BITS_IN_COMPRESSED_FRAME;x++) {
140                 if (bits[x])
141                         *c |= mask;
142                 mask = mask >> 1;
143                 if ((x % 8)==7) {
144                         c++;
145                         *c = 0;
146                         mask = 0x80;
147                 }
148         }
149 }
150
151 static int lpc10tolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
152 {
153         struct lpc10_coder_pvt *tmp = pvt->pvt;
154         int16_t *dst = (int16_t *)pvt->outbuf;
155         int len = 0;
156
157         while (len + LPC10_BYTES_IN_COMPRESSED_FRAME <= f->datalen) {
158                 int x;
159                 float tmpbuf[LPC10_SAMPLES_PER_FRAME];
160                 INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME]; /* XXX see note */
161                 if (pvt->samples + LPC10_SAMPLES_PER_FRAME > BUFFER_SAMPLES) {
162                         ast_log(LOG_WARNING, "Out of buffer space\n");
163                         return -1;
164                 }
165                 extract_bits(bits, f->data + len);
166                 if (lpc10_decode(bits, tmpbuf, tmp->lpc10.dec)) {
167                         ast_log(LOG_WARNING, "Invalid lpc10 data\n");
168                         return -1;
169                 }
170                 for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++) {
171                         /* Convert to a short between -1.0 and 1.0 */
172                         dst[pvt->samples + x] = (int16_t)(32768.0 * tmpbuf[x]);
173                 }
174
175                 pvt->samples += LPC10_SAMPLES_PER_FRAME;
176                 pvt->datalen += 2*LPC10_SAMPLES_PER_FRAME;
177                 len += LPC10_BYTES_IN_COMPRESSED_FRAME;
178         }
179         if (len != f->datalen) 
180                 printf("Decoded %d, expected %d\n", len, f->datalen);
181         return 0;
182 }
183
184 static int lintolpc10_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
185 {
186         struct lpc10_coder_pvt *tmp = pvt->pvt;
187
188         /* Just add the frames to our stream */
189         if (pvt->samples + f->samples > BUFFER_SAMPLES) {
190                 ast_log(LOG_WARNING, "Out of buffer space\n");
191                 return -1;
192         }
193         memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
194         pvt->samples += f->samples;
195         return 0;
196 }
197
198 static struct ast_frame *lintolpc10_frameout(struct ast_trans_pvt *pvt)
199 {
200         struct lpc10_coder_pvt *tmp = pvt->pvt;
201         int x;
202         int datalen = 0;        /* output frame */
203         int samples = 0;        /* output samples */
204         float tmpbuf[LPC10_SAMPLES_PER_FRAME];
205         INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME];     /* XXX what ??? */
206         /* We can't work on anything less than a frame in size */
207         if (pvt->samples < LPC10_SAMPLES_PER_FRAME)
208                 return NULL;
209         while (pvt->samples >=  LPC10_SAMPLES_PER_FRAME) {
210                 /* Encode a frame of data */
211                 for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++)
212                         tmpbuf[x] = (float)tmp->buf[x + samples] / 32768.0;
213                 lpc10_encode(tmpbuf, bits, tmp->lpc10.enc);
214                 build_bits((unsigned char *) pvt->outbuf + datalen, bits);
215                 datalen += LPC10_BYTES_IN_COMPRESSED_FRAME;
216                 samples += LPC10_SAMPLES_PER_FRAME;
217                 pvt->samples -= LPC10_SAMPLES_PER_FRAME;
218                 /* Use one of the two left over bits to record if this is a 22 or 23 ms frame...
219                    important for IAX use */
220                 tmp->longer = 1 - tmp->longer;
221 #if 0   /* what the heck was this for? */
222                 ((char *)(tmp->f.data))[consumed - 1] |= tmp->longer;
223 #endif          
224         }
225         /* Move the data at the end of the buffer to the front */
226         if (pvt->samples)
227                 memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2);
228         return ast_trans_frameout(pvt, datalen, samples);
229 }
230
231
232 static void lpc10_destroy(struct ast_trans_pvt *arg)
233 {
234         struct lpc10_coder_pvt *pvt = arg->pvt;
235         /* Enc and DEC are both just allocated, so they can be freed */
236         free(pvt->lpc10.enc);
237 }
238
239 static struct ast_translator lpc10tolin = {
240         .name = "lpc10tolin", 
241         .srcfmt = AST_FORMAT_LPC10,
242         .dstfmt = AST_FORMAT_SLINEAR,
243         .newpvt = lpc10_dec_new,
244         .framein = lpc10tolin_framein,
245         .destroy = lpc10_destroy,
246         .sample = lpc10tolin_sample,
247         .desc_size = sizeof(struct lpc10_coder_pvt),
248         .buffer_samples = BUFFER_SAMPLES,
249         .plc_samples = LPC10_SAMPLES_PER_FRAME,
250         .buf_size = BUFFER_SAMPLES * 2,
251 };
252
253 static struct ast_translator lintolpc10 = {
254         .name = "lintolpc10", 
255         .srcfmt = AST_FORMAT_SLINEAR,
256         .dstfmt = AST_FORMAT_LPC10,
257         .newpvt = lpc10_enc_new,
258         .framein = lintolpc10_framein,
259         .frameout = lintolpc10_frameout,
260         .destroy = lpc10_destroy,
261         .sample = lintolpc10_sample,
262         .desc_size = sizeof(struct lpc10_coder_pvt),
263         .buffer_samples = BUFFER_SAMPLES,
264         .buf_size = LPC10_BYTES_IN_COMPRESSED_FRAME * (1 + BUFFER_SAMPLES / LPC10_SAMPLES_PER_FRAME),
265 };
266
267 static void parse_config(void)
268 {
269         struct ast_variable *var;
270         struct ast_config *cfg = ast_config_load("codecs.conf");
271         if (!cfg)
272                 return;
273         for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) {
274                if (!strcasecmp(var->name, "genericplc")) {
275                         lpc10tolin.useplc = ast_true(var->value) ? 1 : 0;
276                         if (option_verbose > 2)
277                                ast_verbose(VERBOSE_PREFIX_3 "codec_lpc10: %susing generic PLC\n",
278                                         lpc10tolin.useplc ? "" : "not ");
279                 }
280         }
281         ast_config_destroy(cfg);
282 }
283
284 static int reload(void)
285 {
286         parse_config();
287
288         return 0;
289 }
290
291
292 static int unload_module(void)
293 {
294         int res;
295
296         res = ast_unregister_translator(&lintolpc10);
297         res |= ast_unregister_translator(&lpc10tolin);
298
299         return res;
300 }
301
302 static int load_module(void)
303 {
304         int res;
305
306         parse_config();
307         res=ast_register_translator(&lpc10tolin);
308         if (!res) 
309                 res=ast_register_translator(&lintolpc10);
310         else
311                 ast_unregister_translator(&lpc10tolin);
312
313         return res;
314 }
315
316 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "LPC10 2.4kbps Coder/Decoder",
317                 .load = load_module,
318                 .unload = unload_module,
319                 .reload = reload,
320                );