Merged revisions 278023 via svnmerge from
[asterisk/asterisk.git] / codecs / codec_gsm.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * The GSM code is from TOAST.  Copyright information for that package is available
5  * in the GSM directory.
6  *
7  * Copyright (C) 1999 - 2005, Digium, Inc.
8  *
9  * Mark Spencer <markster@digium.com>
10  *
11  * See http://www.asterisk.org for more information about
12  * the Asterisk project. Please do not directly contact
13  * any of the maintainers of this project for assistance;
14  * the project provides a web site, mailing lists and IRC
15  * channels for your use.
16  *
17  * This program is free software, distributed under the terms of
18  * the GNU General Public License Version 2. See the LICENSE file
19  * at the top of the source tree.
20  */
21
22 /*! \file
23  *
24  * \brief Translate between signed linear and Global System for Mobile Communications (GSM)
25  *
26  * \ingroup codecs
27  */
28
29 /*** MODULEINFO
30         <depend>gsm</depend>
31  ***/
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include "asterisk/translate.h"
38 #include "asterisk/config.h"
39 #include "asterisk/module.h"
40 #include "asterisk/utils.h"
41
42 #ifdef HAVE_GSM_HEADER
43 #include "gsm.h"
44 #elif defined(HAVE_GSM_GSM_HEADER)
45 #include <gsm/gsm.h>
46 #endif
47
48 #include "../formats/msgsm.h"
49
50 #define BUFFER_SAMPLES  8000
51 #define GSM_SAMPLES     160
52 #define GSM_FRAME_LEN   33
53 #define MSGSM_FRAME_LEN 65
54
55 /* Sample frame data */
56 #include "asterisk/slin.h"
57 #include "ex_gsm.h"
58
59 struct gsm_translator_pvt {     /* both gsm2lin and lin2gsm */
60         gsm gsm;
61         int16_t buf[BUFFER_SAMPLES];    /* lin2gsm, temporary storage */
62 };
63
64 static int gsm_new(struct ast_trans_pvt *pvt)
65 {
66         struct gsm_translator_pvt *tmp = pvt->pvt;
67         
68         return (tmp->gsm = gsm_create()) ? 0 : -1;
69 }
70
71 /*! \brief decode and store in outbuf. */
72 static int gsmtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
73 {
74         struct gsm_translator_pvt *tmp = pvt->pvt;
75         int x;
76         int16_t *dst = pvt->outbuf.i16;
77         /* guess format from frame len. 65 for MSGSM, 33 for regular GSM */
78         int flen = (f->datalen % MSGSM_FRAME_LEN == 0) ?
79                 MSGSM_FRAME_LEN : GSM_FRAME_LEN;
80
81         for (x=0; x < f->datalen; x += flen) {
82                 unsigned char data[2 * GSM_FRAME_LEN];
83                 unsigned char *src;
84                 int len;
85                 if (flen == MSGSM_FRAME_LEN) {
86                         len = 2*GSM_SAMPLES;
87                         src = data;
88                         /* Translate MSGSM format to Real GSM format before feeding in */
89                         /* XXX what's the point here! we should just work
90                          * on the full format.
91                          */
92                         conv65(f->data.ptr + x, data);
93                 } else {
94                         len = GSM_SAMPLES;
95                         src = f->data.ptr + x;
96                 }
97                 /* XXX maybe we don't need to check */
98                 if (pvt->samples + len > BUFFER_SAMPLES) {      
99                         ast_log(LOG_WARNING, "Out of buffer space\n");
100                         return -1;
101                 }
102                 if (gsm_decode(tmp->gsm, src, dst + pvt->samples)) {
103                         ast_log(LOG_WARNING, "Invalid GSM data (1)\n");
104                         return -1;
105                 }
106                 pvt->samples += GSM_SAMPLES;
107                 pvt->datalen += 2 * GSM_SAMPLES;
108                 if (flen == MSGSM_FRAME_LEN) {
109                         if (gsm_decode(tmp->gsm, data + GSM_FRAME_LEN, dst + pvt->samples)) {
110                                 ast_log(LOG_WARNING, "Invalid GSM data (2)\n");
111                                 return -1;
112                         }
113                         pvt->samples += GSM_SAMPLES;
114                         pvt->datalen += 2 * GSM_SAMPLES;
115                 }
116         }
117         return 0;
118 }
119
120 /*! \brief store samples into working buffer for later decode */
121 static int lintogsm_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
122 {
123         struct gsm_translator_pvt *tmp = pvt->pvt;
124
125         /* XXX We should look at how old the rest of our stream is, and if it
126            is too old, then we should overwrite it entirely, otherwise we can
127            get artifacts of earlier talk that do not belong */
128         if (pvt->samples + f->samples > BUFFER_SAMPLES) {
129                 ast_log(LOG_WARNING, "Out of buffer space\n");
130                 return -1;
131         }
132         memcpy(tmp->buf + pvt->samples, f->data.ptr, f->datalen);
133         pvt->samples += f->samples;
134         return 0;
135 }
136
137 /*! \brief encode and produce a frame */
138 static struct ast_frame *lintogsm_frameout(struct ast_trans_pvt *pvt)
139 {
140         struct gsm_translator_pvt *tmp = pvt->pvt;
141         int datalen = 0;
142         int samples = 0;
143
144         /* We can't work on anything less than a frame in size */
145         if (pvt->samples < GSM_SAMPLES)
146                 return NULL;
147         while (pvt->samples >= GSM_SAMPLES) {
148                 /* Encode a frame of data */
149                 gsm_encode(tmp->gsm, tmp->buf + samples, (gsm_byte *) pvt->outbuf.c + datalen);
150                 datalen += GSM_FRAME_LEN;
151                 samples += GSM_SAMPLES;
152                 pvt->samples -= GSM_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 void gsm_destroy_stuff(struct ast_trans_pvt *pvt)
163 {
164         struct gsm_translator_pvt *tmp = pvt->pvt;
165         if (tmp->gsm)
166                 gsm_destroy(tmp->gsm);
167 }
168
169 static struct ast_translator gsmtolin = {
170         .name = "gsmtolin", 
171         .srcfmt = AST_FORMAT_GSM,
172         .dstfmt = AST_FORMAT_SLINEAR,
173         .newpvt = gsm_new,
174         .framein = gsmtolin_framein,
175         .destroy = gsm_destroy_stuff,
176         .sample = gsm_sample,
177         .buffer_samples = BUFFER_SAMPLES,
178         .buf_size = BUFFER_SAMPLES * 2,
179         .desc_size = sizeof (struct gsm_translator_pvt ),
180 };
181
182 static struct ast_translator lintogsm = {
183         .name = "lintogsm", 
184         .srcfmt = AST_FORMAT_SLINEAR,
185         .dstfmt = AST_FORMAT_GSM,
186         .newpvt = gsm_new,
187         .framein = lintogsm_framein,
188         .frameout = lintogsm_frameout,
189         .destroy = gsm_destroy_stuff,
190         .sample = slin8_sample,
191         .desc_size = sizeof (struct gsm_translator_pvt ),
192         .buf_size = (BUFFER_SAMPLES * GSM_FRAME_LEN + GSM_SAMPLES - 1)/GSM_SAMPLES,
193 };
194
195 /*! \brief standard module glue */
196 static int reload(void)
197 {
198         return AST_MODULE_LOAD_SUCCESS;
199 }
200
201 static int unload_module(void)
202 {
203         int res;
204
205         res = ast_unregister_translator(&lintogsm);
206         if (!res)
207                 res = ast_unregister_translator(&gsmtolin);
208
209         return res;
210 }
211
212 static int load_module(void)
213 {
214         int res;
215
216         res = ast_register_translator(&gsmtolin);
217         if (!res) 
218                 res=ast_register_translator(&lintogsm);
219         else
220                 ast_unregister_translator(&gsmtolin);
221         if (res) 
222                 return AST_MODULE_LOAD_FAILURE;
223         return AST_MODULE_LOAD_SUCCESS;
224 }
225
226 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "GSM Coder/Decoder",
227                 .load = load_module,
228                 .unload = unload_module,
229                 .reload = reload,
230                );