ss_input.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2005 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 "annhell.h"
  33
  34 /*******************
  35         Data
  36 ********************/
  37
  38 /*******************
  39         Code
  40 ********************/
  41
  42 static int fget16(FILE * f)
  43 /* Reads a 16 bit integer from a file in big endian byte ordering */
  44 {
  45         int c;
  46
  47         c=fgetc(f);
  48         c += (fgetc(f) * 256);
  49
  50         return(c);
  51 }
  52
  53
  54 static int fget32(FILE * f)
  55 /* Reads a 32 bit integer from a file in big endian byte ordering */
  56 {
  57         int c;
  58
  59         c=fgetc(f);
  60         c += (fgetc(f) * 256);
  61         c += (fgetc(f) * 65536);
  62         c += (fgetc(f) * 16777216);
  63
  64         return(c);
  65 }
  66
  67
  68 static float load_sample(FILE * f, int bits, int sign)
  69 /* loads one sample from a file */
  70 {
  71         int s;
  72
  73         /* Caution: no error condition is checked */
  74
  75         if(bits == 8)
  76         {
  77                 s=fgetc(f) - 128;
  78                 s <<= 8;
  79         }
  80         else
  81         {
  82                 if(!sign)
  83                         s=fget16(f) - 32768;
  84                 else
  85                         s=(short int)fget16(f);
  86         }
  87
  88         return((float) s);
  89 }
  90
  91
  92 static void load_pcm_wave(FILE * f, int bits, int sign, struct ss_wave * w)
  93 /* loads an interleaved stream from a file */
  94 {
  95         int n, i;
  96         double m;
  97
  98         /* fills the channels */
  99         for(m=0;m < w->size;m++)
 100         {
 101                 i=(int) m;
 102
 103                 for(n=0;n < w->n_channels;n++)
 104                         w->wave[n][i]=load_sample(f, bits, sign);
 105         }
 106 }
 107
 108
 109 /**
 110  * ss_load_wav_file - Loads a file in .WAV format.
 111  * @file: name of the file
 112  * @base_freq: base frequency
 113  * @min_freq: minimum frequency
 114  * @max_freq: maximum frequency
 115  * @loop_start: frame number of loop start (-1, no loop)
 116  * @loop_end: frame number of loop end (-1, end of wave)
 117  *
 118  * Loads a file in .WAV format.
 119  */
 120 struct ss_wave * ss_load_wav_file(char * file,
 121         double base_freq, double min_freq, double max_freq,
 122         double loop_start, double loop_end)
 123 {
 124         FILE * f;
 125         char dummydata[256];
 126         int rlen, flen;
 127         short int b_per_sec, n_channels;
 128         char riffid[5], waveid[5], fmtid[5], dataid[5];
 129         double size;
 130         int s_rate, bits;
 131         struct ss_wave * w;
 132
 133         if((f=fopen(file, "r")) == NULL)
 134                 return(NULL);
 135
 136         fread(riffid, 1, 4, f);
 137         riffid[4] = 0;
 138         fread(&rlen, 1, 4, f);
 139         fread(waveid, 1, 4, f);
 140         waveid[4] = 0;
 141
 142         if(strcmp(waveid,"WAVE"))
 143         {
 144                 fclose(f);
 145                 return(NULL);
 146         }
 147
 148         fread(fmtid, 1, 4, f);
 149         fmtid[4] = 0;
 150         flen=fget32(f);
 151
 152         if(flen > 240)
 153                 flen=240;
 154
 155         if(fget16(f) != 1)
 156         {
 157                 /* wicked compressed format? fail */
 158                 fclose(f);
 159                 return(NULL);
 160         }
 161
 162         n_channels=fget16(f);
 163         s_rate=fget32(f);
 164         b_per_sec=fget32(f);
 165
 166         bits=fget16(f) / n_channels;
 167         bits *= 8;
 168
 169         fread(dummydata, 1, (size_t)flen - 14, f);
 170         fread(dataid, 1, 4, f);
 171         dataid[4] = 0;
 172
 173         size=(double) fget32(f);
 174         if(bits == 16) size /= 2;
 175         size /= (double) n_channels;
 176
 177         if((w=ss_alloc_wave(size, n_channels, s_rate)) != NULL)
 178         {
 179                 w->base_freq=base_freq;
 180                 w->min_freq=min_freq;
 181                 w->max_freq=max_freq;
 182
 183                 w->loop_start=loop_start;
 184
 185                 if(loop_end < 0)
 186                         w->loop_end=size;
 187                 else
 188                         w->loop_end=loop_end;
 189
 190                 load_pcm_wave(f, bits, 1, w);
 191         }
 192
 193         fclose(f);
 194
 195         return(w);
 196 }
 197
 198
 199 /**
 200  * ss_load_pat_file - Loads an instrument in .PAT format.
 201  * @i: The instrument
 202  * @filename: filename holding the instrument
 203  *
 204  * Loads data from a Gravis Ultrasound patch (.PAT) format and
 205  * stores it as layers for an instrument.
 206  *
 207  * Returns -100 if the file could not be read, -101 or -102
 208  * if the file is not recognized as a .PAT file, or 0 if
 209  * everything went OK.
 210  */
 211 int ss_load_pat_file(struct ss_ins * i, char * file)
 212 {
 213         FILE * f;
 214         char buffer[512];
 215         int m, n, o;
 216         int n_layers;
 217         int flags, bits, sign, loop, pingpong;
 218         struct ss_wave * w;
 219
 220         if((f=fopen(file, "r")) == NULL)
 221                 return(-100);
 222
 223         /* read signatures */
 224         fread(buffer, 12, 1, f);
 225         if(strcmp(buffer, "GF1PATCH110") != 0)
 226         {
 227                 fclose(f);
 228                 return(-101);
 229         }
 230
 231         fread(buffer, 10, 1, f);
 232         if(strcmp(buffer, "ID#000002") != 0)
 233         {
 234                 fclose(f);
 235                 return(-102);
 236         }
 237
 238         /* skip description */
 239         fread(buffer, 65, 1, f);
 240
 241         /* ignore volume */
 242         fget16(f);
 243
 244         /* skip */
 245         fread(buffer, 109, 1, f);
 246
 247         /* # of layers */
 248         n_layers=fgetc(f);
 249
 250         /* skip */
 251         fread(buffer, 40, 1, f);
 252
 253         for(n=0;n < n_layers;n++)
 254         {
 255                 int size, s_rate;
 256                 double loop_start, loop_end;
 257                 double min_freq, max_freq, base_freq;
 258
 259                 /* layer name */
 260                 fread(buffer, 8, 1, f);
 261                 printf("name: '%s'\n", buffer);
 262
 263                 size=(double)fget32(f);
 264                 loop_start=(double)fget32(f);
 265                 loop_end=(double)fget32(f);
 266                 s_rate=fget16(f);
 267
 268                 printf("size: %d [%d-%d], s_rate: %d\n",
 269                         size, (int)loop_start, (int)loop_end, s_rate);
 270
 271                 min_freq=((double)fget32(f)) / 1000.0;
 272                 max_freq=((double)fget32(f)) / 1000.0;
 273                 base_freq=((double)fget32(f)) / 1000.0;
 274
 275                 printf("note_freqs: %lf - %lf - %lf\n",
 276                         min_freq, base_freq, max_freq);
 277
 278                 if(base_freq < 0)
 279                         break;
 280
 281                 /* ignore fine-tune */
 282                 fget16(f);
 283
 284                 /* ignore pan position */
 285                 fgetc(f);
 286
 287                 /* skip envelope rate, value, tremolo and vibrato */
 288                 fread(buffer, 18, 1, f);
 289
 290                 flags=fgetc(f);
 291                 printf("flags: 0x%02X\n", flags);
 292
 293                 bits=flags & 0x01 ? 16 : 8;
 294                 sign=flags & 0x02 ? 0 : 1;
 295                 loop=flags & 0x04 ? 1 : 0;
 296                 pingpong=flags & 0x08 ? 1 : 0;
 297
 298                 printf("bits: %d, sign: %d, loop: %d pingpong: %d\n",
 299                         bits, sign, loop, pingpong);
 300
 301                 if(bits == 16)
 302                 {
 303                         size /= 2;
 304                         loop_start /= 2;
 305                         loop_end /= 2;
 306                 }
 307
 308                 /* skip frequency scale data */
 309                 fget16(f); fget16(f);
 310
 311                 /* skip reserved */
 312                 fread(buffer, 36, 1, f);
 313
 314                 if((w=ss_alloc_wave(size, 1, s_rate)) == NULL)
 315                         break;
 316
 317                 /* set the rest of values */
 318                 w->loop_start=loop_start;
 319                 w->loop_end=loop_end;
 320                 w->base_freq=base_freq;
 321                 w->min_freq=min_freq;
 322                 w->max_freq=max_freq;
 323
 324                 /* load the wave */
 325                 load_pcm_wave(f, bits, sign, w);
 326
 327                 if(pingpong && loop)
 328                 {
 329                         int loop_size;
 330                         float * ptr;
 331
 332                         /* if ping-pong, realloc space for a reverse
 333                            version of the loop */
 334                         loop_size=(int)(loop_end - loop_start);
 335
 336                         ptr=(float *) malloc((size + loop_size + 1)
 337                                 * sizeof(float));
 338
 339                         /* transfer start and loop */
 340                         for(m=0;m <= (int)loop_end;m++)
 341                                 ptr[m]=w->wave[0][m];
 342
 343                         /* transfer a reversed version of the loop */
 344                         for(o=m - 1;o >= loop_start;o--,m++)
 345                                 ptr[m]=w->wave[0][o];
 346
 347                         /* transfer the end */
 348                         for(o=loop_end + 1;o < size;o++,m++)
 349                                 ptr[m]=w->wave[0][o];
 350
 351                         w->loop_end += (double) loop_size;
 352                         w->size += (double) loop_size;
 353
 354                         /* free and swap */
 355                         free(w->wave[0]);
 356                         w->wave[0]=ptr;
 357                 }
 358
 359                 if(loop == 0) w->loop_start=-1;
 360
 361                 /* finally add layer to instrument */
 362                 ss_ins_add_layer(i, w);
 363         }
 364
 365         fclose(f);
 366         return(0);
 367 }