formats/format_g729.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 /*
  20  *
  21  * Save to raw, headerless G729 data.
  22  *
  23  */
  24
  25 #include <unistd.h>
  26 #include <netinet/in.h>
  27 #include <arpa/inet.h>
  28 #include <stdlib.h>
  29 #include <sys/time.h>
  30 #include <stdio.h>
  31 #include <errno.h>
  32 #include <string.h>
  33
  34 #include "asterisk.h"
  35
  36 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  37
  38 #include "asterisk/lock.h"
  39 #include "asterisk/channel.h"
  40 #include "asterisk/file.h"
  41 #include "asterisk/logger.h"
  42 #include "asterisk/sched.h"
  43 #include "asterisk/module.h"
  44 #include "asterisk/endian.h"
  45
  46 /* Some Ideas for this code came from makeg729e.c by Jeffrey Chilton */
  47
  48 /* Portions of the conversion code are by guido@sienanet.it */
  49
  50 struct ast_filestream {
  51         void *reserved[AST_RESERVED_POINTERS];
  52         /* Believe it or not, we must decode/recode to account for the
  53            weird MS format */
  54         /* This is what a filestream means to us */
  55         int fd; /* Descriptor */
  56         struct ast_frame fr;                            /* Frame information */
  57         char waste[AST_FRIENDLY_OFFSET];        /* Buffer for sending frames, etc */
  58         char empty;                                                     /* Empty character */
  59         unsigned char g729[20];                         /* Two Real G729 Frames */
  60 };
  61
  62
  63 AST_MUTEX_DEFINE_STATIC(g729_lock);
  64 static int glistcnt = 0;
  65
  66 static char *name = "g729";
  67 static char *desc = "Raw G729 data";
  68 static char *exts = "g729";
  69
  70 static struct ast_filestream *g729_open(int fd)
  71 {
  72         /* We don't have any header to read or anything really, but
  73            if we did, it would go here.  We also might want to check
  74            and be sure it's a valid file.  */
  75         struct ast_filestream *tmp;
  76         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
  77                 memset(tmp, 0, sizeof(struct ast_filestream));
  78                 if (ast_mutex_lock(&g729_lock)) {
  79                         ast_log(LOG_WARNING, "Unable to lock g729 list\n");
  80                         free(tmp);
  81                         return NULL;
  82                 }
  83                 tmp->fd = fd;
  84                 tmp->fr.data = tmp->g729;
  85                 tmp->fr.frametype = AST_FRAME_VOICE;
  86                 tmp->fr.subclass = AST_FORMAT_G729A;
  87                 /* datalen will vary for each frame */
  88                 tmp->fr.src = name;
  89                 tmp->fr.mallocd = 0;
  90                 glistcnt++;
  91                 ast_mutex_unlock(&g729_lock);
  92                 ast_update_use_count();
  93         }
  94         return tmp;
  95 }
  96
  97 static struct ast_filestream *g729_rewrite(int fd, const char *comment)
  98 {
  99         /* We don't have any header to read or anything really, but
 100            if we did, it would go here.  We also might want to check
 101            and be sure it's a valid file.  */
 102         struct ast_filestream *tmp;
 103         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
 104                 memset(tmp, 0, sizeof(struct ast_filestream));
 105                 if (ast_mutex_lock(&g729_lock)) {
 106                         ast_log(LOG_WARNING, "Unable to lock g729 list\n");
 107                         free(tmp);
 108                         return NULL;
 109                 }
 110                 tmp->fd = fd;
 111                 glistcnt++;
 112                 ast_mutex_unlock(&g729_lock);
 113                 ast_update_use_count();
 114         } else
 115                 ast_log(LOG_WARNING, "Out of memory\n");
 116         return tmp;
 117 }
 118
 119 static void g729_close(struct ast_filestream *s)
 120 {
 121         if (ast_mutex_lock(&g729_lock)) {
 122                 ast_log(LOG_WARNING, "Unable to lock g729 list\n");
 123                 return;
 124         }
 125         glistcnt--;
 126         ast_mutex_unlock(&g729_lock);
 127         ast_update_use_count();
 128         close(s->fd);
 129         free(s);
 130         s = NULL;
 131 }
 132
 133 static struct ast_frame *g729_read(struct ast_filestream *s, int *whennext)
 134 {
 135         int res;
 136         /* Send a frame from the file to the appropriate channel */
 137         s->fr.frametype = AST_FRAME_VOICE;
 138         s->fr.subclass = AST_FORMAT_G729A;
 139         s->fr.offset = AST_FRIENDLY_OFFSET;
 140         s->fr.samples = 160;
 141         s->fr.datalen = 20;
 142         s->fr.mallocd = 0;
 143         s->fr.data = s->g729;
 144         if ((res = read(s->fd, s->g729, 20)) != 20) {
 145                 if (res && (res != 10))
 146                         ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
 147                 return NULL;
 148         }
 149         *whennext = s->fr.samples;
 150         return &s->fr;
 151 }
 152
 153 static int g729_write(struct ast_filestream *fs, struct ast_frame *f)
 154 {
 155         int res;
 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_G729A) {
 161                 ast_log(LOG_WARNING, "Asked to write non-G729 frame (%d)!\n", f->subclass);
 162                 return -1;
 163         }
 164         if (f->datalen % 10) {
 165                 ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 10\n", f->datalen);
 166                 return -1;
 167         }
 168         if ((res = write(fs->fd, f->data, f->datalen)) != f->datalen) {
 169                         ast_log(LOG_WARNING, "Bad write (%d/10): %s\n", res, strerror(errno));
 170                         return -1;
 171         }
 172         return 0;
 173 }
 174
 175 static char *g729_getcomment(struct ast_filestream *s)
 176 {
 177         return NULL;
 178 }
 179
 180 static int g729_seek(struct ast_filestream *fs, long sample_offset, int whence)
 181 {
 182         long bytes;
 183         off_t min,cur,max,offset=0;
 184         min = 0;
 185         cur = lseek(fs->fd, 0, SEEK_CUR);
 186         max = lseek(fs->fd, 0, SEEK_END);
 187
 188         bytes = 20 * (sample_offset / 160);
 189         if (whence == SEEK_SET)
 190                 offset = bytes;
 191         else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
 192                 offset = cur + bytes;
 193         else if (whence == SEEK_END)
 194                 offset = max - bytes;
 195         if (whence != SEEK_FORCECUR) {
 196                 offset = (offset > max)?max:offset;
 197         }
 198         /* protect against seeking beyond begining. */
 199         offset = (offset < min)?min:offset;
 200         if (lseek(fs->fd, offset, SEEK_SET) < 0)
 201                 return -1;
 202         return 0;
 203 }
 204
 205 static int g729_trunc(struct ast_filestream *fs)
 206 {
 207         /* Truncate file to current length */
 208         if (ftruncate(fs->fd, lseek(fs->fd, 0, SEEK_CUR)) < 0)
 209                 return -1;
 210         return 0;
 211 }
 212
 213 static long g729_tell(struct ast_filestream *fs)
 214 {
 215         off_t offset;
 216         offset = lseek(fs->fd, 0, SEEK_CUR);
 217         return (offset/20)*160;
 218 }
 219
 220 int load_module()
 221 {
 222         return ast_format_register(name, exts, AST_FORMAT_G729A,
 223                                                                 g729_open,
 224                                                                 g729_rewrite,
 225                                                                 g729_write,
 226                                                                 g729_seek,
 227                                                                 g729_trunc,
 228                                                                 g729_tell,
 229                                                                 g729_read,
 230                                                                 g729_close,
 231                                                                 g729_getcomment);
 232
 233
 234 }
 235
 236 int unload_module()
 237 {
 238         return ast_format_unregister(name);
 239 }
 240
 241 int usecount()
 242 {
 243         return glistcnt;
 244 }
 245
 246 char *description()
 247 {
 248         return desc;
 249 }
 250
 251
 252 char *key()
 253 {
 254         return ASTERISK_GPL_KEY;
 255 }