src/maud.c

   1 /* libSoX MAUD file format handler, by Lutz Vieweg 1993
   2  *
   3  * supports: mono and stereo, linear, a-law and u-law reading and writing
   4  *
   5  * an IFF format; description at http://lclevy.free.fr/amiga/MAUDINFO.TXT
   6  *
   7  * Copyright 1998-2006 Chris Bagwell and SoX Contributors
   8  * This source code is freely redistributable and may be used for
   9  * any purpose.  This copyright notice must be maintained.
  10  * Lance Norskog And Sundry Contributors are not responsible for
  11  * the consequences of using this software.
  12  */
  13
  14 #include "sox_i.h"
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <errno.h>
  19
  20 /* Private data for MAUD file */
  21 typedef struct {
  22         uint32_t nsamples;
  23 } priv_t;
  24
  25 static void maudwriteheader(sox_format_t *);
  26
  27 /*
  28  * Do anything required before you start reading samples.
  29  * Read file header.
  30  *      Find out sampling rate,
  31  *      size and encoding of samples,
  32  *      mono/stereo/quad.
  33  */
  34 static int startread(sox_format_t * ft)
  35 {
  36         priv_t * p = (priv_t *) ft->priv;
  37
  38         char buf[12];
  39         char *chunk_buf;
  40
  41         unsigned short bitpersam;
  42         uint32_t nom;
  43         unsigned short denom;
  44         unsigned short chaninf;
  45
  46         uint32_t chunksize;
  47         uint32_t trash32;
  48         uint16_t trash16;
  49         int rc;
  50
  51         /* Needed for rawread() */
  52         rc = lsx_rawstartread(ft);
  53         if (rc)
  54             return rc;
  55
  56         /* read FORM chunk */
  57         if (lsx_reads(ft, buf, (size_t)4) == SOX_EOF || strncmp(buf, "FORM", (size_t)4) != 0)
  58         {
  59                 lsx_fail_errno(ft,SOX_EHDR,"MAUD: header does not begin with magic word `FORM'");
  60                 return (SOX_EOF);
  61         }
  62
  63         lsx_readdw(ft, &trash32); /* totalsize */
  64
  65         if (lsx_reads(ft, buf, (size_t)4) == SOX_EOF || strncmp(buf, "MAUD", (size_t)4) != 0)
  66         {
  67                 lsx_fail_errno(ft,SOX_EHDR,"MAUD: `FORM' chunk does not specify `MAUD' as type");
  68                 return(SOX_EOF);
  69         }
  70
  71         /* read chunks until 'BODY' (or end) */
  72
  73         while (lsx_reads(ft, buf, (size_t)4) == SOX_SUCCESS && strncmp(buf,"MDAT",(size_t)4) != 0) {
  74
  75                 /*
  76                 buf[4] = 0;
  77                 lsx_debug("chunk %s",buf);
  78                 */
  79
  80                 if (strncmp(buf,"MHDR",(size_t)4) == 0) {
  81
  82                         lsx_readdw(ft, &chunksize);
  83                         if (chunksize != 8*4)
  84                         {
  85                             lsx_fail_errno(ft,SOX_EHDR,"MAUD: MHDR chunk has bad size");
  86                             return(SOX_EOF);
  87                         }
  88
  89                         /* number of samples stored in MDAT */
  90                         lsx_readdw(ft, &(p->nsamples));
  91
  92                         /* number of bits per sample as stored in MDAT */
  93                         lsx_readw(ft, &bitpersam);
  94
  95                         /* number of bits per sample after decompression */
  96                         lsx_readw(ft, &trash16);
  97
  98                         lsx_readdw(ft, &nom);         /* clock source frequency */
  99                         lsx_readw(ft, &denom);       /* clock devide           */
 100                         if (denom == 0)
 101                         {
 102                             lsx_fail_errno(ft,SOX_EHDR,"MAUD: frequency denominator == 0, failed");
 103                             return (SOX_EOF);
 104                         }
 105
 106                         ft->signal.rate = nom / denom;
 107
 108                         lsx_readw(ft, &chaninf); /* channel information */
 109                         switch (chaninf) {
 110                         case 0:
 111                                 ft->signal.channels = 1;
 112                                 break;
 113                         case 1:
 114                                 ft->signal.channels = 2;
 115                                 break;
 116                         default:
 117                                 lsx_fail_errno(ft,SOX_EFMT,"MAUD: unsupported number of channels in file");
 118                                 return (SOX_EOF);
 119                         }
 120
 121                         lsx_readw(ft, &chaninf); /* number of channels (mono: 1, stereo: 2, ...) */
 122                         if (chaninf != ft->signal.channels)
 123                         {
 124                                 lsx_fail_errno(ft,SOX_EFMT,"MAUD: unsupported number of channels in file");
 125                             return(SOX_EOF);
 126                         }
 127
 128                         lsx_readw(ft, &chaninf); /* compression type */
 129
 130                         lsx_readdw(ft, &trash32); /* rest of chunk, unused yet */
 131                         lsx_readdw(ft, &trash32);
 132                         lsx_readdw(ft, &trash32);
 133
 134                         if (bitpersam == 8 && chaninf == 0) {
 135                                 ft->encoding.bits_per_sample = 8;
 136                                 ft->encoding.encoding = SOX_ENCODING_UNSIGNED;
 137                         }
 138                         else if (bitpersam == 8 && chaninf == 2) {
 139                                 ft->encoding.bits_per_sample = 8;
 140                                 ft->encoding.encoding = SOX_ENCODING_ALAW;
 141                         }
 142                         else if (bitpersam == 8 && chaninf == 3) {
 143                                 ft->encoding.bits_per_sample = 8;
 144                                 ft->encoding.encoding = SOX_ENCODING_ULAW;
 145                         }
 146                         else if (bitpersam == 16 && chaninf == 0) {
 147                                 ft->encoding.bits_per_sample = 16;
 148                                 ft->encoding.encoding = SOX_ENCODING_SIGN2;
 149                         }
 150                         else
 151                         {
 152                                 lsx_fail_errno(ft,SOX_EFMT,"MAUD: unsupported compression type detected");
 153                                 return(SOX_EOF);
 154                         }
 155
 156                         continue;
 157                 }
 158
 159                 if (strncmp(buf,"ANNO",(size_t)4) == 0) {
 160                         lsx_readdw(ft, &chunksize);
 161                         if (chunksize & 1)
 162                                 chunksize++;
 163                         chunk_buf = lsx_malloc(chunksize + (size_t)1);
 164                         if (lsx_readbuf(ft, chunk_buf, (size_t)chunksize)
 165                             != chunksize)
 166                         {
 167                                 lsx_fail_errno(ft,SOX_EOF,"MAUD: Unexpected EOF in ANNO header");
 168                                 return(SOX_EOF);
 169                         }
 170                         chunk_buf[chunksize] = '\0';
 171                         lsx_debug("%s",chunk_buf);
 172                         free(chunk_buf);
 173
 174                         continue;
 175                 }
 176
 177                 /* some other kind of chunk */
 178                 lsx_readdw(ft, &chunksize);
 179                 if (chunksize & 1)
 180                         chunksize++;
 181                 lsx_seeki(ft, (off_t)chunksize, SEEK_CUR);
 182                 continue;
 183
 184         }
 185
 186         if (strncmp(buf,"MDAT",(size_t)4) != 0)
 187         {
 188             lsx_fail_errno(ft,SOX_EFMT,"MAUD: MDAT chunk not found");
 189             return(SOX_EOF);
 190         }
 191         lsx_readdw(ft, &(p->nsamples));
 192         return(SOX_SUCCESS);
 193 }
 194
 195 static int startwrite(sox_format_t * ft)
 196 {
 197         priv_t * p = (priv_t *) ft->priv;
 198         int rc;
 199
 200         /* Needed for rawwrite() */
 201         rc = lsx_rawstartwrite(ft);
 202         if (rc)
 203             return rc;
 204
 205         /* If you have to seek around the output file */
 206         if (! ft->seekable)
 207         {
 208             lsx_fail_errno(ft,SOX_EOF,"Output .maud file must be a file, not a pipe");
 209             return (SOX_EOF);
 210         }
 211         p->nsamples = 0x7f000000;
 212         maudwriteheader(ft);
 213         p->nsamples = 0;
 214         return (SOX_SUCCESS);
 215 }
 216
 217 static size_t write_samples(sox_format_t * ft, const sox_sample_t *buf, size_t len)
 218 {
 219         priv_t * p = (priv_t *) ft->priv;
 220
 221         p->nsamples += len;
 222
 223         return lsx_rawwrite(ft, buf, len);
 224 }
 225
 226 static int stopwrite(sox_format_t * ft)
 227 {
 228         /* All samples are already written out. */
 229
 230         priv_t *p = (priv_t*)ft->priv;
 231         uint32_t mdat_size; /* MDAT chunk size */
 232         mdat_size = p->nsamples * (ft->encoding.bits_per_sample >> 3);
 233         lsx_padbytes(ft, (size_t) (mdat_size%2));
 234
 235         if (lsx_seeki(ft, (off_t)0, 0) != 0)
 236         {
 237             lsx_fail_errno(ft,errno,"can't rewind output file to rewrite MAUD header");
 238             return(SOX_EOF);
 239         }
 240
 241         maudwriteheader(ft);
 242         return(SOX_SUCCESS);
 243 }
 244
 245 #define MAUDHEADERSIZE (4+(4+4+32)+(4+4+19+1)+(4+4))
 246 static void maudwriteheader(sox_format_t * ft)
 247 {
 248         priv_t * p = (priv_t *) ft->priv;
 249         uint32_t mdat_size; /* MDAT chunk size */
 250
 251         mdat_size = p->nsamples * (ft->encoding.bits_per_sample >> 3);
 252
 253         lsx_writes(ft, "FORM");
 254         lsx_writedw(ft, MAUDHEADERSIZE + mdat_size + mdat_size%2);  /* size of file */
 255         lsx_writes(ft, "MAUD"); /* File type */
 256
 257         lsx_writes(ft, "MHDR");
 258         lsx_writedw(ft,  8*4); /* number of bytes to follow */
 259         lsx_writedw(ft, p->nsamples);  /* number of samples stored in MDAT */
 260
 261         switch (ft->encoding.encoding) {
 262
 263         case SOX_ENCODING_UNSIGNED:
 264           lsx_writew(ft, 8); /* number of bits per sample as stored in MDAT */
 265           lsx_writew(ft, 8); /* number of bits per sample after decompression */
 266           break;
 267
 268         case SOX_ENCODING_SIGN2:
 269           lsx_writew(ft, 16); /* number of bits per sample as stored in MDAT */
 270           lsx_writew(ft, 16); /* number of bits per sample after decompression */
 271           break;
 272
 273         case SOX_ENCODING_ALAW:
 274         case SOX_ENCODING_ULAW:
 275           lsx_writew(ft, 8); /* number of bits per sample as stored in MDAT */
 276           lsx_writew(ft, 16); /* number of bits per sample after decompression */
 277           break;
 278
 279         default:
 280           break;
 281         }
 282
 283         lsx_writedw(ft, (unsigned)(ft->signal.rate + .5)); /* sample rate, Hz */
 284         lsx_writew(ft, (int) 1); /* clock devide */
 285
 286         if (ft->signal.channels == 1) {
 287           lsx_writew(ft, 0); /* channel information */
 288           lsx_writew(ft, 1); /* number of channels (mono: 1, stereo: 2, ...) */
 289         }
 290         else {
 291           lsx_writew(ft, 1);
 292           lsx_writew(ft, 2);
 293         }
 294
 295         switch (ft->encoding.encoding) {
 296
 297         case SOX_ENCODING_UNSIGNED:
 298         case SOX_ENCODING_SIGN2:
 299           lsx_writew(ft, 0); /* no compression */
 300           break;
 301
 302         case SOX_ENCODING_ULAW:
 303           lsx_writew(ft, 3);
 304           break;
 305
 306         case SOX_ENCODING_ALAW:
 307           lsx_writew(ft, 2);
 308           break;
 309
 310         default:
 311           break;
 312         }
 313
 314         lsx_writedw(ft, 0); /* reserved */
 315         lsx_writedw(ft, 0); /* reserved */
 316         lsx_writedw(ft, 0); /* reserved */
 317
 318         lsx_writes(ft, "ANNO");
 319         lsx_writedw(ft, 19); /* length of block */
 320         lsx_writes(ft, "file created by SoX");
 321         lsx_padbytes(ft, (size_t)1);
 322
 323         lsx_writes(ft, "MDAT");
 324         lsx_writedw(ft, p->nsamples * (ft->encoding.bits_per_sample >> 3)); /* samples in file */
 325 }
 326
 327 LSX_FORMAT_HANDLER(maud)
 328 {
 329   static char const * const names[] = {"maud", NULL};
 330   static unsigned const write_encodings[] = {
 331     SOX_ENCODING_SIGN2, 16, 0,
 332     SOX_ENCODING_UNSIGNED, 8, 0,
 333     SOX_ENCODING_ULAW, 8, 0,
 334     SOX_ENCODING_ALAW, 8, 0,
 335     0};
 336   static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
 337     "Used with the ‘Toccata’ sound-card on the Amiga",
 338     names, SOX_FILE_BIG_END | SOX_FILE_MONO | SOX_FILE_STEREO,
 339     startread, lsx_rawread, lsx_rawstopread,
 340     startwrite, write_samples, stopwrite,
 341     NULL, write_encodings, NULL, sizeof(priv_t)
 342   };
 343   return &handler;
 344 }