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