codecs/codec_ilbc.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Translate between signed linear and Internet Low Bitrate Codec
   5  *
   6  * The iLBC code is from The IETF code base and is copyright The Internet Society (2004)
   7  *
   8  * Copyright (C) 1999 - 2005, Digium, Inc.
   9  *
  10  * Mark Spencer <markster@digium.com>
  11  *
  12  * This program is free software, distributed under the terms of
  13  * the GNU General Public License
  14  */
  15
  16 #include "asterisk/lock.h"
  17 #include "asterisk/translate.h"
  18 #include "asterisk/module.h"
  19 #include "asterisk/logger.h"
  20 #include "asterisk/channel.h"
  21 #include <fcntl.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <netinet/in.h>
  25 #include <string.h>
  26 #include <stdio.h>
  27
  28 #include "ilbc/iLBC_encode.h"
  29 #include "ilbc/iLBC_decode.h"
  30
  31 /* Sample frame data */
  32 #include "slin_ilbc_ex.h"
  33 #include "ilbc_slin_ex.h"
  34
  35 #define USE_ILBC_ENHANCER       0
  36 #define ILBC_MS                         30
  37 /* #define ILBC_MS                      20 */
  38
  39 AST_MUTEX_DEFINE_STATIC(localuser_lock);
  40 static int localusecnt=0;
  41
  42 static char *tdesc = "iLBC/PCM16 (signed linear) Codec Translator";
  43
  44 struct ast_translator_pvt {
  45         iLBC_Enc_Inst_t enc;
  46         iLBC_Dec_Inst_t dec;
  47         struct ast_frame f;
  48         /* Space to build offset */
  49         char offset[AST_FRIENDLY_OFFSET];
  50         /* Buffer for our outgoing frame */
  51         short outbuf[8000];
  52         /* Enough to store a full second */
  53         short buf[8000];
  54         int tail;
  55 };
  56
  57 #define ilbc_coder_pvt ast_translator_pvt
  58
  59 static struct ast_translator_pvt *lintoilbc_new(void)
  60 {
  61         struct ilbc_coder_pvt *tmp;
  62         tmp = malloc(sizeof(struct ilbc_coder_pvt));
  63         if (tmp) {
  64                 /* Shut valgrind up */
  65                 memset(&tmp->enc, 0, sizeof(tmp->enc));
  66                 initEncode(&tmp->enc, ILBC_MS);
  67                 tmp->tail = 0;
  68                 localusecnt++;
  69         }
  70         return tmp;
  71 }
  72
  73 static struct ast_translator_pvt *ilbctolin_new(void)
  74 {
  75         struct ilbc_coder_pvt *tmp;
  76         tmp = malloc(sizeof(struct ilbc_coder_pvt));
  77         if (tmp) {
  78                 /* Shut valgrind up */
  79                 memset(&tmp->dec, 0, sizeof(tmp->dec));
  80                 initDecode(&tmp->dec, ILBC_MS, USE_ILBC_ENHANCER);
  81                 tmp->tail = 0;
  82                 localusecnt++;
  83         }
  84         return tmp;
  85 }
  86
  87 static struct ast_frame *lintoilbc_sample(void)
  88 {
  89         static struct ast_frame f;
  90         f.frametype = AST_FRAME_VOICE;
  91         f.subclass = AST_FORMAT_SLINEAR;
  92         f.datalen = sizeof(slin_ilbc_ex);
  93         /* Assume 8000 Hz */
  94         f.samples = sizeof(slin_ilbc_ex)/2;
  95         f.mallocd = 0;
  96         f.offset = 0;
  97         f.src = __PRETTY_FUNCTION__;
  98         f.data = slin_ilbc_ex;
  99         return &f;
 100 }
 101
 102 static struct ast_frame *ilbctolin_sample(void)
 103 {
 104         static struct ast_frame f;
 105         f.frametype = AST_FRAME_VOICE;
 106         f.subclass = AST_FORMAT_ILBC;
 107         f.datalen = sizeof(ilbc_slin_ex);
 108         /* All frames are 30 ms long */
 109         f.samples = 240;
 110         f.mallocd = 0;
 111         f.offset = 0;
 112         f.src = __PRETTY_FUNCTION__;
 113         f.data = ilbc_slin_ex;
 114         return &f;
 115 }
 116
 117 static struct ast_frame *ilbctolin_frameout(struct ast_translator_pvt *tmp)
 118 {
 119         if (!tmp->tail)
 120                 return NULL;
 121         /* Signed linear is no particular frame size, so just send whatever
 122            we have in the buffer in one lump sum */
 123         tmp->f.frametype = AST_FRAME_VOICE;
 124         tmp->f.subclass = AST_FORMAT_SLINEAR;
 125         tmp->f.datalen = tmp->tail * 2;
 126         /* Assume 8000 Hz */
 127         tmp->f.samples = tmp->tail;
 128         tmp->f.mallocd = 0;
 129         tmp->f.offset = AST_FRIENDLY_OFFSET;
 130         tmp->f.src = __PRETTY_FUNCTION__;
 131         tmp->f.data = tmp->buf;
 132         /* Reset tail pointer */
 133         tmp->tail = 0;
 134
 135         return &tmp->f;
 136 }
 137
 138 static int ilbctolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
 139 {
 140         /* Assuming there's space left, decode into the current buffer at
 141            the tail location.  Read in as many frames as there are */
 142         int x,i;
 143         float tmpf[240];
 144
 145         if (f->datalen == 0) { /* native PLC */
 146                 if (tmp->tail + 240 < sizeof(tmp->buf)/2) {
 147                         iLBC_decode(tmpf, NULL, &tmp->dec, 0);
 148                         for (i=0;i<240;i++)
 149                                 tmp->buf[tmp->tail + i] = tmpf[i];
 150                         tmp->tail+=240;
 151                 } else {
 152                         ast_log(LOG_WARNING, "Out of buffer space\n");
 153                         return -1;
 154                 }
 155         }
 156
 157         if (f->datalen % 50) {
 158                 ast_log(LOG_WARNING, "Huh?  An ilbc frame that isn't a multiple of 50 bytes long from %s (%d)?\n", f->src, f->datalen);
 159                 return -1;
 160         }
 161
 162         for (x=0;x<f->datalen;x+=50) {
 163                 if (tmp->tail + 240 < sizeof(tmp->buf)/2) {
 164                         iLBC_decode(tmpf, f->data + x, &tmp->dec, 1);
 165                         for (i=0;i<240;i++)
 166                                 tmp->buf[tmp->tail + i] = tmpf[i];
 167                         tmp->tail+=240;
 168                 } else {
 169                         ast_log(LOG_WARNING, "Out of buffer space\n");
 170                         return -1;
 171                 }
 172         }
 173         return 0;
 174 }
 175
 176 static int lintoilbc_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
 177 {
 178         /* Just add the frames to our stream */
 179         /* XXX We should look at how old the rest of our stream is, and if it
 180            is too old, then we should overwrite it entirely, otherwise we can
 181            get artifacts of earlier talk that do not belong */
 182         if (tmp->tail + f->datalen/2 < sizeof(tmp->buf) / 2) {
 183                 memcpy((tmp->buf + tmp->tail), f->data, f->datalen);
 184                 tmp->tail += f->datalen/2;
 185         } else {
 186                 ast_log(LOG_WARNING, "Out of buffer space\n");
 187                 return -1;
 188         }
 189         return 0;
 190 }
 191
 192 static struct ast_frame *lintoilbc_frameout(struct ast_translator_pvt *tmp)
 193 {
 194         int x=0,i;
 195         float tmpf[240];
 196         /* We can't work on anything less than a frame in size */
 197         if (tmp->tail < 240)
 198                 return NULL;
 199         tmp->f.frametype = AST_FRAME_VOICE;
 200         tmp->f.subclass = AST_FORMAT_ILBC;
 201         tmp->f.mallocd = 0;
 202         tmp->f.offset = AST_FRIENDLY_OFFSET;
 203         tmp->f.src = __PRETTY_FUNCTION__;
 204         tmp->f.data = tmp->outbuf;
 205         while(tmp->tail >= 240) {
 206                 if ((x+1) * 50 >= sizeof(tmp->outbuf)) {
 207                         ast_log(LOG_WARNING, "Out of buffer space\n");
 208                         break;
 209                 }
 210                 for (i=0;i<240;i++)
 211                         tmpf[i] = tmp->buf[i];
 212                 /* Encode a frame of data */
 213                 iLBC_encode(((unsigned char *)(tmp->outbuf)) + (x * 50), tmpf, &tmp->enc);
 214                 /* Assume 8000 Hz -- 20 ms */
 215                 tmp->tail -= 240;
 216                 /* Move the data at the end of the buffer to the front */
 217                 if (tmp->tail)
 218                         memmove(tmp->buf, tmp->buf + 240, tmp->tail * 2);
 219                 x++;
 220         }
 221         tmp->f.datalen = x * 50;
 222         tmp->f.samples = x * 240;
 223 #if 0
 224         {
 225                 static int fd = -1;
 226                 if (fd == -1) {
 227                         fd = open("ilbc.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
 228                         write(fd, tmp->f.data, tmp->f.datalen);
 229                         close(fd);
 230                 }
 231         }
 232 #endif
 233         return &tmp->f;
 234 }
 235
 236 static void ilbc_destroy_stuff(struct ast_translator_pvt *pvt)
 237 {
 238         free(pvt);
 239         localusecnt--;
 240 }
 241
 242 static struct ast_translator ilbctolin =
 243         { "ilbctolin",
 244            AST_FORMAT_ILBC, AST_FORMAT_SLINEAR,
 245            ilbctolin_new,
 246            ilbctolin_framein,
 247            ilbctolin_frameout,
 248            ilbc_destroy_stuff,
 249            ilbctolin_sample
 250            };
 251
 252 static struct ast_translator lintoilbc =
 253         { "lintoilbc",
 254            AST_FORMAT_SLINEAR, AST_FORMAT_ILBC,
 255            lintoilbc_new,
 256            lintoilbc_framein,
 257            lintoilbc_frameout,
 258            ilbc_destroy_stuff,
 259            lintoilbc_sample
 260            };
 261
 262 int unload_module(void)
 263 {
 264         int res;
 265         ast_mutex_lock(&localuser_lock);
 266         res = ast_unregister_translator(&lintoilbc);
 267         if (!res)
 268                 res = ast_unregister_translator(&ilbctolin);
 269         if (localusecnt)
 270                 res = -1;
 271         ast_mutex_unlock(&localuser_lock);
 272         return res;
 273 }
 274
 275 int load_module(void)
 276 {
 277         int res;
 278         res=ast_register_translator(&ilbctolin);
 279         if (!res)
 280                 res=ast_register_translator(&lintoilbc);
 281         else
 282                 ast_unregister_translator(&ilbctolin);
 283         return res;
 284 }
 285
 286 char *description(void)
 287 {
 288         return tdesc;
 289 }
 290
 291 int usecount(void)
 292 {
 293         int res;
 294         STANDARD_USECOUNT(res);
 295         return res;
 296 }
 297
 298 char *key()
 299 {
 300         return ASTERISK_GPL_KEY;
 301 }