formats/format_wav_gsm.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Save GSM in the proprietary Microsoft format.
   5  *
   6  * Copyright (C) 1999-2004, Digium, Inc.
   7  *
   8  * Mark Spencer <markster@digium.com>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14 #include <asterisk/lock.h>
  15 #include <asterisk/channel.h>
  16 #include <asterisk/file.h>
  17 #include <asterisk/logger.h>
  18 #include <asterisk/sched.h>
  19 #include <asterisk/module.h>
  20 #include <netinet/in.h>
  21 #include <arpa/inet.h>
  22 #include <stdlib.h>
  23 #include <sys/time.h>
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #ifdef __linux__
  29 #include <endian.h>
  30 #else
  31 #ifdef SOLARIS
  32 #include "solaris-compat/compat.h"
  33 #else
  34 #include <machine/endian.h>
  35 #endif
  36 #endif
  37 #include "msgsm.h"
  38
  39 /* Some Ideas for this code came from makewave.c by Jeffrey Chilton */
  40
  41 /* Portions of the conversion code are by guido@sienanet.it */
  42
  43 /* begin binary data: */
  44 char msgsm_silence[] = /* 65 */
  45 {0x48,0x17,0xD6,0x84,0x02,0x80,0x24,0x49,0x92,0x24,0x89,0x02,0x80,0x24,0x49
  46 ,0x92,0x24,0x89,0x02,0x80,0x24,0x49,0x92,0x24,0x89,0x02,0x80,0x24,0x49,0x92
  47 ,0x24,0x09,0x82,0x74,0x61,0x4D,0x28,0x00,0x48,0x92,0x24,0x49,0x92,0x28,0x00
  48 ,0x48,0x92,0x24,0x49,0x92,0x28,0x00,0x48,0x92,0x24,0x49,0x92,0x28,0x00,0x48
  49 ,0x92,0x24,0x49,0x92,0x00};
  50 /* end binary data. size = 65 bytes */
  51
  52 struct ast_filestream {
  53         void *reserved[AST_RESERVED_POINTERS];
  54         /* Believe it or not, we must decode/recode to account for the
  55            weird MS format */
  56         /* This is what a filestream means to us */
  57         int fd; /* Descriptor */
  58         int bytes;
  59         struct ast_frame fr;                            /* Frame information */
  60         char waste[AST_FRIENDLY_OFFSET];        /* Buffer for sending frames, etc */
  61         char empty;                                                     /* Empty character */
  62         unsigned char gsm[66];                          /* Two Real GSM Frames */
  63         int foffset;
  64         int secondhalf;                                         /* Are we on the second half */
  65         struct timeval last;
  66 };
  67
  68
  69 AST_MUTEX_DEFINE_STATIC(wav_lock);
  70 static int glistcnt = 0;
  71
  72 static char *name = "wav49";
  73 static char *desc = "Microsoft WAV format (Proprietary GSM)";
  74 static char *exts = "WAV|wav49";
  75
  76 #if __BYTE_ORDER == __LITTLE_ENDIAN
  77 #define htoll(b) (b)
  78 #define htols(b) (b)
  79 #define ltohl(b) (b)
  80 #define ltohs(b) (b)
  81 #else
  82 #if __BYTE_ORDER == __BIG_ENDIAN
  83 #define htoll(b)  \
  84           (((((b)      ) & 0xFF) << 24) | \
  85                ((((b) >>  8) & 0xFF) << 16) | \
  86                    ((((b) >> 16) & 0xFF) <<  8) | \
  87                    ((((b) >> 24) & 0xFF)      ))
  88 #define htols(b) \
  89           (((((b)      ) & 0xFF) << 8) | \
  90                    ((((b) >> 8) & 0xFF)      ))
  91 #define ltohl(b) htoll(b)
  92 #define ltohs(b) htols(b)
  93 #else
  94 #error "Endianess not defined"
  95 #endif
  96 #endif
  97
  98
  99 static int check_header(int fd)
 100 {
 101         int type, size, formtype;
 102         int fmt, hsize, fact;
 103         short format, chans;
 104         int freq;
 105         int data;
 106         if (read(fd, &type, 4) != 4) {
 107                 ast_log(LOG_WARNING, "Read failed (type)\n");
 108                 return -1;
 109         }
 110         if (read(fd, &size, 4) != 4) {
 111                 ast_log(LOG_WARNING, "Read failed (size)\n");
 112                 return -1;
 113         }
 114         size = ltohl(size);
 115         if (read(fd, &formtype, 4) != 4) {
 116                 ast_log(LOG_WARNING, "Read failed (formtype)\n");
 117                 return -1;
 118         }
 119         if (memcmp(&type, "RIFF", 4)) {
 120                 ast_log(LOG_WARNING, "Does not begin with RIFF\n");
 121                 return -1;
 122         }
 123         if (memcmp(&formtype, "WAVE", 4)) {
 124                 ast_log(LOG_WARNING, "Does not contain WAVE\n");
 125                 return -1;
 126         }
 127         if (read(fd, &fmt, 4) != 4) {
 128                 ast_log(LOG_WARNING, "Read failed (fmt)\n");
 129                 return -1;
 130         }
 131         if (memcmp(&fmt, "fmt ", 4)) {
 132                 ast_log(LOG_WARNING, "Does not say fmt\n");
 133                 return -1;
 134         }
 135         if (read(fd, &hsize, 4) != 4) {
 136                 ast_log(LOG_WARNING, "Read failed (formtype)\n");
 137                 return -1;
 138         }
 139         if (ltohl(hsize) != 20) {
 140                 ast_log(LOG_WARNING, "Unexpected header size %d\n", ltohl(hsize));
 141                 return -1;
 142         }
 143         if (read(fd, &format, 2) != 2) {
 144                 ast_log(LOG_WARNING, "Read failed (format)\n");
 145                 return -1;
 146         }
 147         if (ltohs(format) != 49) {
 148                 ast_log(LOG_WARNING, "Not a GSM file %d\n", ltohs(format));
 149                 return -1;
 150         }
 151         if (read(fd, &chans, 2) != 2) {
 152                 ast_log(LOG_WARNING, "Read failed (format)\n");
 153                 return -1;
 154         }
 155         if (ltohs(chans) != 1) {
 156                 ast_log(LOG_WARNING, "Not in mono %d\n", ltohs(chans));
 157                 return -1;
 158         }
 159         if (read(fd, &freq, 4) != 4) {
 160                 ast_log(LOG_WARNING, "Read failed (freq)\n");
 161                 return -1;
 162         }
 163         if (ltohl(freq) != 8000) {
 164                 ast_log(LOG_WARNING, "Unexpected freqency %d\n", ltohl(freq));
 165                 return -1;
 166         }
 167         /* Ignore the byte frequency */
 168         if (read(fd, &freq, 4) != 4) {
 169                 ast_log(LOG_WARNING, "Read failed (X_1)\n");
 170                 return -1;
 171         }
 172         /* Ignore the two weird fields */
 173         if (read(fd, &freq, 4) != 4) {
 174                 ast_log(LOG_WARNING, "Read failed (X_2/X_3)\n");
 175                 return -1;
 176         }
 177         /* Ignore the byte frequency */
 178         if (read(fd, &freq, 4) != 4) {
 179                 ast_log(LOG_WARNING, "Read failed (Y_1)\n");
 180                 return -1;
 181         }
 182         /* Check for the word fact */
 183         if (read(fd, &fact, 4) != 4) {
 184                 ast_log(LOG_WARNING, "Read failed (fact)\n");
 185                 return -1;
 186         }
 187         if (memcmp(&fact, "fact", 4)) {
 188                 ast_log(LOG_WARNING, "Does not say fact\n");
 189                 return -1;
 190         }
 191         /* Ignore the "fact value" */
 192         if (read(fd, &fact, 4) != 4) {
 193                 ast_log(LOG_WARNING, "Read failed (fact header)\n");
 194                 return -1;
 195         }
 196         if (read(fd, &fact, 4) != 4) {
 197                 ast_log(LOG_WARNING, "Read failed (fact value)\n");
 198                 return -1;
 199         }
 200         /* Check for the word data */
 201         if (read(fd, &data, 4) != 4) {
 202                 ast_log(LOG_WARNING, "Read failed (data)\n");
 203                 return -1;
 204         }
 205         if (memcmp(&data, "data", 4)) {
 206                 ast_log(LOG_WARNING, "Does not say data\n");
 207                 return -1;
 208         }
 209         /* Ignore the data length */
 210         if (read(fd, &data, 4) != 4) {
 211                 ast_log(LOG_WARNING, "Read failed (data)\n");
 212                 return -1;
 213         }
 214         return 0;
 215 }
 216
 217 static int update_header(int fd)
 218 {
 219         off_t cur,end,bytes;
 220         int datalen,filelen;
 221
 222         cur = lseek(fd, 0, SEEK_CUR);
 223         end = lseek(fd, 0, SEEK_END);
 224         /* in a gsm WAV, data starts 60 bytes in */
 225         bytes = end - 60;
 226         datalen = htoll((bytes + 1) & ~0x1);
 227         filelen = htoll(52 + ((bytes + 1) & ~0x1));
 228         if (cur < 0) {
 229                 ast_log(LOG_WARNING, "Unable to find our position\n");
 230                 return -1;
 231         }
 232         if (lseek(fd, 4, SEEK_SET) != 4) {
 233                 ast_log(LOG_WARNING, "Unable to set our position\n");
 234                 return -1;
 235         }
 236         if (write(fd, &filelen, 4) != 4) {
 237                 ast_log(LOG_WARNING, "Unable to set write file size\n");
 238                 return -1;
 239         }
 240         if (lseek(fd, 56, SEEK_SET) != 56) {
 241                 ast_log(LOG_WARNING, "Unable to set our position\n");
 242                 return -1;
 243         }
 244         if (write(fd, &datalen, 4) != 4) {
 245                 ast_log(LOG_WARNING, "Unable to set write datalen\n");
 246                 return -1;
 247         }
 248         if (lseek(fd, cur, SEEK_SET) != cur) {
 249                 ast_log(LOG_WARNING, "Unable to return to position\n");
 250                 return -1;
 251         }
 252         return 0;
 253 }
 254
 255 static int write_header(int fd)
 256 {
 257         unsigned int hz=htoll(8000);
 258         unsigned int bhz = htoll(1625);
 259         unsigned int hs = htoll(20);
 260         unsigned short fmt = htols(49);
 261         unsigned short chans = htols(1);
 262         unsigned int fhs = htoll(4);
 263         unsigned int x_1 = htoll(65);
 264         unsigned short x_2 = htols(2);
 265         unsigned short x_3 = htols(320);
 266         unsigned int y_1 = htoll(20160);
 267         unsigned int size = htoll(0);
 268         /* Write a GSM header, ignoring sizes which will be filled in later */
 269         if (write(fd, "RIFF", 4) != 4) {
 270                 ast_log(LOG_WARNING, "Unable to write header\n");
 271                 return -1;
 272         }
 273         if (write(fd, &size, 4) != 4) {
 274                 ast_log(LOG_WARNING, "Unable to write header\n");
 275                 return -1;
 276         }
 277         if (write(fd, "WAVEfmt ", 8) != 8) {
 278                 ast_log(LOG_WARNING, "Unable to write header\n");
 279                 return -1;
 280         }
 281         if (write(fd, &hs, 4) != 4) {
 282                 ast_log(LOG_WARNING, "Unable to write header\n");
 283                 return -1;
 284         }
 285         if (write(fd, &fmt, 2) != 2) {
 286                 ast_log(LOG_WARNING, "Unable to write header\n");
 287                 return -1;
 288         }
 289         if (write(fd, &chans, 2) != 2) {
 290                 ast_log(LOG_WARNING, "Unable to write header\n");
 291                 return -1;
 292         }
 293         if (write(fd, &hz, 4) != 4) {
 294                 ast_log(LOG_WARNING, "Unable to write header\n");
 295                 return -1;
 296         }
 297         if (write(fd, &bhz, 4) != 4) {
 298                 ast_log(LOG_WARNING, "Unable to write header\n");
 299                 return -1;
 300         }
 301         if (write(fd, &x_1, 4) != 4) {
 302                 ast_log(LOG_WARNING, "Unable to write header\n");
 303                 return -1;
 304         }
 305         if (write(fd, &x_2, 2) != 2) {
 306                 ast_log(LOG_WARNING, "Unable to write header\n");
 307                 return -1;
 308         }
 309         if (write(fd, &x_3, 2) != 2) {
 310                 ast_log(LOG_WARNING, "Unable to write header\n");
 311                 return -1;
 312         }
 313         if (write(fd, "fact", 4) != 4) {
 314                 ast_log(LOG_WARNING, "Unable to write header\n");
 315                 return -1;
 316         }
 317         if (write(fd, &fhs, 4) != 4) {
 318                 ast_log(LOG_WARNING, "Unable to write header\n");
 319                 return -1;
 320         }
 321         if (write(fd, &y_1, 4) != 4) {
 322                 ast_log(LOG_WARNING, "Unable to write header\n");
 323                 return -1;
 324         }
 325         if (write(fd, "data", 4) != 4) {
 326                 ast_log(LOG_WARNING, "Unable to write header\n");
 327                 return -1;
 328         }
 329         if (write(fd, &size, 4) != 4) {
 330                 ast_log(LOG_WARNING, "Unable to write header\n");
 331                 return -1;
 332         }
 333         return 0;
 334 }
 335
 336 static struct ast_filestream *wav_open(int fd)
 337 {
 338         /* We don't have any header to read or anything really, but
 339            if we did, it would go here.  We also might want to check
 340            and be sure it's a valid file.  */
 341         struct ast_filestream *tmp;
 342         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
 343                 memset(tmp, 0, sizeof(struct ast_filestream));
 344                 if (check_header(fd)) {
 345                         free(tmp);
 346                         return NULL;
 347                 }
 348                 if (ast_mutex_lock(&wav_lock)) {
 349                         ast_log(LOG_WARNING, "Unable to lock wav list\n");
 350                         free(tmp);
 351                         return NULL;
 352                 }
 353                 tmp->fd = fd;
 354                 tmp->fr.data = tmp->gsm;
 355                 tmp->fr.frametype = AST_FRAME_VOICE;
 356                 tmp->fr.subclass = AST_FORMAT_GSM;
 357                 /* datalen will vary for each frame */
 358                 tmp->fr.src = name;
 359                 tmp->fr.mallocd = 0;
 360                 tmp->secondhalf = 0;
 361                 glistcnt++;
 362                 ast_mutex_unlock(&wav_lock);
 363                 ast_update_use_count();
 364         }
 365         return tmp;
 366 }
 367
 368 static struct ast_filestream *wav_rewrite(int fd, const char *comment)
 369 {
 370         /* We don't have any header to read or anything really, but
 371            if we did, it would go here.  We also might want to check
 372            and be sure it's a valid file.  */
 373         struct ast_filestream *tmp;
 374         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
 375                 memset(tmp, 0, sizeof(struct ast_filestream));
 376                 if (write_header(fd)) {
 377                         free(tmp);
 378                         return NULL;
 379                 }
 380                 if (ast_mutex_lock(&wav_lock)) {
 381                         ast_log(LOG_WARNING, "Unable to lock wav list\n");
 382                         free(tmp);
 383                         return NULL;
 384                 }
 385                 tmp->fd = fd;
 386                 glistcnt++;
 387                 ast_mutex_unlock(&wav_lock);
 388                 ast_update_use_count();
 389         } else
 390                 ast_log(LOG_WARNING, "Out of memory\n");
 391         return tmp;
 392 }
 393
 394 static void wav_close(struct ast_filestream *s)
 395 {
 396         char zero = 0;
 397         if (ast_mutex_lock(&wav_lock)) {
 398                 ast_log(LOG_WARNING, "Unable to lock wav list\n");
 399                 return;
 400         }
 401         glistcnt--;
 402         ast_mutex_unlock(&wav_lock);
 403         ast_update_use_count();
 404         /* Pad to even length */
 405         if (s->bytes & 0x1)
 406                 write(s->fd, &zero, 1);
 407         close(s->fd);
 408         free(s);
 409         s = NULL;
 410 }
 411
 412 static struct ast_frame *wav_read(struct ast_filestream *s, int *whennext)
 413 {
 414         int res;
 415         char msdata[66];
 416         /* Send a frame from the file to the appropriate channel */
 417
 418         s->fr.frametype = AST_FRAME_VOICE;
 419         s->fr.subclass = AST_FORMAT_GSM;
 420         s->fr.offset = AST_FRIENDLY_OFFSET;
 421         s->fr.samples = 160;
 422         s->fr.datalen = 33;
 423         s->fr.mallocd = 0;
 424         if (s->secondhalf) {
 425                 /* Just return a frame based on the second GSM frame */
 426                 s->fr.data = s->gsm + 33;
 427         } else {
 428                 if ((res = read(s->fd, msdata, 65)) != 65) {
 429                         if (res && (res != 1))
 430                                 ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
 431                         return NULL;
 432                 }
 433                 /* Convert from MS format to two real GSM frames */
 434                 conv65(msdata, s->gsm);
 435                 s->fr.data = s->gsm;
 436         }
 437         s->secondhalf = !s->secondhalf;
 438         *whennext = 160;
 439         return &s->fr;
 440 }
 441
 442 static int wav_write(struct ast_filestream *fs, struct ast_frame *f)
 443 {
 444         int res;
 445         char msdata[66];
 446         int len =0;
 447         int alreadyms=0;
 448         if (f->frametype != AST_FRAME_VOICE) {
 449                 ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
 450                 return -1;
 451         }
 452         if (f->subclass != AST_FORMAT_GSM) {
 453                 ast_log(LOG_WARNING, "Asked to write non-GSM frame (%d)!\n", f->subclass);
 454                 return -1;
 455         }
 456         if (!(f->datalen % 65))
 457                 alreadyms = 1;
 458         while(len < f->datalen) {
 459                 if (alreadyms) {
 460                         fs->secondhalf = 0;
 461                         if ((res = write(fs->fd, f->data + len, 65)) != 65) {
 462                                 ast_log(LOG_WARNING, "Bad write (%d/65): %s\n", res, strerror(errno));
 463                                 return -1;
 464                         }
 465                         fs->bytes += 65;
 466                         update_header(fs->fd);
 467                         len += 65;
 468                 } else {
 469                         if (fs->secondhalf) {
 470                                 memcpy(fs->gsm + 33, f->data + len, 33);
 471                                 conv66(fs->gsm, msdata);
 472                                 if ((res = write(fs->fd, msdata, 65)) != 65) {
 473                                         ast_log(LOG_WARNING, "Bad write (%d/65): %s\n", res, strerror(errno));
 474                                         return -1;
 475                                 }
 476                                 fs->bytes += 65;
 477                                 update_header(fs->fd);
 478                         } else {
 479                                 /* Copy the data and do nothing */
 480                                 memcpy(fs->gsm, f->data + len, 33);
 481                         }
 482                         fs->secondhalf = !fs->secondhalf;
 483                         len += 33;
 484                 }
 485         }
 486         return 0;
 487 }
 488
 489 static int wav_seek(struct ast_filestream *fs, long sample_offset, int whence)
 490 {
 491         off_t offset=0,distance,cur,min,max;
 492         min = 60;
 493         cur = lseek(fs->fd, 0, SEEK_CUR);
 494         max = lseek(fs->fd, 0, SEEK_END);
 495         /* I'm getting sloppy here, I'm only going to go to even splits of the 2
 496          * frames, if you want tighter cuts use format_gsm, format_pcm, or format_wav */
 497         distance = (sample_offset/320) * 65;
 498         if(whence == SEEK_SET)
 499                 offset = distance + min;
 500         else if(whence == SEEK_CUR || whence == SEEK_FORCECUR)
 501                 offset = distance + cur;
 502         else if(whence == SEEK_END)
 503                 offset = max - distance;
 504         /* always protect against seeking past end of header */
 505         offset = (offset < min)?min:offset;
 506         if (whence != SEEK_FORCECUR) {
 507                 offset = (offset > max)?max:offset;
 508         } else if (offset > max) {
 509                 int i;
 510                 lseek(fs->fd, 0, SEEK_END);
 511                 for (i=0; i< (offset - max) / 65; i++) {
 512                         write(fs->fd, msgsm_silence, 65);
 513                 }
 514         }
 515         fs->secondhalf = 0;
 516         return lseek(fs->fd, offset, SEEK_SET);
 517 }
 518
 519 static int wav_trunc(struct ast_filestream *fs)
 520 {
 521         if(ftruncate(fs->fd, lseek(fs->fd, 0, SEEK_CUR)))
 522                 return -1;
 523         return update_header(fs->fd);
 524 }
 525
 526 static long wav_tell(struct ast_filestream *fs)
 527 {
 528         off_t offset;
 529         offset = lseek(fs->fd, 0, SEEK_CUR);
 530         /* since this will most likely be used later in play or record, lets stick
 531          * to that level of resolution, just even frames boundaries */
 532         return (offset - 52)/65*320;
 533 }
 534
 535 static char *wav_getcomment(struct ast_filestream *s)
 536 {
 537         return NULL;
 538 }
 539
 540 int load_module()
 541 {
 542         return ast_format_register(name, exts, AST_FORMAT_GSM,
 543                                                                 wav_open,
 544                                                                 wav_rewrite,
 545                                                                 wav_write,
 546                                                                 wav_seek,
 547                                                                 wav_trunc,
 548                                                                 wav_tell,
 549                                                                 wav_read,
 550                                                                 wav_close,
 551                                                                 wav_getcomment);
 552
 553
 554 }
 555
 556 int unload_module()
 557 {
 558         return ast_format_unregister(name);
 559 }
 560
 561 int usecount()
 562 {
 563         int res;
 564         if (ast_mutex_lock(&wav_lock)) {
 565                 ast_log(LOG_WARNING, "Unable to lock wav list\n");
 566                 return -1;
 567         }
 568         res = glistcnt;
 569         ast_mutex_unlock(&wav_lock);
 570         return res;
 571 }
 572
 573 char *description()
 574 {
 575         return desc;
 576 }
 577
 578
 579 char *key()
 580 {
 581         return ASTERISK_GPL_KEY;
 582 }