input.c

   1 /*
   2
   3     PROGRAM_NAME PROGRAM_VERSION - PROGRAM_DESCRIPTION
   4
   5     Copyright (C) 2003 Angel Ortega <angel@triptico.com>
   6
   7     This program is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU General Public License
   9     as published by the Free Software Foundation; either version 2
  10     of the License, or (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21     http://www.triptico.com
  22
  23 */
  24
  25 #include "config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #include "input.h"
  31
  32 /*******************
  33         Data
  34 ********************/
  35
  36 extern int _frequency;
  37
  38
  39 /*******************
  40         Code
  41 ********************/
  42
  43 int fget16(FILE * f)
  44 {
  45         int c;
  46
  47         c=fgetc(f);
  48         c+=(fgetc(f) * 256);
  49
  50         return(c);
  51 }
  52
  53
  54 int fget32(FILE * f)
  55 {
  56         int c;
  57
  58         c=fgetc(f);
  59         c+=(fgetc(f) * 256);
  60         c+=(fgetc(f) * 65536);
  61         c+=(fgetc(f) * 16777216);
  62
  63         return(c);
  64 }
  65
  66
  67 int load_sample(FILE * f, int bits, int sign)
  68 {
  69         int s;
  70
  71         if(bits==8)
  72         {
  73                 s=fgetc(f)-128;
  74                 s<<=8;
  75         }
  76         else
  77         {
  78 /*              s=fgetc(f);
  79                 s|=(((unsigned char)fgetc(f)) << 8);*/
  80
  81                 s=(short int)fget16(f);
  82
  83                 if(!sign) s-=32768;
  84         }
  85
  86         return(s);
  87 }
  88
  89
  90 void load_pcm_wave(FILE * f, int * size, int bits, int channels,
  91         int sign, int frequency, int ** lwave, int ** rwave)
  92 {
  93         int n;
  94         int * ls;
  95         int * rs;
  96
  97         ls=(int *)malloc(*size * sizeof(int));
  98
  99         if(channels==2)
 100                 rs=(int *)malloc(*size * sizeof(int));
 101         else
 102                 rs=ls;
 103
 104         for(n=0;n < *size;n++)
 105         {
 106                 ls[n]=load_sample(f, bits, sign);
 107
 108                 if(channels==2)
 109                         rs[n]=load_sample(f, bits, sign);
 110         }
 111
 112         /* resample if needed */
 113         if(frequency != _frequency)
 114         {
 115                 n=*size;
 116
 117                 ls=wave_resample(ls, frequency, size);
 118
 119                 if(channels==2)
 120                         rs=wave_resample(rs, frequency, &n);
 121                 else
 122                         rs=ls;
 123         }
 124
 125         *lwave=ls;
 126         *rwave=rs;
 127 }
 128
 129
 130 int * wave_resample(int * wave, int freq, int * size)
 131 {
 132         double ratio;
 133         int new_size;
 134         int * new_wave;
 135         int n;
 136         double i;
 137
 138         ratio=(double) freq / (double) _frequency;
 139         new_size=(int)((double) (*size) / ratio);
 140
 141         new_wave=(int *)malloc(new_size * sizeof(int));
 142
 143         printf("wave_resample: ratio %f\n", (float)ratio);
 144
 145         for(n=i=0;n < new_size;n++,i+=ratio)
 146                 new_wave[n]=wave[(int)i];
 147
 148         *size=new_size;
 149
 150         /* free the old wave */
 151         free(wave);
 152
 153         return(new_wave);
 154 }
 155
 156
 157 int load_wav_file(char * filename, int * size, int ** lwave, int ** rwave)
 158 {
 159         FILE * f;
 160         char dummydata[256];
 161         int rlen,flen;
 162         short int b_per_sec,num_channels,tag;
 163         char riffid[5],waveid[5],fmtid[5],dataid[5];
 164         int wav_frequency, wav_bits;
 165         int * ls;
 166         int * rs;
 167
 168         if((f=fopen(filename,"r"))==NULL)
 169                 return(0);
 170
 171         fread(riffid,1,4,f);
 172         riffid[4] = 0;
 173         fread(&rlen,1,4,f);
 174         fread(waveid,1,4,f);
 175         waveid[4] = 0;
 176
 177         if(strcmp(waveid,"WAVE"))
 178         {
 179                 fclose(f);
 180                 return(0);
 181         }
 182
 183         fread(fmtid,1,4,f);
 184         fmtid[4] = 0;
 185         flen=fget32(f);
 186
 187         if(flen>240)
 188                 flen=240;
 189
 190         fread(&tag,1,2,f);
 191
 192         num_channels=fget16(f);
 193         wav_frequency=fget32(f);
 194         b_per_sec=fget32(f);
 195
 196         wav_bits=fget16(f) / num_channels;
 197         wav_bits*=8;
 198
 199         fread(dummydata,1,(size_t)flen-14,f);
 200         fread(dataid,1,4,f);
 201         dataid[4] = 0;
 202
 203         *size=fget32(f);
 204         if(wav_bits==16) (*size)/=2;
 205         if(num_channels==2) (*size)/=2;
 206
 207         load_pcm_wave(f, size, wav_bits, num_channels,
 208                 1, wav_frequency, &ls, &rs);
 209
 210         fclose(f);
 211
 212         *lwave=ls;
 213         *rwave=rs;
 214
 215         return(1);
 216 }
 217
 218
 219 /* table of frequencies for each note */
 220
 221 static int _pat_freq_table[128]=
 222 {
 223         8176, 8662, 9177, 9723,
 224         10301, 10913, 11562, 12250,
 225         12978, 13750, 14568, 15434,
 226
 227         16352, 17324, 18354, 19445,
 228         20602, 21827, 23125, 24500,
 229         25957, 27500, 29135, 30868,
 230
 231         32703, 34648, 36708, 38891,
 232         41203, 43654, 46249, 48999,
 233         51913, 55000, 58270, 61735,
 234
 235         65406, 69296, 73416, 77782,
 236         82407, 87307, 92499, 97999,
 237         103826, 110000, 116541, 123471,
 238
 239         130813, 138591, 146832, 155563,
 240         164814, 174614, 184997, 195998,
 241         207652, 220000, 233082, 246942,
 242
 243         261626, 277183, 293665, 311127,
 244         329628, 349228, 369994, 391995,
 245         415305, 440000, 466164, 493883,
 246
 247         523251, 554365, 587330, 622254,
 248         659255, 698456, 739989, 783991,
 249         830609, 880000, 932328, 987767,
 250
 251         1046502, 1108731, 1174659, 1244508,
 252         1318510, 1396913, 1479978, 1567982,
 253         1661219, 1760000, 1864655, 1975533,
 254
 255         2093005, 2217461, 2349318, 2489016,
 256         2637020, 2793826, 2959955, 3135963,
 257         3322438, 3520000, 3729310, 3951066,
 258
 259         4186009, 4434922, 4698636, 4978032,
 260         5274041, 5587652, 5919911, 6271927,
 261         6644875, 7040000, 7458620, 7902133,
 262
 263         8372018, 8869844, 9397273, 9956063,
 264         10548082, 11175303, 11839822, 12543854
 265 };
 266
 267
 268 static int _pat_find_note(int frequency)
 269 {
 270         int n;
 271
 272         for(n=0;n < 128;n++)
 273         {
 274                 if(_pat_freq_table[n] >= frequency)
 275                         return(n);
 276         }
 277
 278         return(-1);
 279 }
 280
 281
 282 int load_pat_file(char * filename)
 283 {
 284         FILE * f;
 285         char buffer[512];
 286         int i, n;
 287         int n_layers;
 288         int size, loop_start, loop_end;
 289         int base_note, min_note, max_note;
 290         int frequency, flags, bits, sign, loop;
 291         int * lwave;
 292         int * rwave;
 293
 294         if((f=fopen(filename,"r"))==NULL)
 295                 return(0);
 296
 297         /* read signatures */
 298         fread(buffer, 12, 1, f);
 299         if(strcmp(buffer, "GF1PATCH110")!=0)
 300         {
 301                 fclose(f);
 302                 return(0);
 303         }
 304
 305         fread(buffer, 10, 1, f);
 306         if(strcmp(buffer, "ID#000002")!=0)
 307         {
 308                 fclose(f);
 309                 return(0);
 310         }
 311
 312         /* skip description */
 313         fread(buffer, 65, 1, f);
 314
 315         /* volume */
 316         i=fget16(f);
 317         printf("vol: %d\n", i);
 318
 319         /* skip */
 320         fread(buffer, 109, 1, f);
 321
 322         /* # of layers */
 323         n_layers=fgetc(f);
 324         printf("layers: %d\n", n_layers);
 325
 326         /* skip */
 327         fread(buffer, 40, 1, f);
 328
 329         for(n=0;n < n_layers;n++)
 330         {
 331                 /* layer name */
 332                 fread(buffer, 8, 1, f);
 333                 printf("name: '%s'\n", buffer);
 334
 335                 size=fget32(f);
 336                 loop_start=fget32(f);
 337                 loop_end=fget32(f);
 338                 frequency=fget16(f);
 339
 340                 printf("size: %d [%d-%d], freq: %d\n",
 341                         size, loop_start, loop_end, frequency);
 342
 343                 min_note=fget32(f);
 344                 max_note=fget32(f);
 345                 base_note=fget32(f);
 346
 347                 printf("freqs: %d - %d - %d\n",
 348                         min_note, base_note, max_note);
 349                 printf("notes: %d - %d - %d\n",
 350                         _pat_find_note(min_note),
 351                         _pat_find_note(base_note),
 352                         _pat_find_note(max_note));
 353
 354                 /* ignore fine-tune */
 355                 fget16(f);
 356
 357                 /* pan position */
 358                 i=fgetc(f);
 359                 printf("pan: %d\n", i);
 360
 361                 /* skip envelope rate, value, tremolo and vibrato */
 362                 fread(buffer, 18, 1, f);
 363
 364                 flags=fgetc(f);
 365                 printf("flags: 0x%02X\n", flags);
 366
 367                 bits=flags & 0x01 ? 16 : 8;
 368                 sign=flags & 0x02 ? 0 : 1;
 369                 loop=flags & 0x04 ? 1 : 0;
 370
 371                 if(flags & 8) printf("PINGPONG!!!\n");
 372
 373                 printf("bits: %d, sign: %d, loop: %d\n",
 374                         bits, sign, loop);
 375
 376                 if(bits == 16)
 377                 {
 378                         size /= 2;
 379                         loop_start /= 2;
 380                         loop_end /= 2;
 381                 }
 382
 383                 /* skip frequency scale data */
 384                 fget16(f); fget16(f);
 385
 386                 /* skip reserved */
 387                 fread(buffer, 36, 1, f);
 388
 389                 /* load the wave */
 390                 load_pcm_wave(f, &size, bits, 1, sign,
 391                         frequency, &lwave, &rwave);
 392
 393                 if(n==0)
 394                 {
 395                         FILE * q;
 396                         q=fopen("qq.raw", "w");
 397                         fwrite(lwave, sizeof(int), size, q);
 398                         fclose(q);
 399                 }
 400         }
 401
 402         fclose(f);
 403         return(1);
 404 }