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