98d410e38f93e0ca8bf931473f89047013817863
[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 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <fcntl.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <netinet/in.h>
36 #include <string.h>
37 #include <stdio.h>
38
39 #include "asterisk/lock.h"
40 #include "asterisk/translate.h"
41 #include "asterisk/module.h"
42 #include "asterisk/logger.h"
43 #include "asterisk/channel.h"
44 #include "asterisk/utils.h"
45
46 #include "ilbc/iLBC_encode.h"
47 #include "ilbc/iLBC_decode.h"
48
49 /* Sample frame data */
50 #include "slin_ilbc_ex.h"
51 #include "ilbc_slin_ex.h"
52
53 #define USE_ILBC_ENHANCER       0
54 #define ILBC_MS                         30
55 /* #define ILBC_MS                      20 */
56
57 #define ILBC_FRAME_LEN  50      /* apparently... */
58 #define ILBC_SAMPLES    240     /* 30ms at 8000 hz */
59 #define BUFFER_SAMPLES  8000
60
61 struct ilbc_coder_pvt {
62         iLBC_Enc_Inst_t enc;
63         iLBC_Dec_Inst_t dec;
64         /* Enough to store a full second */
65         int16_t buf[BUFFER_SAMPLES];
66 };
67
68 static int lintoilbc_new(struct ast_trans_pvt *pvt)
69 {
70         struct ilbc_coder_pvt *tmp = pvt->pvt;
71
72         initEncode(&tmp->enc, ILBC_MS);
73
74         return 0;
75 }
76
77 static int ilbctolin_new(struct ast_trans_pvt *pvt)
78 {
79         struct ilbc_coder_pvt *tmp = pvt->pvt;
80
81         initDecode(&tmp->dec, ILBC_MS, USE_ILBC_ENHANCER);
82
83         return 0;
84 }
85
86 static struct ast_frame *lintoilbc_sample(void)
87 {
88         static struct ast_frame f;
89         f.frametype = AST_FRAME_VOICE;
90         f.subclass = AST_FORMAT_SLINEAR;
91         f.datalen = sizeof(slin_ilbc_ex);
92         f.samples = sizeof(slin_ilbc_ex)/2;
93         f.mallocd = 0;
94         f.offset = 0;
95         f.src = __PRETTY_FUNCTION__;
96         f.data = slin_ilbc_ex;
97         return &f;
98 }
99
100 static struct ast_frame *ilbctolin_sample(void)
101 {
102         static struct ast_frame f;
103         f.frametype = AST_FRAME_VOICE;
104         f.subclass = AST_FORMAT_ILBC;
105         f.datalen = sizeof(ilbc_slin_ex);
106         /* All frames are 30 ms long */
107         f.samples = ILBC_SAMPLES;
108         f.mallocd = 0;
109         f.offset = 0;
110         f.src = __PRETTY_FUNCTION__;
111         f.data = ilbc_slin_ex;
112         return &f;
113 }
114
115 /*! \brief decode a frame and store in outbuf */
116 static int ilbctolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
117 {
118         struct ilbc_coder_pvt *tmp = pvt->pvt;
119         int plc_mode = 1; /* 1 = normal data, 0 = plc */
120         /* Assuming there's space left, decode into the current buffer at
121            the tail location.  Read in as many frames as there are */
122         int x,i;
123         int16_t *dst = (int16_t *)pvt->outbuf;
124         float tmpf[ILBC_SAMPLES];
125
126         if (f->datalen == 0) { /* native PLC, set fake f->datalen and clear plc_mode */
127                 f->datalen = ILBC_FRAME_LEN;
128                 f->samples = ILBC_SAMPLES;
129                 plc_mode = 0;   /* do native plc */
130                 pvt->samples += ILBC_SAMPLES;
131         }
132
133         if (f->datalen % ILBC_FRAME_LEN) {
134                 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);
135                 return -1;
136         }
137         
138         for (x=0; x < f->datalen ; x += ILBC_FRAME_LEN) {
139                 if (pvt->samples + ILBC_SAMPLES > BUFFER_SAMPLES) {     
140                         ast_log(LOG_WARNING, "Out of buffer space\n");
141                         return -1;
142                 }               
143                 iLBC_decode(tmpf, plc_mode ? f->data + x : NULL, &tmp->dec, plc_mode);
144                 for ( i=0; i < ILBC_SAMPLES; i++)
145                         dst[pvt->samples + i] = tmpf[i];
146                 pvt->samples += ILBC_SAMPLES;
147                 pvt->datalen += 2*ILBC_SAMPLES;
148         }
149         return 0;
150 }
151
152 /*! \brief store a frame into a temporary buffer, for later decoding */
153 static int lintoilbc_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
154 {
155         struct ilbc_coder_pvt *tmp = pvt->pvt;
156
157         /* Just add the frames to our stream */
158         /* XXX We should look at how old the rest of our stream is, and if it
159            is too old, then we should overwrite it entirely, otherwise we can
160            get artifacts of earlier talk that do not belong */
161         memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
162         pvt->samples += f->samples;
163         return 0;
164 }
165
166 /*! \brief encode the temporary buffer and generate a frame */
167 static struct ast_frame *lintoilbc_frameout(struct ast_trans_pvt *pvt)
168 {
169         struct ilbc_coder_pvt *tmp = pvt->pvt;
170         int datalen = 0;
171         int samples = 0;
172
173         /* We can't work on anything less than a frame in size */
174         if (pvt->samples < ILBC_SAMPLES)
175                 return NULL;
176         while (pvt->samples >= ILBC_SAMPLES) {
177                 float tmpf[ILBC_SAMPLES];
178                 int i;
179                 /* Encode a frame of data */
180                 for ( i = 0 ; i < ILBC_SAMPLES ; i++ )
181                         tmpf[i] = tmp->buf[i];
182                 iLBC_encode((unsigned char *) pvt->outbuf + datalen, tmpf, &tmp->enc);
183                 datalen += ILBC_FRAME_LEN;
184                 samples += ILBC_SAMPLES;
185                 pvt->samples -= ILBC_SAMPLES;
186                 /* Move the data at the end of the buffer to the front */
187                 if (pvt->samples)
188                         memmove(tmp->buf, tmp->buf + ILBC_SAMPLES, pvt->samples * 2);
189         }
190         return ast_trans_frameout(pvt, datalen, samples);
191 }
192
193 static struct ast_translator ilbctolin = {
194         .name = "ilbctolin", 
195         .srcfmt = AST_FORMAT_ILBC,
196         .dstfmt = AST_FORMAT_SLINEAR,
197         .newpvt = ilbctolin_new,
198         .framein = ilbctolin_framein,
199         .sample = ilbctolin_sample,
200         .desc_size = sizeof(struct ilbc_coder_pvt),
201         .buf_size = BUFFER_SAMPLES * 2,
202 };
203
204 static struct ast_translator lintoilbc = {
205         .name = "lintoilbc", 
206         .srcfmt = AST_FORMAT_SLINEAR,
207         .dstfmt = AST_FORMAT_ILBC,
208         .newpvt = lintoilbc_new,
209         .framein = lintoilbc_framein,
210         .frameout = lintoilbc_frameout,
211         .sample = lintoilbc_sample,
212         .desc_size = sizeof(struct ilbc_coder_pvt),
213         .buf_size = (BUFFER_SAMPLES * ILBC_FRAME_LEN + ILBC_SAMPLES - 1) / ILBC_SAMPLES,
214 };
215
216 static int unload_module(void)
217 {
218         int res;
219
220         res = ast_unregister_translator(&lintoilbc);
221         res |= ast_unregister_translator(&ilbctolin);
222
223         return res;
224 }
225
226 static int load_module(void)
227 {
228         int res;
229
230         res = ast_register_translator(&ilbctolin);
231         if (!res) 
232                 res=ast_register_translator(&lintoilbc);
233         else
234                 ast_unregister_translator(&ilbctolin);
235
236         return res;
237 }
238
239 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "iLBC Coder/Decoder");