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