// i am using this code for compressing wave data from PCM to TRUESPEECH
//it reads 240 bytes of data excluding header and it compresses 240 bytes to 32 bytes and writes it into output file
//here i am reading the header
int inbytes = 0;
if (m_nConversionType)//If WAV file is PCM format header size 58 bytes
  inbytes = fread(msg, 1, 58, i_file);

else///If WAV file is TRUESPEECH format header size 90 bytes
  inbytes = fread(msg, 1, 90, i_file);
//I just read the header to place file pointer after header i didn't use this any where
//srcsize=240
while (1)
{
  memset(header.pbSrc, 0, srcsize);
  memset(header.pbDst, 0, destsize);
  inbytes = fread(header.pbSrc, 1, srcsize, i_file);

    if (inbytes != srcsize)
    {
      if (feof(i_file))
      {
       	AfxMessageBox("EOF");
        break;
      }
      AfxMessageBox(strerror(ferror(i_file)));///here it showes broken pipe error
//It reads 240*16+198 bytes it failed to read remaining data ERROR was "Broken pipe"
      if(ferror(i_file))
      {
	clearerr(i_file);//no use by this statement (error cleared here), but again it failed to read data
      }
      free(header.pbSrc);
      free(header.pbDst);
      free(ts_wf);
      fclose(i_file);
      fclose(o_file))
      return -1;
   }

//compression methods used here to compress data of 240(PCM) to 32(TRUESPEECH)
   if (fwrite(header.pbDst, 1, header.cbDstLengthUsed, o_file) !=
        header.cbDstLengthUsed)
    {
       AfxMessageBox("error writing file\n");
       free(header.pbSrc);
       free(header.pbDst);
       free(ts_wf);
       fclose(i_file);
       fclose(o_file))
	
      return 0;
    }      
  }

// this problem get solved by closing the file and again called same on that file
//But i need it to work on first time.. will you help me

/* 
 * readwave.c
 * Use file formats from wavefmt.h to access PCM .wav file parameters
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "wavefmt.h"

void getinput(FILE *);

int main(int argc, char **argv)
{
    FILE *infile;

    uint32_t number_of_samples;
    int i;
    int fileno;

    ChunkDescriptorHdr   c_hdr;
    FormatSubChunkHdr    f_hdr;
    DataSubChunkHdr      d_hdr;
    
    printf("Size of Chunk  Descriptor Header = %2d\n", sizeof(c_hdr));
    printf("Size of Format SubChunk   Header = %2d\n", sizeof(f_hdr));
    printf("Size of Data   SubChunk   Header = %2d\n", sizeof(d_hdr));
    if ((sizeof(c_hdr) + sizeof(f_hdr) + sizeof(d_hdr)) != 44) {
        printf("Header sizes must add up to 44. Otherwise it can't work.\n");
        exit(EXIT_FAILURE);
    }
    printf("Number of bytes before samples   = %2d\n\n", 
            sizeof(c_hdr)+sizeof(f_hdr)+sizeof(d_hdr));
    if (argc < 2) {
        printf("Usage: %s <wavefilename>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    for (fileno = 1; fileno < argc; fileno++) {
        if ((infile = fopen(argv[fileno], "rb")) == NULL) {
            printf("Can't open file %s for reading\n", argv[fileno]);
            exit(EXIT_FAILURE);
        }
        printf("Opened %s for reading\n", argv[fileno]);

        /*  Read and analyze Chunk Descriptor Header */
        if (fread(&c_hdr, sizeof(c_hdr), 1, infile) != 1) {
            printf("  Error reading Chunk Descriptor Header\n");
            exit(EXIT_FAILURE);
        }
        printf("  ID   from Chunk Descriptor Header:  <");
        for (i = 0; i < 4; i++) {
            if (isprint(c_hdr.ID[i])) {
                printf("%c", c_hdr.ID[i]);
            }
            else {
                printf(" 0x%02x ", c_hdr.ID[i]);
            }

        }
        printf(">\n");

        if (strncmp(c_hdr.ID, "RIFF", 4) != 0) {
            printf("  ID is not <RIFF>\n");
            exit(EXIT_FAILURE);
        }
        printf("  Size from Chunk Descriptor Header = %d\n\n", c_hdr.Size);

        if (strncmp(c_hdr.Format, "WAVE", 4) != 0) {
            printf("  Format is not <WAVE>\n");
            exit(EXIT_FAILURE);
        }

        /* Read and analyze FormatSubChunkHdr */
        fread(&f_hdr, sizeof(f_hdr), 1, infile);
        printf("  ID from Format SubChunk Headr:      <");
        for (i = 0; i < 4; i++) {

            if (isprint(f_hdr.ID[i])) {
                printf("%c", f_hdr.ID[i]);
            }
            else {
                printf(" 0x%02x ", f_hdr.ID[i]);
            }
        }
        printf(">\n");
        if (strncmp(f_hdr.ID, "fmt ", 4) != 0) {
            printf("  ID is not <fmt >\n");
            exit(EXIT_FAILURE);
        }

        printf("  Size = %d\n", f_hdr.Size);
        if (f_hdr.Size != 16) {
            printf("  Size is not 16\n");
            exit(EXIT_FAILURE);
        }
        printf("  Audio Format        = %u\n", f_hdr.AudioFormat);
        if (f_hdr.AudioFormat != 1) {
            printf("  AudioFormat must be 1\n");
            exit(EXIT_FAILURE);
        }

        printf("  Number of channels  = %u\n", f_hdr.NumChannels);
        printf("  Sample rate         = %u\n", f_hdr.SampleRate);
        printf("  Byte rate           = %u\n", f_hdr.ByteRate);
        printf("  Block Align         = %u\n", f_hdr.BlockAlign);
        printf("  Bits per sample     = %u\n", f_hdr.BitsPerSample);
        printf("\n");

    /* check channel number and block size are good */
        if (f_hdr.NumChannels > 4 || f_hdr.BlockAlign > 8) {
            if (f_hdr.NumChannels > 4) {
                printf("  Number of channels must be less than or equal to 4\n");
            }
            if (f_hdr.BlockAlign > 8) {
                printf("  Block align must be less than or equal to 8\n");
            }
            exit(EXIT_FAILURE);
        }

        fread(&d_hdr, sizeof(d_hdr), 1, infile);
        printf("  ID from Data Subchunk Header:       <");
        for (i = 0; i < 4; i++) {
            if (isprint(d_hdr.ID[i])) {
                printf("%c", d_hdr.ID[i]);
            }
            else {
                printf(" 0x%02x ", d_hdr.ID[i]);
            }
        }
        printf(">\n");
        printf("  Data Size           = %d\n", d_hdr.Size);

        number_of_samples = d_hdr.Size / f_hdr.BlockAlign;
        printf("  Samples per Channel = %u\n\n", number_of_samples);
        printf("  Now the file pointer is ready to read the data.\n");
        /* Here's where you process the samples */
        fclose(infile);
        printf("  Closed %s\n", argv[fileno]);
        printf("\n\n");
    }
    printf("\n");
    printf("Number of files processed = %d\n", fileno-1);

    return 0;
}

#ifndef WAVEFMT_H__
#define WAVEFMT_H__
/* typedefs for PCM .wav file headers */
/* 
 * Ref: [url]http://msdn2.microsoft.com/en-us/library/aa446573.aspx[/url]
 * Ref: [url]http://ccrma.stanford.edu/courses/422/projects/WaveFormat/[/url]
 *
 * All PCM .wav files have the following three headers
 *
 * There may be additional Data Subchunks.
 * If so, then each has its own DataSubChunkHdr.
 *
 * For RIFF .wav files, multi-byte integer data are stored in
 * little-endian format. (So if your architecture is little-endian
 * everything falls into place by reading the headers a block
 * at a time.)
 *
 * Data samples are always supposed to fall on even-byte boundaries.
 *
 */

#ifdef __GNUC__
#include <stdint.h>
#else
typedef unsigned int uint32_t;
typedef int int32_t;
typedef short int16_t;
typedef unsigned short uint16_t;
#endif

/* Waveform Chunk descriptor size is 12 */
typedef struct {
    char     ID[4];         /* 'R', 'I', 'F', 'F'                         */
    int32_t  Size;          /* file size - 8                              */
    char     Format[4];     /* 'W', A', V', E'                            */
} ChunkDescriptorHdr;

/* PCM Format SubChunk header size is 24 */
typedef struct {
    char     ID[4];         /* 'f', 'm', 't', ' '                         */
    int32_t Size;           /* 16 for PCM                                 */
    uint16_t AudioFormat;   /* 1 for PCM                                  */
    uint16_t NumChannels;   /* mono = 1; stereo = 2                       */
    uint32_t SampleRate;    /* 8000, 41000, etc.                          */
    uint32_t ByteRate;      /* SampleRate * NumChannels *BitsPerSample/8  */
    uint16_t BlockAlign;    /* NumChannels * BitsPerSample/8              */
    uint16_t BitsPerSample; /* 8, 16, etc.                                */
} FormatSubChunkHdr;

/* Data SubChunk header size is 8 (not counting the actual data bytes)    */
typedef struct {
    char     ID[4];         /* 'd', 'a', 't', 'a'    */
    int32_t Size;           /* NumSamples * NumChannels * BitsPerSample/8 */
    /* The data samples follow */
} DataSubChunkHdr;


/* flags for AudioFormat field of FormatSubChunkHdr */
#define WAVE_FORMAT_PCM     1

#endif