ss_input.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     ss_input.c - Code to load softsynth sounds in different formats
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "ahxm.h"
  33
  34 /*******************
  35         Data
  36 ********************/
  37
  38 /* maximum page size */
  39 int ss_page_size = 441000;
  40
  41 /*******************
  42         Code
  43 ********************/
  44
  45 static int fget16(FILE * f)
  46 /* Reads a 16 bit integer from a file in big endian byte ordering */
  47 {
  48         int c;
  49
  50         c = fgetc(f);
  51         c += (fgetc(f) * 256);
  52
  53         return c;
  54 }
  55
  56
  57 static int fget32(FILE * f)
  58 /* Reads a 32 bit integer from a file in big endian byte ordering */
  59 {
  60         int c;
  61
  62         c = fgetc(f);
  63         c += (fgetc(f) * 256);
  64         c += (fgetc(f) * 65536);
  65         c += (fgetc(f) * 16777216);
  66
  67         return c;
  68 }
  69
  70
  71 static sample_t load_sample(FILE * f, int bits, int sign)
  72 /* loads one sample from a file */
  73 {
  74         int s;
  75
  76         /* if on eof, return silence */
  77         if (feof(f))
  78                 return 0;
  79
  80         if (bits == 8) {
  81                 s = fgetc(f) - 128;
  82                 s <<= 8;
  83         }
  84         else {
  85                 if (!sign)
  86                         s = fget16(f) - 32768;
  87                 else
  88                         s = (short int) fget16(f);
  89         }
  90
  91         return ((sample_t) s) / 32768.0;
  92 }
  93
  94
  95 void load_pcm_wave(FILE * f, struct ss_wave *w)
  96 /* loads an interleaved stream from a file */
  97 {
  98         int n, m;
  99
 100         /* fills the channels */
 101         for (m = 0; m < w->p_size; m++) {
 102                 for (n = 0; n < w->n_channels; n++)
 103                         w->wave[n][m] = load_sample(f, w->bits, w->sign);
 104         }
 105 }
 106
 107
 108 /**
 109  * ss_load_wav_file - Loads a file in .WAV format.
 110  * @file: name of the file
 111  * @base_freq: base frequency
 112  * @min_freq: minimum frequency
 113  * @max_freq: maximum frequency
 114  * @loop_start: frame number of loop start (-1, no loop)
 115  * @loop_end: frame number of loop end (-1, end of wave)
 116  * @first_channel: first channel to start spreading
 117  * @skip_channels: channels to skip when spreading
 118  *
 119  * Loads a file in .WAV format.
 120  */
 121 struct ss_wave *ss_load_wav_file(char *file,
 122                                  double base_freq, double min_freq, double max_freq,
 123                                  double loop_start, double loop_end,
 124                                  int first_channel, int skip_channels)
 125 {
 126         FILE *f;
 127         char dummydata[256];
 128         int rlen, flen;
 129         short int b_per_sec, n_channels;
 130         char riffid[5], waveid[5], fmtid[5], dataid[5];
 131         double size;
 132         int s_rate, bits;
 133         struct ss_wave *w;
 134         int p;
 135
 136         if (*file == '|')
 137                 file = transconv_pipe(file + 1, ".wav", "ahxm");
 138         else {
 139                 /* find the file in the library path */
 140                 if ((file = libpath_locate(file)) == NULL)
 141                         return NULL;
 142
 143                 /* try converting */
 144                 if ((file = transconv(file, ".wav", "ahxm")) == NULL)
 145                         return NULL;
 146         }
 147
 148         if ((f = fopen(file, "r")) == NULL)
 149                 return NULL;
 150
 151         fread(riffid, 1, 4, f);
 152         riffid[4] = 0;
 153         fread(&rlen, 1, 4, f);
 154         fread(waveid, 1, 4, f);
 155         waveid[4] = 0;
 156
 157         if (strcmp(waveid, "WAVE")) {
 158                 fclose(f);
 159                 return NULL;
 160         }
 161
 162         fread(fmtid, 1, 4, f);
 163         fmtid[4] = 0;
 164         flen = fget32(f);
 165
 166         if (flen > 240)
 167                 flen = 240;
 168
 169         if (fget16(f) != 1) {
 170                 /* wicked compressed format? fail */
 171                 fclose(f);
 172                 return NULL;
 173         }
 174
 175         n_channels = fget16(f);
 176         s_rate = fget32(f);
 177         b_per_sec = fget32(f);
 178
 179         bits = fget16(f) / n_channels;
 180         bits *= 8;
 181
 182         fread(dummydata, 1, (size_t) flen - 14, f);
 183         fread(dataid, 1, 4, f);
 184         dataid[4] = 0;
 185
 186         size = (double) fget32(f);
 187         if (bits == 16)
 188                 size /= 2;
 189         size /= (double) n_channels;
 190
 191         p = size > ss_page_size ? ss_page_size : size;
 192
 193         if ((w = ss_alloc_wave(size, n_channels, s_rate, p)) != NULL) {
 194                 w->base_freq = base_freq;
 195                 w->min_freq = min_freq;
 196                 w->max_freq = max_freq;
 197
 198                 w->loop_start = loop_start;
 199
 200                 if (loop_end < 0)
 201                         w->loop_end = size;
 202                 else
 203                         w->loop_end = loop_end;
 204
 205                 w->first_channel = first_channel;
 206                 w->skip_channels = skip_channels;
 207
 208                 /* fill the info needed for paging */
 209                 w->filename = strdup(file);
 210                 w->f_pos = ftell(f);
 211                 w->bits = bits;
 212                 w->sign = 1;
 213
 214                 /* set the page offset further the end, to
 215                    force a page reading the first time it's used */
 216                 w->p_offset = (int) size;
 217         }
 218
 219         fclose(f);
 220
 221         return w;
 222 }
 223
 224
 225 /**
 226  * ss_load_pat_file - Loads an instrument in .PAT format.
 227  * @i: The instrument
 228  * @filename: filename holding the instrument
 229  *
 230  * Loads data from a Gravis Ultrasound patch (.PAT) format and
 231  * stores it as layers for an instrument.
 232  *
 233  * Returns -100 if the file could not be read, -101 or -102
 234  * if the file is not recognized as a .PAT file, or 0 if
 235  * everything went OK.
 236  */
 237 int ss_load_pat_file(struct ss_ins *i, char *file)
 238 {
 239         FILE *f;
 240         char buffer[512];
 241         int m, n, o;
 242         int n_layers;
 243         int flags, bits, sign, loop, pingpong;
 244         struct ss_wave *w;
 245
 246         if ((f = libpath_fopen(file, "r")) == NULL)
 247                 return -100;
 248
 249         /* read signatures */
 250         fread(buffer, 12, 1, f);
 251         if (strcmp(buffer, "GF1PATCH110") != 0) {
 252                 fclose(f);
 253                 return -101;
 254         }
 255
 256         fread(buffer, 10, 1, f);
 257         if (strcmp(buffer, "ID#000002") != 0) {
 258                 fclose(f);
 259                 return -102;
 260         }
 261
 262         /* skip description */
 263         fread(buffer, 65, 1, f);
 264
 265         /* ignore volume */
 266         fget16(f);
 267
 268         /* skip */
 269         fread(buffer, 109, 1, f);
 270
 271         /* # of layers */
 272         n_layers = fgetc(f);
 273
 274         /* skip */
 275         fread(buffer, 40, 1, f);
 276
 277         for (n = 0; n < n_layers; n++) {
 278                 int size, s_rate;
 279                 double loop_start, loop_end;
 280                 double min_freq, max_freq, base_freq;
 281
 282                 /* layer name */
 283                 fread(buffer, 8, 1, f);
 284
 285                 size = (double) fget32(f);
 286                 loop_start = (double) fget32(f);
 287                 loop_end = (double) fget32(f);
 288                 s_rate = fget16(f);
 289
 290                 min_freq = ((double) fget32(f)) / 1000.0;
 291                 max_freq = ((double) fget32(f)) / 1000.0;
 292                 base_freq = ((double) fget32(f)) / 1000.0;
 293
 294                 if (base_freq < 0)
 295                         break;
 296
 297                 /* ignore fine-tune */
 298                 fget16(f);
 299
 300                 /* ignore pan position */
 301                 fgetc(f);
 302
 303                 /* skip envelope rate, value, tremolo and vibrato */
 304                 fread(buffer, 18, 1, f);
 305
 306                 flags = fgetc(f);
 307
 308                 bits = flags & 0x01 ? 16 : 8;
 309                 sign = flags & 0x02 ? 0 : 1;
 310                 loop = flags & 0x04 ? 1 : 0;
 311                 pingpong = flags & 0x08 ? 1 : 0;
 312
 313                 if (bits == 16) {
 314                         size /= 2;
 315                         loop_start /= 2;
 316                         loop_end /= 2;
 317                 }
 318
 319                 /* skip frequency scale data */
 320                 fget16(f);
 321                 fget16(f);
 322
 323                 /* skip reserved */
 324                 fread(buffer, 36, 1, f);
 325
 326                 if ((w = ss_alloc_wave(size, 1, s_rate, -1)) == NULL)
 327                         break;
 328
 329                 /* set the rest of values */
 330                 w->loop_start = loop_start;
 331                 w->loop_end = loop_end;
 332                 w->base_freq = base_freq;
 333                 w->min_freq = min_freq;
 334                 w->max_freq = max_freq;
 335                 w->bits = bits;
 336                 w->sign = sign;
 337
 338                 /* load the wave */
 339                 ss_prepare_wave(w);
 340                 load_pcm_wave(f, w);
 341
 342                 if (pingpong && loop) {
 343                         int loop_size;
 344                         sample_t *ptr;
 345
 346                         /* if ping-pong, realloc space for a reverse
 347                            version of the loop */
 348                         loop_size = (int) (loop_end - loop_start);
 349
 350                         ptr = (sample_t *) malloc((size + loop_size + 1)
 351                                                   * sizeof(sample_t));
 352
 353                         /* transfer start and loop */
 354                         for (m = 0; m <= (int) loop_end; m++)
 355                                 ptr[m] = w->wave[0][m];
 356
 357                         /* transfer a reversed version of the loop */
 358                         for (o = m - 1; o >= loop_start; o--, m++)
 359                                 ptr[m] = w->wave[0][o];
 360
 361                         /* transfer the end */
 362                         for (o = loop_end + 1; o < size; o++, m++)
 363                                 ptr[m] = w->wave[0][o];
 364
 365                         w->loop_end += (double) loop_size;
 366                         w->size += (double) loop_size;
 367                         w->p_size += loop_size;
 368
 369                         /* free and swap */
 370                         free(w->wave[0]);
 371                         w->wave[0] = ptr;
 372                 }
 373
 374                 if (loop == 0)
 375                         w->loop_start = -1;
 376
 377                 /* finally add layer to instrument */
 378                 ss_ins_add_layer(i, w);
 379         }
 380
 381         fclose(f);
 382         return 0;
 383 }