codecs/codec_amr.c0000644000076600007660000003257210573144632014536 0ustar bagyendabagyenda/* * Asterisk -- An open source telephony toolkit. * * The AMR code is from 3GPP TS 26.104. Copyright information for that package is available * in the amr directory. * * Copyright (C) 2007, Digital Solutions * Paul Bagyenda * * * See http://www.asterisk.org for more information about * the Asterisk project. Please do not directly contact * any of the maintainers of this project for assistance; * the project provides a web site, mailing lists and IRC * channels for your use. * * This program is free software, distributed under the terms of * the GNU General Public License Version 2. See the LICENSE file * at the top of the source tree. */ /*! \file * * \brief Translate between signed linear and Adaptive Multi-Rate (AMR) Narrow Band (RFC 3267 format). * * \ingroup codecs */ /*** MODULEINFO ***/ #include "asterisk.h" ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include #include #include #include #include #include #include "asterisk/lock.h" #include "asterisk/translate.h" #include "asterisk/config.h" #include "asterisk/options.h" #include "asterisk/module.h" #include "asterisk/logger.h" #include "asterisk/channel.h" #include "asterisk/utils.h" #include "amr/typedef.h" #include "amr/interf_enc.h" #include "amr/interf_dec.h" /* Sample frame data */ #include "slin_amr_ex.h" #include "amr_slin_ex.h" #define SAMPLES_PER_SEC_NB 8000 /* 8kHz speech gives us 8000 samples per second */ #define BUFFER_SAMPLES 8000 /* maximum number of samples we will process at a go. */ #define AMR_SAMPLES 160 #define AMR_MAX_FRAME_LEN 32 #define AMR_MAX_FRAMES_NB (BUFFER_SAMPLES*1000)/(SAMPLES_PER_SEC_NB*20) /* each frame is 20ms, hence max frames = samples/samples_per_sec*/ static int dtx = 0; static enum Mode enc_mode = MR122; /* Size of (octet-aligned) speech block for each mode */ /* static short block_size[16]={12, 13, 15, 17, 19, 20, 26, 31, 5}; */ /* Taken from Table 2, of 3GPP TS 26.101, v5.0.0 */ static int num_bits[16] = {95, 103, 118, 134,148,159,204,244}; /* Mapping of encoding mode to AMR codec mode */ static const short modeConv[]={475, 515, 59, 67, 74, 795, 102, 122}; struct amr_translator_pvt { /* both amr2lin and lin2amr */ int *destate; /* decoder state */ int *enstate; /* encoder state. */ enum Mode enc_mode; /* Currrently requested mode */ int16_t buf[BUFFER_SAMPLES]; /* lin2amr, temporary storage */ unsigned char pheader[AMR_MAX_FRAMES_NB + 1]; /* lin2amr temporary storage for Pay load header + Table of Contents */ unsigned char speech_bits[AMR_MAX_FRAMES_NB*AMR_MAX_FRAME_LEN + 1]; /* storage for packed bits. */ }; /* Copy bits numbits from bits into dst. Bits are packed from and to higher order bits first. * 'pos' gives start position in dst of copy. * dst[] must be big enough or an unchecked error occurs. */ static unsigned int pack_bits(unsigned char dst[], unsigned pos, unsigned char bits[], unsigned numbits) { unsigned x = 0; unsigned dbyte, doffset; unsigned char ch; unsigned int ct = 0; while (numbits >= 8) { /* first copy whole bytes. */ dbyte = pos / 8; doffset = 8 - (pos % 8); ch = bits[x]; dst[dbyte] = (ch>>(8-doffset)) | (dst[dbyte] & (0xffu<>(8-doffset))); /* Put rest of bits in next bin. */ pos += 8; numbits -= 8; ct += 8; x++; } if (numbits > 0) { dbyte = pos / 8; doffset = 8 - (pos % 8); ch = bits[x] & (0xffu<<(8-numbits)); /* mask off everything else */ dst[dbyte] = (ch>>(8-doffset)) | (dst[dbyte] & (0xffu<>(8-doffset))); /* Put rest of bits in next bin. */ ct += numbits; } return ct; } /* Copy bits from src to bytes (destination), higher order bits first. Kind of the reverse of the above */ static unsigned int unpack_bits(unsigned char bytes[], unsigned char src[], unsigned pos, unsigned numbits) { unsigned x = 0; unsigned dbyte, doffset; unsigned int ct = 0; while (numbits >= 8) { /* first copy whole bytes. */ dbyte = pos / 8; doffset = 8 - (pos % 8); bytes[x] = src[dbyte]<<(8-doffset); if (pos % 8) bytes[x] |= src[dbyte+1]>>doffset; /* Put rest of bits in. */ pos += 8; numbits -= 8; ct += 8; x++; } if (numbits > 0) { dbyte = pos / 8; doffset = 8 - (pos % 8); bytes[x] = src[dbyte]<<(8-doffset); pos += numbits; if (pos / 8 != dbyte) bytes[x] |= src[dbyte+1]>>doffset; bytes[x] &= 0xff<<(8-numbits); /* clear out any excess. */ ct += numbits; } return ct; } /* XXX only bandwidth efficient mode is supported for now. Other one * requires better SDP handling in Asterisk */ static int amr_new(struct ast_trans_pvt *pvt) { struct amr_translator_pvt *tmp = pvt->pvt; tmp->enstate = Encoder_Interface_init(dtx); tmp->destate = Decoder_Interface_init(); tmp->enc_mode = enc_mode; return 0; } /* XXX this sample may not be transmitted as it is not in RTP packet format! */ static struct ast_frame *lintoamr_sample(void) { static struct ast_frame f; f.frametype = AST_FRAME_VOICE; f.subclass = AST_FORMAT_SLINEAR; f.datalen = sizeof(slin_amr_ex); /* Assume 8000 Hz */ f.samples = sizeof(slin_amr_ex)/2; f.mallocd = 0; f.offset = 0; f.src = __PRETTY_FUNCTION__; f.data = slin_amr_ex; return &f; } static struct ast_frame *amrtolin_sample(void) { static struct ast_frame f; f.frametype = AST_FRAME_VOICE; f.subclass = AST_FORMAT_AMRNB; f.datalen = sizeof(amr_slin_ex); /* All frames are 20 ms long */ f.samples = AMR_SAMPLES; f.mallocd = 0; f.offset = 0; f.src = __PRETTY_FUNCTION__; f.data = amr_slin_ex; return &f; } /*! \brief decode and store in outbuf. */ static int amrtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f) { struct amr_translator_pvt *tmp = pvt->pvt; int x = 0, more_frames = 1, num_frames = 0; int16_t *dst = (int16_t *)pvt->outbuf; unsigned char *src = f->data, cmr, buffer[AMR_MAX_FRAME_LEN], toc_entries[AMR_MAX_FRAMES_NB]; unsigned int pos; /* position in the bit stream. */ cmr = (src[0]) >> 4; pos = 4; /* Get the table of contents first... */ while (((pos +7)/8 < f->datalen) && more_frames) { pos += unpack_bits(&toc_entries[num_frames], src, pos, 6); /* get table of contents. */ more_frames = (toc_entries[num_frames]>>7); toc_entries[num_frames] &= ~(1<<7); /* Set top bit to 0 */ /* ast_verbose("amrtolin_framein: cmr=%02hhx, toc=%02hhx, more=%d, datalen=%d\n", cmr, toc_entries[num_frames], more_frames, f->datalen); */ num_frames++; } /* Now get the speech bits, and decode as we go. */ for (x = 0; x> 3) & 0x0f; /* XXX maybe we don't need to check */ if (pvt->samples + AMR_SAMPLES > BUFFER_SAMPLES) { ast_log(LOG_WARNING, "Out of buffer space\n"); return -1; } memset(buffer, 0, sizeof buffer); /* clear it. */ buffer[0] = toc_entries[x]; pos += unpack_bits(buffer+1, src, pos, num_bits[ft]); Decoder_Interface_Decode(tmp->destate,buffer, dst + pvt->samples,0); /* ast_verbose("amrtolin_framein: Decode toc=%02hhx, ft=%u, num_bits=%d\n", toc_entries[x], ft, num_bits[ft]); */ pvt->samples += AMR_SAMPLES; pvt->datalen += 2 * AMR_SAMPLES; } /* Honour the requested codec? */ if (cmr <= tmp->enc_mode) tmp->enc_mode = cmr; return 0; } /*! \brief store samples into working buffer for later decode */ static int lintoamr_framein(struct ast_trans_pvt *pvt, struct ast_frame *f) { struct amr_translator_pvt *tmp = pvt->pvt; /* XXX We should look at how old the rest of our stream is, and if it is too old, then we should overwrite it entirely, otherwise we can get artifacts of earlier talk that do not belong */ /* ast_verbose("lintoamr_framein: %d samples\n", f->samples);*/ if (pvt->samples + f->samples > BUFFER_SAMPLES) { ast_log(LOG_WARNING, "Out of buffer space\n"); return -1; } memcpy(tmp->buf + pvt->samples, f->data, f->datalen); pvt->samples += f->samples; pvt->datalen += 2*f->samples; return 0; } /*! \brief encode and produce a frame */ static struct ast_frame *lintoamr_frameout(struct ast_trans_pvt *pvt) { struct amr_translator_pvt *tmp = pvt->pvt; int datalen = 0, samples = 0, npad; unsigned int pbits = 0, sbits = 0; /* header and body bit count */ unsigned char buffer[AMR_MAX_FRAME_LEN], cmr = tmp->enc_mode, toc_entry, xzero = 0; /* ast_verbose("lintoamr_frameout: %d samples to process\n", pvt->samples); */ /* We can't work on anything less than a frame in size */ if (pvt->samples < AMR_SAMPLES) return NULL; /* First, put the CMR into the header. */ cmr <<= 4; /* Put in higher order nibble. */ pbits += pack_bits(tmp->pheader, pbits, &cmr, 4); while (pvt->samples >= AMR_SAMPLES) { /* Encode a frame of data */ int byte_count = Encoder_Interface_Encode(tmp->enstate, tmp->enc_mode, tmp->buf + samples, buffer, 0); samples += AMR_SAMPLES; pvt->samples -= AMR_SAMPLES; pvt->datalen -= 2*AMR_SAMPLES; toc_entry = buffer[0]; /* Set the F bit */ if (pvt->samples >= AMR_SAMPLES) /* then we have another frame to pack, so... */ toc_entry |= (1<<7); pbits += pack_bits(tmp->pheader, pbits, &toc_entry, 6); /* put in the table of contents element. */ /* Pack the bits of the speech. */ sbits += pack_bits(tmp->speech_bits, sbits, buffer + 1, num_bits[(toc_entry>>3) & 0x0F]); /* ast_verbose("codec_amr: encoded %d bytes, mode = %d, samples left=%d, first two bytes =%02hhx:%02hhx\n", byte_count, tmp->enc_mode, pvt->samples, buffer[1], buffer[2]); */ } /* Finally, put the header and the speech together into the pvt->buffer */ pack_bits((unsigned char *)pvt->outbuf, 0, tmp->pheader, pbits); pack_bits((unsigned char *)pvt->outbuf, pbits, tmp->speech_bits, sbits); npad = 8 - ((sbits + pbits) % 8); /* Number of padding bits */ pack_bits((unsigned char *)pvt->outbuf, pbits+sbits, &xzero, npad); /* zero out the rest of the padding bits. */ datalen = (sbits + pbits + 7)/8; /* Round up to nearest octet. */ /* ast_verbose("codec_amr: Totally encoded %d bytes worth, mode = %d, samples left=%d\n", datalen, tmp->enc_mode, pvt->samples); */ /* Move the data at the end of the buffer to the front */ if (pvt->samples) memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2); return ast_trans_frameout(pvt, datalen, samples); } static void amr_destroy_stuff(struct ast_trans_pvt *pvt) { struct amr_translator_pvt *tmp = pvt->pvt; Encoder_Interface_exit(tmp->enstate); Decoder_Interface_exit(tmp->destate); } static struct ast_translator amrtolin = { .name = "amrtolin", .srcfmt = AST_FORMAT_AMRNB, .dstfmt = AST_FORMAT_SLINEAR, .newpvt = amr_new, .framein = amrtolin_framein, .destroy = amr_destroy_stuff, .sample = amrtolin_sample, .buffer_samples = BUFFER_SAMPLES, .buf_size = BUFFER_SAMPLES * 2, .desc_size = sizeof (struct amr_translator_pvt ) }; static struct ast_translator lintoamr = { .name = "lintoamr", .srcfmt = AST_FORMAT_SLINEAR, .dstfmt = AST_FORMAT_AMRNB, .newpvt = amr_new, .framein = lintoamr_framein, .frameout = lintoamr_frameout, .destroy = amr_destroy_stuff, .sample = lintoamr_sample, .desc_size = sizeof (struct amr_translator_pvt ), .buf_size = (BUFFER_SAMPLES * AMR_MAX_FRAME_LEN + AMR_SAMPLES - 1)/AMR_SAMPLES, }; static void parse_config(void) { struct ast_variable *var; struct ast_config *cfg = ast_config_load("codecs.conf"); if (!cfg) return; for (var = ast_variable_browse(cfg, "amr"); var; var = var->next) { if (!strcasecmp(var->name, "dtx")) { dtx = atoi(var->value); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "codec_amr: set dtx mode to %d\n", dtx); } else if (!strcasecmp(var->name, "mode")) { int mode_tmp = strtol(var->value + 2, NULL, 10); int req_mode; for (req_mode = 0; req_mode < 8; req_mode++) if (mode_tmp == modeConv[req_mode]) break; if (req_mode == 8) { ast_log(LOG_ERROR, "Error, unknown mode %s. Must be one of MR475, MR515, MR59, MR67, MR74, MR795, MR102, MR122", var->value); } else { enc_mode = req_mode; if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "codec_amr: AMR mode set to MR%d\n", mode_tmp); } } } ast_config_destroy(cfg); ast_verbose("codec_amr: enc_mode = %d, dtx = %d\n", enc_mode, dtx); } /*! \brief standard module glue */ static int reload(void) { parse_config(); return 0; } static int unload_module(void) { int res; res = ast_unregister_translator(&lintoamr); if (!res) res = ast_unregister_translator(&amrtolin); return res; } static int load_module(void) { int res; parse_config(); res = ast_register_translator(&amrtolin); if (!res) res=ast_register_translator(&lintoamr); else ast_unregister_translator(&amrtolin); return res; } AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "AMR Coder/Decoder", .load = load_module, .unload = unload_module, .reload = reload, ); codecs/amr_slin_ex.h0000644000076600007660000000065510573076113015122 0ustar bagyendabagyenda/*! \file * \brief 8-bit raw data * * Source: gsm.example * * Copyright (C) 1999-2005, Digium Inc. * * Distributed under the terms of the GNU General Public License * */ static unsigned char amr_slin_ex[] = { 0x73, 0xc3, 0x17, 0x06, 0x90, 0x1a, 0x74, 0x10, 0x0a, 0x32, 0xb1, 0x39, 0x49, 0x99, 0x54, 0x15, 0xd0, 0x00, 0x10, 0x2a, 0x08, 0xfe, 0x83, 0x69, 0x00, 0x00, 0x0b, 0x6f, 0xad, 0x73, 0x0d, 0x28, }; codecs/slin_amr_ex.h0000644000076600007660000000305310572152353015115 0ustar bagyendabagyenda/*! \file * \brief Signed 16-bit audio data * * Source: amr.example * * Copyright (C) 1999-2005, Digium Inc. * * Distributed under the terms of the GNU General Public License * */ static signed short slin_amr_ex[] = { 0x00d8, 0x00b0, 0x0070, 0x0038, 0x0030, 0xff78, 0xfed8, 0xff20, 0xff20, 0xff48, 0xff80, 0xff48, 0xffa0, 0xffc0, 0xff68, 0xff88, 0xffd8, 0x0038, 0x00a8, 0x00a0, 0x0078, 0x0088, 0x0148, 0x01d8, 0x0178, 0x00f0, 0x0068, 0x0040, 0x0098, 0x0068, 0x0018, 0xffe8, 0xffb0, 0xff48, 0xfed8, 0xfec8, 0xfed0, 0xfee0, 0xff18, 0xff28, 0xff38, 0xff80, 0xffc0, 0x0010, 0x0018, 0x0058, 0x0088, 0x0060, 0x0088, 0x00c0, 0x0080, 0x00a0, 0x0088, 0x0050, 0x00a0, 0x00a0, 0x00a8, 0x0100, 0x0120, 0x0110, 0x0058, 0xffa0, 0xff90, 0xff90, 0xffc0, 0xff58, 0xff00, 0xff50, 0xfee8, 0xfee8, 0xff18, 0xff30, 0xff58, 0xff38, 0xfec0, 0xfe60, 0xfeb0, 0xff78, 0x0030, 0x0070, 0x0050, 0x0080, 0x00d8, 0x0110, 0x0108, 0x00e0, 0x00d0, 0x00c8, 0x00b8, 0x0090, 0x0070, 0x0048, 0x0048, 0x0058, 0x0010, 0xffe0, 0xff80, 0xff68, 0xffb8, 0xfff8, 0x0030, 0x0008, 0xffb0, 0xff70, 0xff78, 0xffc8, 0xffd8, 0xffe8, 0xffd0, 0xff58, 0xff38, 0xff58, 0xffb8, 0x0018, 0xfff0, 0x0010, 0x0018, 0x0020, 0x0050, 0x0038, 0x0040, 0x0058, 0x0048, 0x0070, 0x0038, 0x0038, 0x0088, 0x0058, 0x0050, 0x0008, 0xffc8, 0xffe0, 0xffc8, 0xffe8, 0xff98, 0xff48, 0xff78, 0xff90, 0xffa8, 0xffc8, 0xffb0, 0xffd0, 0xffa8, 0xff48, 0xffc0, 0x0050, 0x00c0, 0x00c8, 0x0058, 0xfff0, 0x0020, 0x0080, 0x00a0, 0x0078, 0x0030, 0xfff0, 0xffd8, 0xfff8, 0x0000, 0x0030 };