Asterisk media architecture conversion - no more format bitfields
[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         .newpvt = gsm_new,
172         .framein = gsmtolin_framein,
173         .destroy = gsm_destroy_stuff,
174         .sample = gsm_sample,
175         .buffer_samples = BUFFER_SAMPLES,
176         .buf_size = BUFFER_SAMPLES * 2,
177         .desc_size = sizeof (struct gsm_translator_pvt ),
178 };
179
180 static struct ast_translator lintogsm = {
181         .name = "lintogsm", 
182         .newpvt = gsm_new,
183         .framein = lintogsm_framein,
184         .frameout = lintogsm_frameout,
185         .destroy = gsm_destroy_stuff,
186         .sample = slin8_sample,
187         .desc_size = sizeof (struct gsm_translator_pvt ),
188         .buf_size = (BUFFER_SAMPLES * GSM_FRAME_LEN + GSM_SAMPLES - 1)/GSM_SAMPLES,
189 };
190
191 /*! \brief standard module glue */
192 static int reload(void)
193 {
194         return AST_MODULE_LOAD_SUCCESS;
195 }
196
197 static int unload_module(void)
198 {
199         int res;
200
201         res = ast_unregister_translator(&lintogsm);
202         if (!res)
203                 res = ast_unregister_translator(&gsmtolin);
204
205         return res;
206 }
207
208 static int load_module(void)
209 {
210         int res;
211
212         ast_format_set(&gsmtolin.src_format, AST_FORMAT_GSM, 0);
213         ast_format_set(&gsmtolin.dst_format, AST_FORMAT_SLINEAR, 0);
214
215         ast_format_set(&lintogsm.src_format, AST_FORMAT_SLINEAR, 0);
216         ast_format_set(&lintogsm.dst_format, AST_FORMAT_GSM, 0);
217
218         res = ast_register_translator(&gsmtolin);
219         if (!res) 
220                 res=ast_register_translator(&lintogsm);
221         else
222                 ast_unregister_translator(&gsmtolin);
223         if (res) 
224                 return AST_MODULE_LOAD_FAILURE;
225         return AST_MODULE_LOAD_SUCCESS;
226 }
227
228 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "GSM Coder/Decoder",
229                 .load = load_module,
230                 .unload = unload_module,
231                 .reload = reload,
232                );