00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034 #include "asterisk.h"
00035
00036 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 328209 $")
00037
00038 #include "asterisk/translate.h"
00039 #include "asterisk/config.h"
00040 #include "asterisk/module.h"
00041 #include "asterisk/utils.h"
00042
00043 #include "lpc10/lpc10.h"
00044
00045
00046 #include "asterisk/slin.h"
00047 #include "ex_lpc10.h"
00048
00049
00050
00051
00052
00053
00054 #define LPC10_BYTES_IN_COMPRESSED_FRAME (LPC10_BITS_IN_COMPRESSED_FRAME + 7)/8
00055
00056 #define BUFFER_SAMPLES 8000
00057
00058 struct lpc10_coder_pvt {
00059 union {
00060 struct lpc10_encoder_state *enc;
00061 struct lpc10_decoder_state *dec;
00062 } lpc10;
00063
00064 short buf[BUFFER_SAMPLES];
00065 int longer;
00066 };
00067
00068 static int lpc10_enc_new(struct ast_trans_pvt *pvt)
00069 {
00070 struct lpc10_coder_pvt *tmp = pvt->pvt;
00071
00072 return (tmp->lpc10.enc = create_lpc10_encoder_state()) ? 0 : -1;
00073 }
00074
00075 static int lpc10_dec_new(struct ast_trans_pvt *pvt)
00076 {
00077 struct lpc10_coder_pvt *tmp = pvt->pvt;
00078
00079 return (tmp->lpc10.dec = create_lpc10_decoder_state()) ? 0 : -1;
00080 }
00081
00082 static void extract_bits(INT32 *bits, unsigned char *c)
00083 {
00084 int x;
00085 for (x=0;x<LPC10_BITS_IN_COMPRESSED_FRAME;x++) {
00086 if (*c & (0x80 >> (x & 7)))
00087 bits[x] = 1;
00088 else
00089 bits[x] = 0;
00090 if ((x & 7) == 7)
00091 c++;
00092 }
00093 }
00094
00095
00096 static void build_bits(unsigned char *c, INT32 *bits)
00097 {
00098 unsigned char mask=0x80;
00099 int x;
00100 *c = 0;
00101 for (x=0;x<LPC10_BITS_IN_COMPRESSED_FRAME;x++) {
00102 if (bits[x])
00103 *c |= mask;
00104 mask = mask >> 1;
00105 if ((x % 8)==7) {
00106 c++;
00107 *c = 0;
00108 mask = 0x80;
00109 }
00110 }
00111 }
00112
00113 static int lpc10tolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
00114 {
00115 struct lpc10_coder_pvt *tmp = pvt->pvt;
00116 int16_t *dst = pvt->outbuf.i16;
00117 int len = 0;
00118
00119 while (len + LPC10_BYTES_IN_COMPRESSED_FRAME <= f->datalen) {
00120 int x;
00121 float tmpbuf[LPC10_SAMPLES_PER_FRAME];
00122 INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME];
00123 if (pvt->samples + LPC10_SAMPLES_PER_FRAME > BUFFER_SAMPLES) {
00124 ast_log(LOG_WARNING, "Out of buffer space\n");
00125 return -1;
00126 }
00127 extract_bits(bits, f->data.ptr + len);
00128 if (lpc10_decode(bits, tmpbuf, tmp->lpc10.dec)) {
00129 ast_log(LOG_WARNING, "Invalid lpc10 data\n");
00130 return -1;
00131 }
00132 for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++) {
00133
00134 dst[pvt->samples + x] = (int16_t)(32768.0 * tmpbuf[x]);
00135 }
00136
00137 pvt->samples += LPC10_SAMPLES_PER_FRAME;
00138 pvt->datalen += 2*LPC10_SAMPLES_PER_FRAME;
00139 len += LPC10_BYTES_IN_COMPRESSED_FRAME;
00140 }
00141 if (len != f->datalen)
00142 printf("Decoded %d, expected %d\n", len, f->datalen);
00143 return 0;
00144 }
00145
00146 static int lintolpc10_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
00147 {
00148 struct lpc10_coder_pvt *tmp = pvt->pvt;
00149
00150
00151 if (pvt->samples + f->samples > BUFFER_SAMPLES) {
00152 ast_log(LOG_WARNING, "Out of buffer space\n");
00153 return -1;
00154 }
00155 memcpy(tmp->buf + pvt->samples, f->data.ptr, f->datalen);
00156 pvt->samples += f->samples;
00157 return 0;
00158 }
00159
00160 static struct ast_frame *lintolpc10_frameout(struct ast_trans_pvt *pvt)
00161 {
00162 struct lpc10_coder_pvt *tmp = pvt->pvt;
00163 int x;
00164 int datalen = 0;
00165 int samples = 0;
00166 float tmpbuf[LPC10_SAMPLES_PER_FRAME];
00167 INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME];
00168
00169 if (pvt->samples < LPC10_SAMPLES_PER_FRAME)
00170 return NULL;
00171 while (pvt->samples >= LPC10_SAMPLES_PER_FRAME) {
00172
00173 for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++)
00174 tmpbuf[x] = (float)tmp->buf[x + samples] / 32768.0;
00175 lpc10_encode(tmpbuf, bits, tmp->lpc10.enc);
00176 build_bits(pvt->outbuf.uc + datalen, bits);
00177 datalen += LPC10_BYTES_IN_COMPRESSED_FRAME;
00178 samples += LPC10_SAMPLES_PER_FRAME;
00179 pvt->samples -= LPC10_SAMPLES_PER_FRAME;
00180
00181
00182 tmp->longer = 1 - tmp->longer;
00183 }
00184
00185 if (pvt->samples)
00186 memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2);
00187 return ast_trans_frameout(pvt, datalen, samples);
00188 }
00189
00190
00191 static void lpc10_destroy(struct ast_trans_pvt *arg)
00192 {
00193 struct lpc10_coder_pvt *pvt = arg->pvt;
00194
00195 ast_free(pvt->lpc10.enc);
00196 }
00197
00198 static struct ast_translator lpc10tolin = {
00199 .name = "lpc10tolin",
00200 .srcfmt = AST_FORMAT_LPC10,
00201 .dstfmt = AST_FORMAT_SLINEAR,
00202 .newpvt = lpc10_dec_new,
00203 .framein = lpc10tolin_framein,
00204 .destroy = lpc10_destroy,
00205 .sample = lpc10_sample,
00206 .desc_size = sizeof(struct lpc10_coder_pvt),
00207 .buffer_samples = BUFFER_SAMPLES,
00208 .buf_size = BUFFER_SAMPLES * 2,
00209 };
00210
00211 static struct ast_translator lintolpc10 = {
00212 .name = "lintolpc10",
00213 .srcfmt = AST_FORMAT_SLINEAR,
00214 .dstfmt = AST_FORMAT_LPC10,
00215 .newpvt = lpc10_enc_new,
00216 .framein = lintolpc10_framein,
00217 .frameout = lintolpc10_frameout,
00218 .destroy = lpc10_destroy,
00219 .sample = slin8_sample,
00220 .desc_size = sizeof(struct lpc10_coder_pvt),
00221 .buffer_samples = BUFFER_SAMPLES,
00222 .buf_size = LPC10_BYTES_IN_COMPRESSED_FRAME * (1 + BUFFER_SAMPLES / LPC10_SAMPLES_PER_FRAME),
00223 };
00224
00225 static int reload(void)
00226 {
00227 return AST_MODULE_LOAD_SUCCESS;
00228 }
00229
00230
00231 static int unload_module(void)
00232 {
00233 int res;
00234
00235 res = ast_unregister_translator(&lintolpc10);
00236 res |= ast_unregister_translator(&lpc10tolin);
00237
00238 return res;
00239 }
00240
00241 static int load_module(void)
00242 {
00243 int res;
00244
00245 res = ast_register_translator(&lpc10tolin);
00246 if (!res)
00247 res = ast_register_translator(&lintolpc10);
00248 else
00249 ast_unregister_translator(&lpc10tolin);
00250 if (res)
00251 return AST_MODULE_LOAD_FAILURE;
00252 return AST_MODULE_LOAD_SUCCESS;
00253 }
00254
00255 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "LPC10 2.4kbps Coder/Decoder",
00256 .load = load_module,
00257 .unload = unload_module,
00258 .reload = reload,
00259 );