Merged revisions 65877 via svnmerge from
[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
180                 /* Encode a frame of data */
181                 for (i = 0 ; i < ILBC_SAMPLES ; i++)
182                         tmpf[i] = tmp->buf[samples + i];
183                 iLBC_encode((unsigned char *) pvt->outbuf + datalen, tmpf, &tmp->enc);
184
185                 datalen += ILBC_FRAME_LEN;
186                 samples += ILBC_SAMPLES;
187                 pvt->samples -= ILBC_SAMPLES;
188         }
189
190         /* Move the data at the end of the buffer to the front */
191         if (pvt->samples)
192                 memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2);
193
194         return ast_trans_frameout(pvt, datalen, samples);
195 }
196
197 static struct ast_translator ilbctolin = {
198         .name = "ilbctolin", 
199         .srcfmt = AST_FORMAT_ILBC,
200         .dstfmt = AST_FORMAT_SLINEAR,
201         .newpvt = ilbctolin_new,
202         .framein = ilbctolin_framein,
203         .sample = ilbctolin_sample,
204         .desc_size = sizeof(struct ilbc_coder_pvt),
205         .buf_size = BUFFER_SAMPLES * 2,
206         .native_plc = 1,
207 };
208
209 static struct ast_translator lintoilbc = {
210         .name = "lintoilbc", 
211         .srcfmt = AST_FORMAT_SLINEAR,
212         .dstfmt = AST_FORMAT_ILBC,
213         .newpvt = lintoilbc_new,
214         .framein = lintoilbc_framein,
215         .frameout = lintoilbc_frameout,
216         .sample = lintoilbc_sample,
217         .desc_size = sizeof(struct ilbc_coder_pvt),
218         .buf_size = (BUFFER_SAMPLES * ILBC_FRAME_LEN + ILBC_SAMPLES - 1) / ILBC_SAMPLES,
219 };
220
221 static int unload_module(void)
222 {
223         int res;
224
225         res = ast_unregister_translator(&lintoilbc);
226         res |= ast_unregister_translator(&ilbctolin);
227
228         return res;
229 }
230
231 static int load_module(void)
232 {
233         int res;
234
235         res = ast_register_translator(&ilbctolin);
236         if (!res) 
237                 res=ast_register_translator(&lintoilbc);
238         else
239                 ast_unregister_translator(&ilbctolin);
240
241         return res;
242 }
243
244 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "iLBC Coder/Decoder");