formats/format_g723.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  * \file
  21  *
  22  * \brief Old-style G.723.1 frame/timestamp format.
  23  *
  24  * \arg Extensions: g723, g723sf
  25  * \ingroup formats
  26  */
  27
  28 #include <unistd.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <errno.h>
  34 #include <string.h>
  35 #include <sys/time.h>
  36
  37 #include "asterisk.h"
  38
  39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  40
  41 #include "asterisk/lock.h"
  42 #include "asterisk/channel.h"
  43 #include "asterisk/file.h"
  44 #include "asterisk/logger.h"
  45 #include "asterisk/sched.h"
  46 #include "asterisk/module.h"
  47
  48 #include "../channels/adtranvofr.h"
  49
  50
  51 #define G723_MAX_SIZE 1024
  52
  53 struct ast_filestream {
  54         /* First entry MUST be reserved for the channel type */
  55         void *reserved[AST_RESERVED_POINTERS];
  56         /* This is what a filestream means to us */
  57         FILE *f; /* Descriptor */
  58         struct ast_filestream *next;
  59         struct ast_frame *fr;   /* Frame representation of buf */
  60         struct timeval orig;    /* Original frame time */
  61         char buf[G723_MAX_SIZE + AST_FRIENDLY_OFFSET];  /* Buffer for sending frames, etc */
  62 };
  63
  64
  65 AST_MUTEX_DEFINE_STATIC(g723_lock);
  66 static int glistcnt = 0;
  67
  68 static char *name = "g723sf";
  69 static char *desc = "G.723.1 Simple Timestamp File Format";
  70 static char *exts = "g723|g723sf";
  71
  72 static struct ast_filestream *g723_open(FILE *f)
  73 {
  74         /* We don't have any header to read or anything really, but
  75            if we did, it would go here.  We also might want to check
  76            and be sure it's a valid file.  */
  77         struct ast_filestream *tmp;
  78         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
  79                 memset(tmp, 0, sizeof(struct ast_filestream));
  80                 if (ast_mutex_lock(&g723_lock)) {
  81                         ast_log(LOG_WARNING, "Unable to lock g723 list\n");
  82                         free(tmp);
  83                         return NULL;
  84                 }
  85                 tmp->f = f;
  86                 tmp->fr = (struct ast_frame *)tmp->buf;
  87                 tmp->fr->data = tmp->buf + sizeof(struct ast_frame);
  88                 tmp->fr->frametype = AST_FRAME_VOICE;
  89                 tmp->fr->subclass = AST_FORMAT_G723_1;
  90                 /* datalen will vary for each frame */
  91                 tmp->fr->src = name;
  92                 tmp->fr->mallocd = 0;
  93                 glistcnt++;
  94                 ast_mutex_unlock(&g723_lock);
  95                 ast_update_use_count();
  96         }
  97         return tmp;
  98 }
  99
 100 static struct ast_filestream *g723_rewrite(FILE *f, const char *comment)
 101 {
 102         /* We don't have any header to read or anything really, but
 103            if we did, it would go here.  We also might want to check
 104            and be sure it's a valid file.  */
 105         struct ast_filestream *tmp;
 106         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
 107                 memset(tmp, 0, sizeof(struct ast_filestream));
 108                 if (ast_mutex_lock(&g723_lock)) {
 109                         ast_log(LOG_WARNING, "Unable to lock g723 list\n");
 110                         free(tmp);
 111                         return NULL;
 112                 }
 113                 tmp->f = f;
 114                 glistcnt++;
 115                 ast_mutex_unlock(&g723_lock);
 116                 ast_update_use_count();
 117         } else
 118                 ast_log(LOG_WARNING, "Out of memory\n");
 119         return tmp;
 120 }
 121
 122 static struct ast_frame *g723_read(struct ast_filestream *s, int *whennext)
 123 {
 124         unsigned short size;
 125         int res;
 126         int delay;
 127         /* Read the delay for the next packet, and schedule again if necessary */
 128         if (fread(&delay, 1, 4, s->f) == 4)
 129                 delay = ntohl(delay);
 130         else
 131                 delay = -1;
 132         if (fread(&size, 1, 2, s->f) != 2) {
 133                 /* Out of data, or the file is no longer valid.  In any case
 134                    go ahead and stop the stream */
 135                 return NULL;
 136         }
 137         /* Looks like we have a frame to read from here */
 138         size = ntohs(size);
 139         if (size > G723_MAX_SIZE - sizeof(struct ast_frame)) {
 140                 ast_log(LOG_WARNING, "Size %d is invalid\n", size);
 141                 /* The file is apparently no longer any good, as we
 142                    shouldn't ever get frames even close to this
 143                    size.  */
 144                 return NULL;
 145         }
 146         /* Read the data into the buffer */
 147         s->fr->offset = AST_FRIENDLY_OFFSET;
 148         s->fr->datalen = size;
 149         s->fr->data = s->buf + sizeof(struct ast_frame) + AST_FRIENDLY_OFFSET;
 150         if ((res = fread(s->fr->data, 1, size, s->f)) != size) {
 151                 ast_log(LOG_WARNING, "Short read (%d of %d bytes) (%s)!\n", res, size, strerror(errno));
 152                 return NULL;
 153         }
 154 #if 0
 155                 /* Average out frames <= 50 ms */
 156                 if (delay < 50)
 157                         s->fr->timelen = 30;
 158                 else
 159                         s->fr->timelen = delay;
 160 #else
 161                 s->fr->samples = 240;
 162 #endif
 163         *whennext = s->fr->samples;
 164         return s->fr;
 165 }
 166
 167 static void g723_close(struct ast_filestream *s)
 168 {
 169         if (ast_mutex_lock(&g723_lock)) {
 170                 ast_log(LOG_WARNING, "Unable to lock g723 list\n");
 171                 return;
 172         }
 173         glistcnt--;
 174         ast_mutex_unlock(&g723_lock);
 175         ast_update_use_count();
 176         fclose(s->f);
 177         free(s);
 178         s = NULL;
 179 }
 180
 181
 182 static int g723_write(struct ast_filestream *fs, struct ast_frame *f)
 183 {
 184         u_int32_t delay;
 185         u_int16_t size;
 186         int res;
 187         if (fs->fr) {
 188                 ast_log(LOG_WARNING, "Asked to write on a read stream??\n");
 189                 return -1;
 190         }
 191         if (f->frametype != AST_FRAME_VOICE) {
 192                 ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
 193                 return -1;
 194         }
 195         if (f->subclass != AST_FORMAT_G723_1) {
 196                 ast_log(LOG_WARNING, "Asked to write non-g723 frame!\n");
 197                 return -1;
 198         }
 199         delay = 0;
 200         if (f->datalen <= 0) {
 201                 ast_log(LOG_WARNING, "Short frame ignored (%d bytes long?)\n", f->datalen);
 202                 return 0;
 203         }
 204         if ((res = fwrite(&delay, 1, 4, fs->f)) != 4) {
 205                 ast_log(LOG_WARNING, "Unable to write delay: res=%d (%s)\n", res, strerror(errno));
 206                 return -1;
 207         }
 208         size = htons(f->datalen);
 209         if ((res = fwrite(&size, 1, 2, fs->f)) != 2) {
 210                 ast_log(LOG_WARNING, "Unable to write size: res=%d (%s)\n", res, strerror(errno));
 211                 return -1;
 212         }
 213         if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
 214                 ast_log(LOG_WARNING, "Unable to write frame: res=%d (%s)\n", res, strerror(errno));
 215                 return -1;
 216         }
 217         return 0;
 218 }
 219
 220 static int g723_seek(struct ast_filestream *fs, long sample_offset, int whence)
 221 {
 222         return -1;
 223 }
 224
 225 static int g723_trunc(struct ast_filestream *fs)
 226 {
 227         /* Truncate file to current length */
 228         if (ftruncate(fileno(fs->f), ftell(fs->f)) < 0)
 229                 return -1;
 230         return 0;
 231 }
 232
 233 static long g723_tell(struct ast_filestream *fs)
 234 {
 235         return -1;
 236 }
 237
 238 static char *g723_getcomment(struct ast_filestream *s)
 239 {
 240         return NULL;
 241 }
 242
 243 int load_module()
 244 {
 245         return ast_format_register(name, exts, AST_FORMAT_G723_1,
 246                                                                 g723_open,
 247                                                                 g723_rewrite,
 248                                                                 g723_write,
 249                                                                 g723_seek,
 250                                                                 g723_trunc,
 251                                                                 g723_tell,
 252                                                                 g723_read,
 253                                                                 g723_close,
 254                                                                 g723_getcomment);
 255
 256
 257 }
 258
 259 int unload_module()
 260 {
 261         return ast_format_unregister(name);
 262 }
 263
 264 int usecount()
 265 {
 266         return glistcnt;
 267 }
 268
 269 char *description()
 270 {
 271         return desc;
 272 }
 273
 274
 275 char *key()
 276 {
 277         return ASTERISK_GPL_KEY;
 278 }