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