d271dfe51242a7ea1e3fedaf3da729bc7c7ee9ad
[asterisk/asterisk.git] / codecs / codec_mp3_d.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * MP3 Decoder
5  *
6  * The MP3 code is from freeamp, which in turn is from xingmp3's release
7  * which I can't seem to find anywhere
8  * 
9  * Copyright (C) 1999, Mark Spencer
10  *
11  * Mark Spencer <markster@linux-support.net>
12  *
13  * This program is free software, distributed under the terms of
14  * the GNU General Public License
15  */
16
17 #include <asterisk/translate.h>
18 #include <asterisk/module.h>
19 #include <asterisk/logger.h>
20 #include <asterisk/channel.h>
21 #include <pthread.h>
22 #include <fcntl.h>
23 #include <errno.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <netinet/in.h>
27 #include <string.h>
28 #include <stdio.h>
29
30 #include "mp3/include/L3.h"
31 #include "mp3/include/mhead.h"
32
33 #include "mp3anal.h"
34
35 /* Sample frame data */
36 #include "mp3_slin_ex.h"
37
38 #define MAX_OUT_FRAME 320
39
40 #define MAX_FRAME_SIZE 1441
41 #define MAX_OUTPUT_LEN 2304
42
43 static pthread_mutex_t localuser_lock = PTHREAD_MUTEX_INITIALIZER;
44 static int localusecnt=0;
45
46 static char *tdesc = "MP3/PCM16 (signed linear) Translator (Decoder only)";
47
48 struct ast_translator_pvt {
49         MPEG m;
50         MPEG_HEAD head;
51         DEC_INFO info;
52         struct ast_frame f;
53         /* Space to build offset */
54         char offset[AST_FRIENDLY_OFFSET];
55         /* Mini buffer */
56         char outbuf[MAX_OUT_FRAME];
57         /* Enough to store a full second */
58         short buf[32000];
59         /* Tail of signed linear stuff */
60         int tail;
61         /* Current bitrate */
62         int bitrate;
63         /* XXX What's forward? XXX */
64         int forward;
65         /* Have we called head info yet? */
66         int init;
67         int copy;
68 };
69
70 #define mp3_coder_pvt ast_translator_pvt
71
72 static struct ast_translator_pvt *mp3_new()
73 {
74         struct mp3_coder_pvt *tmp;
75         tmp = malloc(sizeof(struct mp3_coder_pvt));
76         if (tmp) {
77                 tmp->init = 0;
78                 tmp->tail = 0;
79                 tmp->copy = -1;
80                 mpeg_init(&tmp->m);
81         }
82         return tmp;
83 }
84
85 static struct ast_frame *mp3tolin_sample()
86 {
87         static struct ast_frame f;
88         int size;
89         if (mp3_badheader(mp3_slin_ex)) {
90                 ast_log(LOG_WARNING, "Bad MP3 sample??\n");
91                 return NULL;
92         }
93         size = mp3_framelen(mp3_slin_ex);
94         if (size < 1) {
95                 ast_log(LOG_WARNING, "Failed to size??\n");
96                 return NULL;
97         }
98         f.frametype = AST_FRAME_VOICE;
99         f.subclass = AST_FORMAT_MP3;
100         f.data = mp3_slin_ex;
101         f.datalen = sizeof(mp3_slin_ex);
102         /* Dunno how long an mp3 frame is -- kinda irrelevant anyway */
103         f.timelen = 30;
104         f.mallocd = 0;
105         f.offset = 0;
106         f.src = __PRETTY_FUNCTION__;
107         return &f;
108 }
109
110 static struct ast_frame *mp3tolin_frameout(struct ast_translator_pvt *tmp)
111 {
112         if (!tmp->tail)
113                 return NULL;
114         /* Signed linear is no particular frame size, so just send whatever
115            we have in the buffer in one lump sum */
116         tmp->f.frametype = AST_FRAME_VOICE;
117         tmp->f.subclass = AST_FORMAT_SLINEAR;
118         tmp->f.datalen = tmp->tail * 2;
119         /* Assume 8000 Hz */
120         tmp->f.timelen = tmp->tail / 8;
121         tmp->f.mallocd = 0;
122         tmp->f.offset = AST_FRIENDLY_OFFSET;
123         tmp->f.src = __PRETTY_FUNCTION__;
124         tmp->f.data = tmp->buf;
125         /* Reset tail pointer */
126         tmp->tail = 0;
127
128 #if 0
129         /* Save a sample frame */
130         {
131                 static int fd = -1;
132                 if (fd < 0) 
133                         fd = open("mp3out.raw", O_WRONLY | O_CREAT | O_TRUNC, 0644);
134                 write(fd, tmp->f.data, tmp->f.datalen);
135         }               
136 #endif
137         return &tmp->f; 
138 }
139
140 static int mp3_init(struct ast_translator_pvt *tmp, int len)
141 {       
142         if (!audio_decode_init(&tmp->m, &tmp->head, len,0,0,1 /* Convert to mono */,24000)) {
143                 ast_log(LOG_WARNING, "audio_decode_init() failed\n");
144                 return -1;
145         }
146         audio_decode_info(&tmp->m, &tmp->info);
147 #if 0
148         ast_verbose(
149 "Channels: %d\nOutValues: %d\nSample Rate: %d\nBits: %d\nFramebytes: %d\nType: %d\n",
150         tmp->info.channels, tmp->info.outvalues, tmp->info.samprate, tmp->info.bits,tmp->info.framebytes,tmp->info.type);
151 #endif
152         return 0;
153 }
154
155 #ifndef MIN
156 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
157 #endif
158
159 #if 1
160 static int add_to_buf(short *dst, int maxdst, short *src, int srclen, int samprate)
161 {
162         float inc, cur, sum=0;
163         int cnt=0, pos, ptr, lastpos = -1;
164         /* Resample source to destination converting from its sampling rate to 8000 Hz */
165         if (samprate == 8000) {
166                 /* Quickly, all we have to do is copy */
167                 memcpy(dst, src, 2 * MIN(maxdst, srclen));
168                 return MIN(maxdst, srclen);
169         }
170         if (samprate < 8000) {
171                 ast_log(LOG_WARNING, "Don't know how to resample a source less than 8000 Hz!\n");
172                 /* XXX Wrong thing to do XXX */
173                 memcpy(dst, src, 2 * MIN(maxdst, srclen));
174                 return MIN(maxdst, srclen);
175         }
176         /* Ugh, we actually *have* to resample */
177         inc = 8000.0 / (float)samprate;
178         cur = 0;
179         ptr = 0;
180         pos = 0;
181 #if 0
182         ast_verbose("Incrementing by %f, in = %d bytes, out = %d bytes\n", inc, srclen, maxdst);
183 #endif
184         while((pos < maxdst) && (ptr < srclen)) {
185                 if (pos != lastpos) {
186                         if (lastpos > -1) {
187                                 sum = sum / (float)cnt;
188                                 dst[pos - 1] = (int) sum;
189 #if 0
190                                 ast_verbose("dst[%d] = %d\n", pos - 1, dst[pos - 1]);
191 #endif
192                         }
193                         /* Each time we have a first pass */
194                         sum = 0;
195                         cnt = 0;
196                 } else {
197                         sum += src[ptr];
198                 }
199                 ptr++;
200                 cur += inc;
201                 cnt++;
202                 lastpos = pos;
203                 pos = (int)cur;
204         }
205         return pos;
206 }
207 #endif
208
209 static int mp3tolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
210 {
211         /* Assuming there's space left, decode into the current buffer at
212            the tail location */
213         int framelen;
214         short tmpbuf[8000];
215         IN_OUT x;
216 #if 0
217         if (tmp->copy < 0) {
218                 tmp->copy = open("sample.out", O_WRONLY | O_CREAT | O_TRUNC, 0700);
219         }
220         if (tmp->copy > -1)
221                 write(tmp->copy, f->data, f->datalen);
222 #endif
223         /* Check if it's a valid frame */
224         if (mp3_badheader((unsigned char *)f->data)) {
225                 ast_log(LOG_WARNING, "Invalid MP3 header\n");
226                 return -1;
227         }
228         if ((framelen = mp3_framelen((unsigned char *)f->data) != f->datalen)) {
229                 ast_log(LOG_WARNING, "Calculated length %d does not match real length %d\n", framelen, f->datalen);
230                 return -1;
231         }
232         /* Start by putting this in the mp3 buffer */
233         if((framelen = head_info3(f->data, 
234                         f->datalen, &tmp->head, &tmp->bitrate, &tmp->forward)) > 0) {
235                 if (!tmp->init) {
236                         if (mp3_init(tmp, framelen))
237                                 return -1;
238                         else
239                                 tmp->init++;
240                 }
241                 if (tmp->tail + MAX_OUTPUT_LEN/2  < sizeof(tmp->buf)/2) {       
242                         x = audio_decode(&tmp->m, f->data, tmpbuf);
243                         audio_decode_info(&tmp->m, &tmp->info);
244                         if (!x.in_bytes) {
245                                 ast_log(LOG_WARNING, "Invalid MP3 data\n");
246                         } else {
247 #if 1
248                                 /* Resample to 8000 Hz */
249                                 tmp->tail += add_to_buf(tmp->buf + tmp->tail, 
250                                    sizeof(tmp->buf) / 2 - tmp->tail, 
251                                            tmpbuf,
252                                            x.out_bytes/2,
253                                            tmp->info.samprate);
254 #else
255                                 memcpy(tmp->buf + tmp->tail, tmpbuf, x.out_bytes);
256                                 /* Signed linear output */
257                                 tmp->tail+=x.out_bytes/2;
258 #endif
259                         }
260                 } else {
261                         ast_log(LOG_WARNING, "Out of buffer space\n");
262                         return -1;
263                 }
264         } else {
265                 ast_log(LOG_WARNING, "Not a valid MP3 frame\n");
266         }
267         return 0;
268 }
269
270 static void mp3_destroy_stuff(struct ast_translator_pvt *pvt)
271 {
272         close(pvt->copy);
273         free(pvt);
274 }
275
276 static struct ast_translator mp3tolin =
277         { "mp3tolin", 
278            AST_FORMAT_MP3, AST_FORMAT_SLINEAR,
279            mp3_new,
280            mp3tolin_framein,
281            mp3tolin_frameout,
282            mp3_destroy_stuff,
283            mp3tolin_sample
284            };
285
286 int unload_module(void)
287 {
288         int res;
289         ast_pthread_mutex_lock(&localuser_lock);
290         res = ast_unregister_translator(&mp3tolin);
291         if (localusecnt)
292                 res = -1;
293         ast_pthread_mutex_unlock(&localuser_lock);
294         return res;
295 }
296
297 int load_module(void)
298 {
299         int res;
300         res=ast_register_translator(&mp3tolin);
301         return res;
302 }
303
304 char *description(void)
305 {
306         return tdesc;
307 }
308
309 int usecount(void)
310 {
311         int res;
312         STANDARD_USECOUNT(res);
313         return res;
314 }
315
316 char *key()
317 {
318         return ASTERISK_GPL_KEY;
319 }