formats/format_g726.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (c) 2004 - 2005, inAccess Networks
   5  *
   6  * Michael Manousos <manousos@inaccessnetworks.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 Headerless G.726 (16/24/32/40kbps) data format for Asterisk.
  22  *
  23  * File name extensions:
  24  * \arg 40 kbps: g726-40
  25  * \arg 32 kbps: g726-32
  26  * \arg 24 kbps: g726-24
  27  * \arg 16 kbps: g726-16
  28  * \ingroup formats
  29  */
  30
  31 #include "asterisk.h"
  32
  33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  34
  35 #include <unistd.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <stdlib.h>
  39 #include <sys/time.h>
  40 #include <stdio.h>
  41 #include <errno.h>
  42 #include <string.h>
  43
  44 #include "asterisk/lock.h"
  45 #include "asterisk/options.h"
  46 #include "asterisk/channel.h"
  47 #include "asterisk/file.h"
  48 #include "asterisk/logger.h"
  49 #include "asterisk/sched.h"
  50 #include "asterisk/module.h"
  51 #include "asterisk/endian.h"
  52
  53 #define RATE_40         0
  54 #define RATE_32         1
  55 #define RATE_24         2
  56 #define RATE_16         3
  57
  58 /* We can only read/write chunks of FRAME_TIME ms G.726 data */
  59 #define FRAME_TIME      10      /* 10 ms size */
  60
  61 #define BUF_SIZE        (5*FRAME_TIME)  /* max frame size in bytes ? */
  62 /* Frame sizes in bytes */
  63 static int frame_size[4] = {
  64                 FRAME_TIME * 5,
  65                 FRAME_TIME * 4,
  66                 FRAME_TIME * 3,
  67                 FRAME_TIME * 2
  68 };
  69
  70 struct g726_desc  {
  71         int rate;       /* RATE_* defines */
  72 };
  73
  74 /*
  75  * Rate dependant format functions (open, rewrite)
  76  */
  77 static int g726_open(struct ast_filestream *tmp, int rate)
  78 {
  79         struct g726_desc *s = (struct g726_desc *)tmp->_private;
  80         s->rate = rate;
  81         if (option_debug)
  82                 ast_log(LOG_DEBUG, "Created filestream G.726-%dk.\n",
  83                                 40 - s->rate * 8);
  84         return 0;
  85 }
  86
  87 static int g726_40_open(struct ast_filestream *s)
  88 {
  89         return g726_open(s, RATE_40);
  90 }
  91
  92 static int g726_32_open(struct ast_filestream *s)
  93 {
  94         return g726_open(s, RATE_32);
  95 }
  96
  97 static int g726_24_open(struct ast_filestream *s)
  98 {
  99         return g726_open(s, RATE_24);
 100 }
 101
 102 static int g726_16_open(struct ast_filestream *s)
 103 {
 104         return g726_open(s, RATE_16);
 105 }
 106
 107 static int g726_40_rewrite(struct ast_filestream *s, const char *comment)
 108 {
 109         return g726_open(s, RATE_40);
 110 }
 111
 112 static int g726_32_rewrite(struct ast_filestream *s, const char *comment)
 113 {
 114         return g726_open(s, RATE_32);
 115 }
 116
 117 static int g726_24_rewrite(struct ast_filestream *s, const char *comment)
 118 {
 119         return g726_open(s, RATE_24);
 120 }
 121
 122 static int g726_16_rewrite(struct ast_filestream *s, const char *comment)
 123 {
 124         return g726_open(s, RATE_16);
 125 }
 126
 127 /*
 128  * Rate independent format functions (read, write)
 129  */
 130
 131 static struct ast_frame *g726_read(struct ast_filestream *s, int *whennext)
 132 {
 133         int res;
 134         struct g726_desc *fs = (struct g726_desc *)s->_private;
 135
 136         /* Send a frame from the file to the appropriate channel */
 137         s->fr.frametype = AST_FRAME_VOICE;
 138         s->fr.subclass = AST_FORMAT_G726;
 139         s->fr.mallocd = 0;
 140         AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, frame_size[fs->rate]);
 141         s->fr.samples = 8 * FRAME_TIME;
 142         if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
 143                 if (res)
 144                         ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
 145                 return NULL;
 146         }
 147         *whennext = s->fr.samples;
 148         return &s->fr;
 149 }
 150
 151 static int g726_write(struct ast_filestream *s, struct ast_frame *f)
 152 {
 153         int res;
 154         struct g726_desc *fs = (struct g726_desc *)s->_private;
 155
 156         if (f->frametype != AST_FRAME_VOICE) {
 157                 ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
 158                 return -1;
 159         }
 160         if (f->subclass != AST_FORMAT_G726) {
 161                 ast_log(LOG_WARNING, "Asked to write non-G726 frame (%d)!\n",
 162                                                 f->subclass);
 163                 return -1;
 164         }
 165         if (f->datalen % frame_size[fs->rate]) {
 166                 ast_log(LOG_WARNING, "Invalid data length %d, should be multiple of %d\n",
 167                                                 f->datalen, frame_size[fs->rate]);
 168                 return -1;
 169         }
 170         if ((res = fwrite(f->data, 1, f->datalen, s->f)) != f->datalen) {
 171                 ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n",
 172                                 res, frame_size[fs->rate], strerror(errno));
 173                         return -1;
 174         }
 175         return 0;
 176 }
 177
 178 static int g726_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 179 {
 180         return -1;
 181 }
 182
 183 static int g726_trunc(struct ast_filestream *fs)
 184 {
 185         return -1;
 186 }
 187
 188 static off_t g726_tell(struct ast_filestream *fs)
 189 {
 190         return -1;
 191 }
 192
 193 static const struct ast_format f[] = {
 194         {
 195                 .name = "g726-40",
 196                 .exts = "g726-40",
 197                 .format = AST_FORMAT_G726,
 198                 .open = g726_40_open,
 199                 .rewrite = g726_40_rewrite,
 200                 .write = g726_write,
 201                 .seek = g726_seek,
 202                 .trunc = g726_trunc,
 203                 .tell = g726_tell,
 204                 .read = g726_read,
 205                 .buf_size = BUF_SIZE + AST_FRIENDLY_OFFSET,
 206                 .desc_size = sizeof(struct g726_desc),
 207         },
 208         {
 209                 .name = "g726-32",
 210                 .exts = "g726-32",
 211                 .format = AST_FORMAT_G726,
 212                 .open = g726_32_open,
 213                 .rewrite = g726_32_rewrite,
 214                 .write = g726_write,
 215                 .seek = g726_seek,
 216                 .trunc = g726_trunc,
 217                 .tell = g726_tell,
 218                 .read = g726_read,
 219                 .buf_size = BUF_SIZE + AST_FRIENDLY_OFFSET,
 220                 .desc_size = sizeof(struct g726_desc),
 221         },
 222         {
 223                 .name = "g726-24",
 224                 .exts = "g726-24",
 225                 .format = AST_FORMAT_G726,
 226                 .open = g726_24_open,
 227                 .rewrite = g726_24_rewrite,
 228                 .write = g726_write,
 229                 .seek = g726_seek,
 230                 .trunc = g726_trunc,
 231                 .tell = g726_tell,
 232                 .read = g726_read,
 233                 .buf_size = BUF_SIZE + AST_FRIENDLY_OFFSET,
 234                 .desc_size = sizeof(struct g726_desc),
 235         },
 236         {
 237                 .name = "g726-16",
 238                 .exts = "g726-16",
 239                 .format = AST_FORMAT_G726,
 240                 .open = g726_16_open,
 241                 .rewrite = g726_16_rewrite,
 242                 .write = g726_write,
 243                 .seek = g726_seek,
 244                 .trunc = g726_trunc,
 245                 .tell = g726_tell,
 246                 .read = g726_read,
 247                 .buf_size = BUF_SIZE + AST_FRIENDLY_OFFSET,
 248                 .desc_size = sizeof(struct g726_desc),
 249         },
 250         {       .format = 0 }   /* terminator */
 251 };
 252
 253 static int load_module(void)
 254 {
 255         int i;
 256
 257         for (i = 0; f[i].format ; i++) {
 258                 if (ast_format_register(&f[i])) {       /* errors are fatal */
 259                         ast_log(LOG_WARNING, "Failed to register format %s.\n", f[i].name);
 260                         return -1;
 261                 }
 262         }
 263         return 0;
 264 }
 265
 266 static int unload_module(void)
 267 {
 268         int i;
 269
 270         for (i = 0; f[i].format ; i++) {
 271                 if (ast_format_unregister(f[i].name))
 272                         ast_log(LOG_WARNING, "Failed to unregister format %s.\n", f[i].name);
 273         }
 274         return(0);
 275 }
 276
 277 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Raw G.726 (16/24/32/40kbps) data");