11541f5895172ab0f95edbaefac97929133fc0f3
[asterisk/asterisk.git] / codecs / codec_a_mu.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief codec_a_mu.c - translate between alaw and ulaw directly
22  *
23  * \ingroup codecs
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include <fcntl.h>
31
32 #include "asterisk/module.h"
33 #include "asterisk/translate.h"
34 #include "asterisk/alaw.h"
35 #include "asterisk/ulaw.h"
36 #include "asterisk/utils.h"
37
38 #define BUFFER_SAMPLES   8000   /* size for the translation buffers */
39
40 static unsigned char mu2a[256];
41 static unsigned char a2mu[256];
42
43 /* Sample frame data (Mu data is okay) */
44
45 #include "ulaw_slin_ex.h"
46
47 /*! \brief convert frame data and store into the buffer */
48 static int alawtoulaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
49 {
50         int x = f->samples;
51         unsigned char *src = f->data;
52         unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
53
54         pvt->samples += x;
55         pvt->datalen += x;
56
57         while (x--)
58                 *dst++ = a2mu[*src++];
59
60         return 0;
61 }
62
63 /*! \brief convert frame data and store into the buffer */
64 static int ulawtoalaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
65 {
66         int x = f->samples;
67         unsigned char *src = f->data;
68         unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
69
70         pvt->samples += x;
71         pvt->datalen += x;
72
73         while (x--)
74                 *dst++ = mu2a[*src++];
75
76         return 0;
77 }
78
79 /*
80  * alawToLin_Sample. Just random data, somehow...
81  */
82 static struct ast_frame *alawtoulaw_sample(void)
83 {
84         static struct ast_frame f;
85         f.frametype = AST_FRAME_VOICE;
86         f.subclass = AST_FORMAT_ALAW;
87         f.datalen = sizeof(ulaw_slin_ex);
88         f.samples = sizeof(ulaw_slin_ex);
89         f.mallocd = 0;
90         f.offset = 0;
91         f.src = __PRETTY_FUNCTION__;
92         f.data = ulaw_slin_ex; /* XXX what ? */
93         return &f;
94 }
95
96 static struct ast_frame *ulawtoalaw_sample(void)
97 {
98         static struct ast_frame f;
99         f.frametype = AST_FRAME_VOICE;
100         f.subclass = AST_FORMAT_ULAW;
101         f.datalen = sizeof(ulaw_slin_ex);
102         f.samples = sizeof(ulaw_slin_ex);
103         f.mallocd = 0;
104         f.offset = 0;
105         f.src = __PRETTY_FUNCTION__;
106         f.data = ulaw_slin_ex;
107         return &f;
108 }
109
110 static struct ast_translator alawtoulaw = {
111         .name = "alawtoulaw",
112         .srcfmt = AST_FORMAT_ALAW,
113         .dstfmt = AST_FORMAT_ULAW,
114         .framein = alawtoulaw_framein,
115         .sample = alawtoulaw_sample,
116         .buffer_samples = BUFFER_SAMPLES,
117         .buf_size = BUFFER_SAMPLES,
118 };
119
120 static struct ast_translator ulawtoalaw = {
121         .name = "ulawtoalaw",
122         .srcfmt = AST_FORMAT_ULAW,
123         .dstfmt = AST_FORMAT_ALAW,
124         .framein = ulawtoalaw_framein,
125         .sample = ulawtoalaw_sample,
126         .buffer_samples = BUFFER_SAMPLES,
127         .buf_size = BUFFER_SAMPLES,
128 };
129
130 /*! \brief standard module glue */
131
132 static int unload_module(void)
133 {
134         int res;
135
136         res = ast_unregister_translator(&ulawtoalaw);
137         res |= ast_unregister_translator(&alawtoulaw);
138
139         return res;
140 }
141
142 static int load_module(void)
143 {
144         int res;
145         int x;
146
147         for (x=0;x<256;x++) {
148                 mu2a[x] = AST_LIN2A(AST_MULAW(x));
149                 a2mu[x] = AST_LIN2MU(AST_ALAW(x));
150         }
151         res = ast_register_translator(&alawtoulaw);
152         if (!res)
153                 res = ast_register_translator(&ulawtoalaw);
154         else
155                 ast_unregister_translator(&alawtoulaw);
156         if (res)
157                 return AST_MODULE_LOAD_FAILURE;
158         return AST_MODULE_LOAD_SUCCESS;
159 }
160
161 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "A-law and Mulaw direct Coder/Decoder");