ss_input.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2006 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)) return(0);
  78
  79         if(bits == 8)
  80         {
  81                 s = fgetc(f) - 128;
  82                 s <<= 8;
  83         }
  84         else
  85         {
  86                 if(!sign)
  87                         s = fget16(f) - 32768;
  88                 else
  89                         s = (short int)fget16(f);
  90         }
  91
  92         return(((sample_t) s) / 32768.0);
  93 }
  94
  95
  96 void load_pcm_wave(FILE * f, struct ss_wave * w)
  97 /* loads an interleaved stream from a file */
  98 {
  99         int n, m;
 100
 101         /* fills the channels */
 102         for(m = 0;m < w->p_size;m++)
 103         {
 104                 for(n = 0;n < w->n_channels;n++)
 105                         w->wave[n][m] = load_sample(f, w->bits, w->sign);
 106         }
 107 }
 108
 109
 110 /**
 111  * ss_load_wav_file - Loads a file in .WAV format.
 112  * @file: name of the file
 113  * @base_freq: base frequency
 114  * @min_freq: minimum frequency
 115  * @max_freq: maximum frequency
 116  * @loop_start: frame number of loop start (-1, no loop)
 117  * @loop_end: frame number of loop end (-1, end of wave)
 118  * @first_channel: first channel to start spreading
 119  * @skip_channels: channels to skip when spreading
 120  *
 121  * Loads a file in .WAV format.
 122  */
 123 struct ss_wave * ss_load_wav_file(char * file,
 124         double base_freq, double min_freq, double max_freq,
 125         double loop_start, double loop_end,
 126         int first_channel, int skip_channels)
 127 {
 128         FILE * f;
 129         char dummydata[256];
 130         int rlen, flen;
 131         short int b_per_sec, n_channels;
 132         char riffid[5], waveid[5], fmtid[5], dataid[5];
 133         double size;
 134         int s_rate, bits;
 135         struct ss_wave * w;
 136         int p;
 137
 138         /* find the file in the library path */
 139         if((file = libpath_locate(file)) == NULL)
 140                 return(NULL);
 141
 142         /* try converting */
 143         if((file = transconv(file, ".wav", "ahxm")) == NULL)
 144                 return(NULL);
 145
 146         if((f = fopen(file, "r")) == NULL)
 147                 return(NULL);
 148
 149         fread(riffid, 1, 4, f);
 150         riffid[4] = 0;
 151         fread(&rlen, 1, 4, f);
 152         fread(waveid, 1, 4, f);
 153         waveid[4] = 0;
 154
 155         if(strcmp(waveid,"WAVE"))
 156         {
 157                 fclose(f);
 158                 return(NULL);
 159         }
 160
 161         fread(fmtid, 1, 4, f);
 162         fmtid[4] = 0;
 163         flen = fget32(f);
 164
 165         if(flen > 240)
 166                 flen = 240;
 167
 168         if(fget16(f) != 1)
 169         {
 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) size /= 2;
 188         size /= (double) n_channels;
 189
 190         p = size > ss_page_size ? ss_page_size : size;
 191
 192         if((w = ss_alloc_wave(size, n_channels, s_rate, p)) != NULL)
 193         {
 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         {
 253                 fclose(f);
 254                 return(-101);
 255         }
 256
 257         fread(buffer, 10, 1, f);
 258         if(strcmp(buffer, "ID#000002") != 0)
 259         {
 260                 fclose(f);
 261                 return(-102);
 262         }
 263
 264         /* skip description */
 265         fread(buffer, 65, 1, f);
 266
 267         /* ignore volume */
 268         fget16(f);
 269
 270         /* skip */
 271         fread(buffer, 109, 1, f);
 272
 273         /* # of layers */
 274         n_layers = fgetc(f);
 275
 276         /* skip */
 277         fread(buffer, 40, 1, f);
 278
 279         for(n = 0;n < n_layers;n++)
 280         {
 281                 int size, s_rate;
 282                 double loop_start, loop_end;
 283                 double min_freq, max_freq, base_freq;
 284
 285                 /* layer name */
 286                 fread(buffer, 8, 1, f);
 287
 288                 size = (double)fget32(f);
 289                 loop_start = (double)fget32(f);
 290                 loop_end = (double)fget32(f);
 291                 s_rate = fget16(f);
 292
 293                 min_freq = ((double)fget32(f)) / 1000.0;
 294                 max_freq = ((double)fget32(f)) / 1000.0;
 295                 base_freq = ((double)fget32(f)) / 1000.0;
 296
 297                 if(base_freq < 0)
 298                         break;
 299
 300                 /* ignore fine-tune */
 301                 fget16(f);
 302
 303                 /* ignore pan position */
 304                 fgetc(f);
 305
 306                 /* skip envelope rate, value, tremolo and vibrato */
 307                 fread(buffer, 18, 1, f);
 308
 309                 flags = fgetc(f);
 310
 311                 bits = flags & 0x01 ? 16 : 8;
 312                 sign = flags & 0x02 ? 0 : 1;
 313                 loop = flags & 0x04 ? 1 : 0;
 314                 pingpong = flags & 0x08 ? 1 : 0;
 315
 316                 if(bits == 16)
 317                 {
 318                         size /= 2;
 319                         loop_start /= 2;
 320                         loop_end /= 2;
 321                 }
 322
 323                 /* skip frequency scale data */
 324                 fget16(f); fget16(f);
 325
 326                 /* skip reserved */
 327                 fread(buffer, 36, 1, f);
 328
 329                 if((w = ss_alloc_wave(size, 1, s_rate, -1)) == NULL)
 330                         break;
 331
 332                 /* set the rest of values */
 333                 w->loop_start = loop_start;
 334                 w->loop_end = loop_end;
 335                 w->base_freq = base_freq;
 336                 w->min_freq = min_freq;
 337                 w->max_freq = max_freq;
 338                 w->bits = bits;
 339                 w->sign = sign;
 340
 341                 /* load the wave */
 342                 ss_prepare_wave(w);
 343                 load_pcm_wave(f, w);
 344
 345                 if(pingpong && loop)
 346                 {
 347                         int loop_size;
 348                         sample_t * ptr;
 349
 350                         /* if ping-pong, realloc space for a reverse
 351                            version of the loop */
 352                         loop_size = (int)(loop_end - loop_start);
 353
 354                         ptr = (sample_t *) malloc((size + loop_size + 1)
 355                                 * sizeof(sample_t));
 356
 357                         /* transfer start and loop */
 358                         for(m = 0;m <= (int)loop_end;m++)
 359                                 ptr[m] = w->wave[0][m];
 360
 361                         /* transfer a reversed version of the loop */
 362                         for(o = m - 1;o >= loop_start;o--, m++)
 363                                 ptr[m] = w->wave[0][o];
 364
 365                         /* transfer the end */
 366                         for(o = loop_end + 1;o < size;o++, m++)
 367                                 ptr[m] = w->wave[0][o];
 368
 369                         w->loop_end += (double) loop_size;
 370                         w->size += (double) loop_size;
 371                         w->p_size += loop_size;
 372
 373                         /* free and swap */
 374                         free(w->wave[0]);
 375                         w->wave[0] = ptr;
 376                 }
 377
 378                 if(loop == 0) w->loop_start = -1;
 379
 380                 /* finally add layer to instrument */
 381                 ss_ins_add_layer(i, w);
 382         }
 383
 384         fclose(f);
 385         return(0);
 386 }