Odczyt .wav

FILE  *wavFile;
              wavFile = fopen(FileDialog1->GetPath(), "rb");   
              if( wavFile == NULL )
              {
              
              }
              else
              {



                typedef struct  WAV_HEADER{
    char                RIFF[4];       
    unsigned long       ChunkSize;      
    char                WAVE[4];        
    char                fmt[4];        
    unsigned long       Subchunk1Size; 
    unsigned short      AudioFormat;    
    unsigned short      NumOfChan;      
    unsigned long       SamplesPerSec;  
    unsigned long       BytesPerSec;    
    unsigned short      BlockAlign;    
    unsigned short      BitsPerSample;  
    char                Subchunk2ID[4]; 
    unsigned long       Subchunk2Size;  

                                            }wav_hdr;

                    wav_hdr wavHeader;
                    int headerSize = sizeof(wav_hdr),filelength = 0;
                    fread(&wavHeader,headerSize,1,wavFile);
                    fclose(wavFile);


SAMPLE_RATE = wavHeader.SamplesPerSec;
NUM_CHANNELS = wavHeader.NumOfChan; 

data.frameIndex = 0;
numSamples = ((8 * wavHeader.Subchunk2Size)/wavHeader.BitsPerSample  );
totalFrames = (numSamples / NUM_CHANNELS);
NUM_SECONDS = (totalFrames / SAMPLE_RATE);


fread( data.recordedSamples, wavHeader.Subchunk2Size, totalFrames, wavFile );
                fclose( wavFile );

numBytes = numSamples * sizeof(SAMPLE);
if( data.recordedSamples != nullptr )
                free(data.recordedSamples);
                data.recordedSamples = (SAMPLE *) malloc( numBytes );

ifstream is("d:\\plik.wav", ios_base::binary);

char		sign[4];
uint32_t	chunk_size;

is.read(sign, 4).read((char*)&chunk_size, 4);
if(memcmp(sign, "RIFF", 4) != 0) return -1;
is.read(sign, 4);
if(memcmp(sign, "WAVE", 4) != 0) return -1;

while( is.read(sign, 4).read((char*)&chunk_size, 4) )
{
	if(memcmp(sign, "fmt ", 4) == 0)
	{
		vector<char> fmt(chunk_size, 0);
		is.read(&fmt.front(), chunk_size);

		WAVEFORMATEX *pwf = (WAVEFORMATEX*)&fmt.front();
		if(pwf->wFormatTag != WAVE_FORMAT_PCM && pwf->wFormatTag != 3 /* WAVE_FORMAT_IEEE_FLOAT */)
		{
			/* prawdopodobnie kompresja */
			return -1;
		}

		/* tu czytasz parametry z pwf do swoich zmiennych */

		continue;
	}


	if(memcmp(sign, "data", 4) == 0)
	{
		/* tu czytasz 'chunk_size' bajtów próbek */

		break;
	}

	is.seekg(chunk_size, ios::cur); // resztę bloków pomijamy
}

return is ? 0 : -1;

PaSampleFormat smp_format = 0;
...

if(pwf->wFormatTag == WAVE_FORMAT_PCM)
{
	switch(pwf->wBitsPerSample)
	{
	case 8:  smp_format = paUInt8 ; break;
	case 16: smp_format = paInt16; break;
	case 24: smp_format = paInt24; break;
	case 32: smp_format = paInt32; break;
	};
}	
else smp_format = paFloat32; 

typedef struct {
  WORD  wFormatTag;
  WORD  nChannels;
  DWORD nSamplesPerSec;
  DWORD nAvgBytesPerSec;
  WORD  nBlockAlign;
  WORD  wBitsPerSample;
  WORD  cbSize;
} WAVEFORMATEX;

unsigned short      BlockAlign;
...
BlockAlign = pwf->nBlockAlign;
                numSamples = ((8 * chunk_size)/BitsPerSample  );
                totalFrames = (numSamples / al.NUM_CHANNELS);

    totalFrames = (chunk_size/BlockAlgin);

   numBytes = numSamples * sizeof(SAMPLE);
                if( data.recordedSamples != nullptr )
                free(data.recordedSamples);
                data.recordedSamples = (SAMPLE *) malloc( numBytes );

                fread( data.recordedSamples, al.NUM_CHANNELS * sizeof(SAMPLE), totalFrames, wavFile );
                fclose( wavFile );

char*           Buffer = NULL;
Buffer = new char [chunk_size];
fread( Buffer, chunk_size, totalFrames, wavFile );
fclose( wavFile );
delete[] Buffer;

 numBytes = numSamples * sizeof(SAMPLE);
                if( data.recordedSamples != nullptr )
                free(data.recordedSamples);
                data.recordedSamples = (SAMPLE *) malloc( numBytes );
 
                fread( data.recordedSamples, al.NUM_CHANNELS * sizeof(SAMPLE), totalFrames, wavFile );
                fclose( wavFile );

ifstream is(FileDialog1->GetPath(), ios_base::binary);

char        sign[4];
uint32_t    chunk_size;
unsigned short      BitsPerSample;
unsigned long       SamplesPerSec;
//unsigned short      BlockAlign; //
smp_format = 0;

is.read(sign, 4).read((char*)&chunk_size, 4);
if(memcmp(sign, "RIFF", 4) != 0)
{
    wxString msg = "Nie moge odtworzyć pliku ";
    wxMessageBox(msg, _("Aplikacja"));

}
is.read(sign, 4);
if(memcmp(sign, "WAVE", 4) != 0)
{
    wxString msg = "Nie moge odtworzyć pliku ";
    wxMessageBox(msg, _("Aplikacja"));

}

while( is.read(sign, 4).read((char*)&chunk_size, 4) )
{
    if(memcmp(sign, "fmt ", 4) == 0)
    {
        vector<char> fmt(chunk_size, 0);
        is.read(&fmt.front(), chunk_size);

        WAVEFORMATEX *pwf = (WAVEFORMATEX*)&fmt.front();
        if(pwf->wFormatTag != WAVE_FORMAT_PCM && pwf->wFormatTag != 3 /* WAVE_FORMAT_IEEE_FLOAT */)
        {
            /* prawdopodobnie kompresja */
            wxString msg = "Nie moge odtworzyć pliku ";
            wxMessageBox(msg, _("Aplikacja"));

        }

        /* tu czytasz parametry z pwf do swoich zmiennych */

        if(pwf->wFormatTag == WAVE_FORMAT_PCM)
        {
            switch(pwf->wBitsPerSample)
            {
                case 8:  smp_format = paUInt8 ; break;
                case 16: smp_format = paInt16; break;
                case 24: smp_format = paInt24; break;
                case 32: smp_format = paInt32; break;
            };
        }
            else smp_format = paFloat32;

        al.NUM_CHANNELS = pwf->nChannels ;
        da.SAMPLE_RATE = pwf->nSamplesPerSec;
   //      pwf->nAvgBytesPerSec;
  //     BlockAlign = pwf->nBlockAlign;   //
        SamplesPerSec = pwf->nSamplesPerSec;
        BitsPerSample = pwf->wBitsPerSample;




        continue;
    }


    if(memcmp(sign, "data", 4) == 0)
    {
        /* tu czytasz 'chunk_size' bajtów próbek */

        break;
    }

    is.seekg(chunk_size, ios::cur); // resztę bloków pomijamy
}

                data.frameIndex = 0;
                numSamples = ((8 * chunk_size)/BitsPerSample  );
                totalFrames = (numSamples / al.NUM_CHANNELS);
            //    totalFrames = (chunk_size/BlockAlgin);         //-> 2 mozliwosc
                da.NUM_SECONDS = (totalFrames / da.SAMPLE_RATE);


/// mysle nad tym
                //numBytes = numSamples * sizeof(SAMPLE);
               // if( data.recordedSamples != nullptr )
              //  free(data.recordedSamples);
              
                    
                //    numBytes = chunk_size;
                 //   data.recordedSamples = (SAMPLE *) malloc( numBytes );
                  //    unsigned int    BufferSize = 0;
                       char*           Buffer = NULL;
                      Buffer = new char [chunk_size];
                      char* buffer = new char[chunk_size];
                       fread( Buffer, chunk_size, totalFrames, wavFile );
              //  data.recordedSamples = (SAMPLE *) chunk_size;
               // fread( data.recordedSamples, chunk_size, totalFrames, wavFile );
              //  fread( data.recordedSamples, al.NUM_CHANNELS * sizeof(SAMPLE), totalFrames, wavFile );
                    fclose( wavFile );

if(memcmp(sign, "data", 4) == 0)
{
	delete[] data.recordedSamples;
	data.recordedSamples = new char[chunk_size];
	is.read(data.recordedSamples, chunk_size);
	totalFrames = chunk_size / BlockAlign;
	break;
}

data.recordedSamples = new char[chunk_size];

        delete[] data.recordedSamples;
        data.recordedSamples = (SAMPLE *) chunk_size;
        is.read(data.recordedSamples, chunk_size);
        totalFrames = chunk_size / BlockAlign;
        break;

    data.recordedSamples = (SAMPLE *) chunk_size;

  delete[] data.recordedSamples;

        data.recordedSamples = new SAMPLE[chunk_size];;
        is.read((char *)data.recordedSamples, chunk_size);
        totalFrames = chunk_size / BlockAlign;
       da.NUM_SECONDS = (totalFrames / da.SAMPLE_RATE);
        break;

data.recordedSamples = (SAMPLE*) new char[chunk_size];