src/8svx.c

   1 /* Amiga 8SVX format handler: W V Neisius, February 1992 */
   2
   3 #include "sox_i.h"
   4
   5 #include <errno.h>
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9
  10 #define BUFLEN 512
  11
  12 /* Private data used by writer */
  13 typedef struct{
  14   uint32_t nsamples;
  15   uint32_t left;
  16   off_t ch0_pos;
  17   sox_uint8_t buf[4][BUFLEN];
  18   FILE* tmp[4];
  19 } priv_t;
  20
  21 static void svxwriteheader(sox_format_t *, size_t);
  22
  23 /*======================================================================*/
  24 /*                         8SVXSTARTREAD                                */
  25 /*======================================================================*/
  26
  27 static int startread(sox_format_t * ft)
  28 {
  29         priv_t * p = (priv_t * ) ft->priv;
  30
  31         char buf[12];
  32         char *chunk_buf;
  33
  34         uint32_t totalsize;
  35         uint32_t chunksize;
  36
  37         uint32_t channels;
  38         unsigned short rate;
  39
  40         if (! ft->seekable)
  41         {
  42                 lsx_fail_errno(ft,SOX_EINVAL,"8svx input file must be a file, not a pipe");
  43                 return (SOX_EOF);
  44         }
  45         rate = 0;
  46         channels = 1;
  47
  48         /* read FORM chunk */
  49         if (lsx_reads(ft, buf, (size_t)4) == SOX_EOF || strncmp(buf, "FORM", (size_t)4) != 0)
  50         {
  51                 lsx_fail_errno(ft, SOX_EHDR, "Header did not begin with magic word `FORM'");
  52                 return(SOX_EOF);
  53         }
  54         lsx_readdw(ft, &totalsize);
  55         if (lsx_reads(ft, buf, (size_t)4) == SOX_EOF || strncmp(buf, "8SVX", (size_t)4) != 0)
  56         {
  57                 lsx_fail_errno(ft, SOX_EHDR, "'FORM' chunk does not specify `8SVX' as type");
  58                 return(SOX_EOF);
  59         }
  60
  61         /* read chunks until 'BODY' (or end) */
  62         while (lsx_reads(ft, buf, (size_t)4) == SOX_SUCCESS && strncmp(buf,"BODY",(size_t)4) != 0) {
  63                 if (strncmp(buf,"VHDR",(size_t)4) == 0) {
  64                         lsx_readdw(ft, &chunksize);
  65                         if (chunksize != 20)
  66                         {
  67                                 lsx_fail_errno(ft, SOX_EHDR, "VHDR chunk has bad size");
  68                                 return(SOX_EOF);
  69                         }
  70                         lsx_seeki(ft,(off_t)12,SEEK_CUR);
  71                         lsx_readw(ft, &rate);
  72                         lsx_seeki(ft,(off_t)1,SEEK_CUR);
  73                         lsx_readbuf(ft, buf,(size_t)1);
  74                         if (buf[0] != 0)
  75                         {
  76                                 lsx_fail_errno(ft, SOX_EFMT, "Unsupported data compression");
  77                                 return(SOX_EOF);
  78                         }
  79                         lsx_seeki(ft,(off_t)4,SEEK_CUR);
  80                         continue;
  81                 }
  82
  83                 if (strncmp(buf,"ANNO",(size_t)4) == 0) {
  84                         lsx_readdw(ft, &chunksize);
  85                         if (chunksize & 1)
  86                                 chunksize++;
  87                         chunk_buf = lsx_malloc(chunksize + (size_t)2);
  88                         if (lsx_readbuf(ft, chunk_buf,(size_t)chunksize)
  89                                         != chunksize)
  90                         {
  91                                 lsx_fail_errno(ft, SOX_EHDR, "Couldn't read all of header");
  92                                 return(SOX_EOF);
  93                         }
  94                         chunk_buf[chunksize] = '\0';
  95                         lsx_debug("%s",chunk_buf);
  96                         free(chunk_buf);
  97
  98                         continue;
  99                 }
 100
 101                 if (strncmp(buf,"NAME",(size_t)4) == 0) {
 102                         lsx_readdw(ft, &chunksize);
 103                         if (chunksize & 1)
 104                                 chunksize++;
 105                         chunk_buf = lsx_malloc(chunksize + (size_t)1);
 106                         if (lsx_readbuf(ft, chunk_buf,(size_t)chunksize)
 107                                         != chunksize)
 108                         {
 109                                 lsx_fail_errno(ft, SOX_EHDR, "Couldn't read all of header");
 110                                 return(SOX_EOF);
 111                         }
 112                         chunk_buf[chunksize] = '\0';
 113                         lsx_debug("%s",chunk_buf);
 114                         free(chunk_buf);
 115
 116                         continue;
 117                 }
 118
 119                 if (strncmp(buf,"CHAN",(size_t)4) == 0) {
 120                         lsx_readdw(ft, &chunksize);
 121                         if (chunksize != 4)
 122                         {
 123                                 lsx_fail_errno(ft, SOX_EHDR, "Couldn't read all of header");
 124                                 return(SOX_EOF);
 125                         }
 126                         lsx_readdw(ft, &channels);
 127                         channels = (channels & 0x01) +
 128                                         ((channels & 0x02) >> 1) +
 129                                         ((channels & 0x04) >> 2) +
 130                                         ((channels & 0x08) >> 3);
 131
 132                         continue;
 133                 }
 134
 135                 /* some other kind of chunk */
 136                 lsx_readdw(ft, &chunksize);
 137                 if (chunksize & 1)
 138                         chunksize++;
 139                 lsx_seeki(ft,(off_t)chunksize,SEEK_CUR);
 140                 continue;
 141
 142         }
 143
 144         if (rate == 0)
 145         {
 146                 lsx_fail_errno(ft, SOX_EHDR, "Invalid sample rate");
 147                 return(SOX_EOF);
 148         }
 149         if (strncmp(buf,"BODY",(size_t)4) != 0)
 150         {
 151                 lsx_fail_errno(ft, SOX_EHDR, "BODY chunk not found");
 152                 return(SOX_EOF);
 153         }
 154         lsx_readdw(ft, &(p->nsamples));
 155         p->left = p->nsamples;
 156         p->ch0_pos = lsx_tell(ft);
 157
 158         ft->signal.length = p->nsamples;
 159         ft->signal.channels = channels;
 160         ft->signal.rate = rate;
 161         ft->encoding.encoding = SOX_ENCODING_SIGN2;
 162         ft->encoding.bits_per_sample = 8;
 163
 164         return(SOX_SUCCESS);
 165 }
 166
 167 /*======================================================================*/
 168 /*                         8SVXREAD                                     */
 169 /*======================================================================*/
 170 static size_t read_samples(sox_format_t * ft, sox_sample_t *buf, size_t nsamp)
 171 {
 172     size_t done = 0;
 173
 174     priv_t * p = (priv_t * ) ft->priv;
 175     size_t frames = nsamp / ft->signal.channels;
 176     unsigned width = p->nsamples / ft->signal.channels;
 177
 178     if (p->left < frames)
 179         frames = p->left;
 180
 181     while (done != frames) {
 182         size_t chunk = frames - done;
 183         size_t i;
 184         unsigned ch;
 185
 186         if (chunk > BUFLEN)
 187             chunk = BUFLEN;
 188
 189         for (ch = 0; ch != ft->signal.channels; ch++) {
 190             if (lsx_seeki(ft, p->ch0_pos + ch * width, SEEK_SET) ||
 191                 chunk != lsx_readbuf(ft, p->buf[ch], chunk))
 192                 return done * ft->signal.channels;
 193         }
 194
 195         for (i = 0; i != chunk; i++) {
 196             for (ch = 0; ch != ft->signal.channels; ch++) {
 197                 /* scale signed up to long's range */
 198                 *buf++ = SOX_SIGNED_8BIT_TO_SAMPLE(p->buf[ch][i], dummy);
 199             }
 200         }
 201
 202         done += chunk;
 203         p->left -= chunk * ft->signal.channels;
 204         p->ch0_pos += chunk;
 205     }
 206     return done * ft->signal.channels;
 207 }
 208
 209 /*======================================================================*/
 210 /*                         8SVXSTARTWRITE                               */
 211 /*======================================================================*/
 212 static int startwrite(sox_format_t * ft)
 213 {
 214         priv_t * p = (priv_t * ) ft->priv;
 215         size_t i;
 216
 217         /* open channel output files */
 218         for (i = 0; i < ft->signal.channels; i++) {
 219                 if ((p->tmp[i] = lsx_tmpfile()) == NULL)
 220                 {
 221                         lsx_fail_errno(ft,errno,"Can't open channel output file");
 222                         return(SOX_EOF);
 223                 }
 224         }
 225
 226         p->nsamples = 0;
 227         return(SOX_SUCCESS);
 228 }
 229
 230 /*======================================================================*/
 231 /*                         8SVXWRITE                                    */
 232 /*======================================================================*/
 233
 234 static size_t write_samples(sox_format_t * ft, const sox_sample_t *buf, size_t len)
 235 {
 236         priv_t * p = (priv_t * ) ft->priv;
 237         SOX_SAMPLE_LOCALS;
 238
 239         unsigned char datum;
 240         size_t done = 0, i;
 241
 242         p->nsamples += len;
 243
 244         while(done < len) {
 245                 for (i = 0; i < ft->signal.channels; i++) {
 246                         datum = SOX_SAMPLE_TO_SIGNED_8BIT(*buf++, ft->clips);
 247                         putc(datum, p->tmp[i]);
 248                 }
 249                 done += ft->signal.channels;
 250         }
 251         return (done);
 252 }
 253
 254 /*======================================================================*/
 255 /*                         8SVXSTOPWRITE                                */
 256 /*======================================================================*/
 257
 258 static int stopwrite(sox_format_t * ft)
 259 {
 260         priv_t * p = (priv_t * ) ft->priv;
 261
 262         size_t i, len;
 263         char svxbuf[512];
 264
 265         svxwriteheader(ft, (size_t) p->nsamples);
 266
 267         /* append all channel pieces to channel 0 */
 268         /* close temp files */
 269         for (i = 0; i < ft->signal.channels; i++) {
 270                 if (fseeko(p->tmp[i], (off_t)0, 0))
 271                 {
 272                         lsx_fail_errno (ft,errno,"Can't rewind channel output file %lu",(unsigned long)i);
 273                         return(SOX_EOF);
 274                 }
 275                 while (!feof(p->tmp[i])) {
 276                         len = fread(svxbuf, (size_t) 1, (size_t) 512, p->tmp[i]);
 277                         if (lsx_writebuf(ft, svxbuf, len) != len) {
 278                           lsx_fail_errno (ft,errno,"Can't write channel output file %lu",(unsigned long)i);
 279                           return SOX_EOF;
 280                         }
 281                 }
 282                 fclose (p->tmp[i]);
 283         }
 284
 285         /* add a pad byte if BODY size is odd */
 286         if(p->nsamples % 2 != 0)
 287             lsx_writeb(ft, '\0');
 288
 289         return(SOX_SUCCESS);
 290 }
 291
 292 /*======================================================================*/
 293 /*                         8SVXWRITEHEADER                              */
 294 /*======================================================================*/
 295 #define SVXHEADERSIZE 100
 296 static void svxwriteheader(sox_format_t * ft, size_t nsamples)
 297 {
 298         size_t formsize =  nsamples + SVXHEADERSIZE - 8;
 299
 300         /* FORM size must be even */
 301         if(formsize % 2 != 0) formsize++;
 302
 303         lsx_writes(ft, "FORM");
 304         lsx_writedw(ft, (unsigned) formsize);  /* size of file */
 305         lsx_writes(ft, "8SVX"); /* File type */
 306
 307         lsx_writes(ft, "VHDR");
 308         lsx_writedw(ft, 20); /* number of bytes to follow */
 309         lsx_writedw(ft, (unsigned) nsamples/ft->signal.channels);  /* samples, 1-shot */
 310         lsx_writedw(ft, 0);  /* samples, repeat */
 311         lsx_writedw(ft, 0);  /* samples per repeat cycle */
 312         lsx_writew(ft, min(65535, (unsigned)(ft->signal.rate + .5)));
 313         lsx_writeb(ft,1); /* number of octabes */
 314         lsx_writeb(ft,0); /* data compression (none) */
 315         lsx_writew(ft,1); lsx_writew(ft,0); /* volume */
 316
 317         lsx_writes(ft, "ANNO");
 318         lsx_writedw(ft, 32); /* length of block */
 319         lsx_writes(ft, "File created by Sound Exchange  ");
 320
 321         lsx_writes(ft, "CHAN");
 322         lsx_writedw(ft, 4);
 323         lsx_writedw(ft, (ft->signal.channels == 2) ? 6u :
 324                    (ft->signal.channels == 4) ? 15u : 2u);
 325
 326         lsx_writes(ft, "BODY");
 327         lsx_writedw(ft, (unsigned) nsamples); /* samples in file */
 328 }
 329
 330 LSX_FORMAT_HANDLER(svx)
 331 {
 332   static char const * const names[] = {"8svx", NULL};
 333   static unsigned const write_encodings[] = {SOX_ENCODING_SIGN2, 8, 0, 0};
 334   static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
 335     "Amiga audio format (a subformat of the Interchange File Format)",
 336     names, SOX_FILE_BIG_END|SOX_FILE_MONO|SOX_FILE_STEREO|SOX_FILE_QUAD,
 337     startread, read_samples, NULL,
 338     startwrite, write_samples, stopwrite,
 339     NULL, write_encodings, NULL, sizeof(priv_t)
 340   };
 341   return &handler;
 342 }