Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. unsigned char* load_wav(char *name,int& size,int& rate)
  2. {
  3.         FILE *file;
  4.         unsigned char *wave,*snd;
  5.         int aa,bb,samples,channels;
  6.         int bits,ptr,pd,smp;
  7.         bool fl;
  8.  
  9.         file=fopen(name,"rb");
  10.  
  11.         if(!file)
  12.         {
  13.                 printf("ERR: Can't open sample (%s)\n",name);
  14.                 return NULL;
  15.         }
  16.        
  17.         fseek(file,0,SEEK_END);
  18.         size=ftell(file);
  19.         fseek(file,0,SEEK_SET);
  20.        
  21.         wave=(unsigned char*)malloc(size);
  22.  
  23.         if(!wave)
  24.         {
  25.                 printf("ERR: Can`t allocate memory.\n");
  26.                 return NULL;
  27.         }
  28.  
  29.         fread(wave,size,1,file);
  30.         fclose(file);
  31.        
  32.         fl=false;
  33.  
  34.         for(aa=0;aa<size-4;aa++)
  35.         {
  36.                 if(memcmp(&wave[aa],"RIFF",4)==0)
  37.                 {
  38.                         fl=true;
  39.                         ptr=aa;
  40.                         break;
  41.                 }
  42.         }
  43.  
  44.         if(!fl)
  45.         {
  46.                 printf("ERR: RIFF chunk not found\n");
  47.                 free(wave);
  48.                 return NULL;
  49.         }
  50.  
  51.         fl=false;
  52.  
  53.         for(aa=ptr;aa<size-4;aa++)
  54.         {
  55.                 if(!memcmp(&wave[aa],"WAVEfmt ",8))
  56.                 {
  57.                         fl=true;
  58.                         ptr=aa;
  59.                         break;
  60.                 }
  61.         }
  62.  
  63.         if(!fl)
  64.         {
  65.                 printf("ERR: WAVEfmt chunk not found\n");
  66.                 free(wave);
  67.                 return NULL;
  68.         }
  69.  
  70.         if(read_word(&wave[ptr+12])!=1)
  71.         {
  72.                 printf("ERR: Only unpacked PCM supported (%s)\n",name);
  73.                 free(wave);
  74.                 return NULL;
  75.         }
  76.  
  77.         channels=read_word(&wave[ptr+14]);
  78.         rate=read_dword(&wave[ptr+16]);
  79.         bits=read_word(&wave[ptr+26]);
  80.  
  81.         if(channels<1||channels>2)
  82.         {
  83.                 printf("ERR: Only mono/stereo files supported (%s)\n",name);
  84.                 free(wave);
  85.                 return NULL;
  86.         }
  87.  
  88.         if(bits!=8&&bits!=16)
  89.         {
  90.                 printf("ERR: Only 8/16bit PCM supported (%s)\n",name);
  91.                 free(wave);
  92.                 return NULL;
  93.         }
  94.  
  95.         switch(rate)
  96.         {
  97.         case 8000:  rate=27; break;//7918
  98.         case 11025: rate=18; break;//11075
  99.         case 16000: rate=11; break;//16055
  100.         case 22000:
  101.         case 22050: rate=7;  break;//21604
  102.         case 32000: rate=3;  break;//33018
  103.         case 44100: rate=1;  break;//43750
  104.         default:
  105.                 printf("ERR: Only 44100 Hz or less supported (%s)\n",name);
  106.                 free(wave);
  107.                 return NULL;
  108.         }
  109.  
  110.         fl=false;
  111.  
  112.         for(aa=ptr+28;aa<size-4;aa++)
  113.         {
  114.                 if(!memcmp(&wave[aa],"data",4))
  115.                 {
  116.                         fl=true;
  117.                         ptr=aa;
  118.                         break;
  119.                 }
  120.         }
  121.  
  122.         if(!fl)
  123.         {
  124.                 printf("ERR: DATA chunk not found\n");
  125.                 free(wave);
  126.                 return NULL;
  127.         }
  128.        
  129.         samples=read_dword(&wave[ptr+4])/channels/(bits>>3);
  130.        
  131.         ptr+=8;
  132.        
  133.         snd=(unsigned char*)malloc(samples+1);
  134.        
  135.         pd=0;
  136.  
  137.         for(aa=0;aa<samples;aa++)
  138.         {      
  139.                 smp=0;
  140.  
  141.                 for(bb=0;bb<channels;bb++)
  142.                 {
  143.                         switch(bits)
  144.                         {
  145.                         case 8:
  146.                                 smp+=(signed char)(wave[ptr]+128);
  147.                                 ptr++;
  148.                                 break;
  149.  
  150.                         case 16:
  151.                                 smp+=((signed char)wave[ptr+1]);
  152.                                 ptr+=2;
  153.                                 break;
  154.                         }
  155.                 }
  156.  
  157.                 smp=0x80+smp/channels;
  158.  
  159.                 if(!smp) ++smp;//т ё¤ьяых эх фюыцэю с√Є№ эєыхщ
  160.  
  161.                 snd[pd++]=smp;
  162.         }
  163.        
  164.         snd[pd++]=0;//ъюэхЎ ё¤ьяыр
  165.  
  166.         size=pd;
  167.  
  168.         free(wave);
  169.  
  170.         return snd;
  171. }