• C/C++
• Windows 32 API
• File Streams (File I/O)

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

Members:

	wFormatTag

		Waveform-audio format type. Format tags are registered with Microsoft Corporation for many compression
		algorithms. A complete list of format tags can be found in the MMREG.H header file.

	nChannels

		Number of channels in the waveform-audio data. Monaural data uses one channel and stereo data uses two
		channels.

	nSamplesPerSec

		Sample rate, in samples per second (hertz), that each channel should be played or recorded. If wFormatTag is
		WAVE_FORMAT_PCM, then common values for nSamplesPerSec are 8.0 kHz, 11.025 kHz, 22.05 kHz, and 44.1 kHz. For
		non-PCM formats, this member must be computed according to the manufacturer's specification of the format
		tag.

	nAvgBytesPerSec

		Required average data-transfer rate, in bytes per second, for the format tag. If wFormatTag is
		WAVE_FORMAT_PCM, nAvgBytesPerSec should be equal to the product of nSamplesPerSec and nBlockAlign. For
		non-PCM formats, this member must be computed according to the manufacturer's specification of the format
		tag.
		Playback and record software can estimate buffer sizes by using the nAvgBytesPerSec member.

	nBlockAlign

		Block alignment, in bytes. The block alignment is the minimum atomic unit of data for the wFormatTag format
		type. If wFormatTag is WAVE_FORMAT_PCM, nBlockAlign should be equal to the product of nChannels and
		wBitsPerSample divided by 8 (bits per byte). For non-PCM formats, this member must be computed according to
		the manufacturer's specification of the format tag.
		Playback and record software must process a multiple of nBlockAlign bytes of data at a time. Data written
		and read from a device must always start at the beginning of a block. For example, it is illegal to start
		playback of PCM data in the middle of a sample (that is, on a non-block-aligned boundary).

	wBitsPerSample

		Bits per sample for the wFormatTag format type. If wFormatTag is WAVE_FORMAT_PCM, then wBitsPerSample should
		be equal to 8 or 16. For non-PCM formats, this member must be set according to the manufacturer's
		specification of the format tag. Note that some compression schemes cannot define a value for
		wBitsPerSample, so this member can be zero.

	cbSize

		Size, in bytes, of extra format information appended to the end of the WAVEFORMATEX structure. This
		information can be used by non-PCM formats to store extra attributes for the wFormatTag. If no extra
		information is required by the wFormatTag, this member must be set to zero. Note that for WAVE_FORMAT_PCM
		formats (and only WAVE_FORMAT_PCM formats), this member is ignored.

#include <mmreg.h>
#include<string>
#include<fstream>

/*--------------------------------------------------------------------------------**
** This function takes in a filename, a pointer to a WAVEFORMATEX structure that  **
** will be set, and a char* databuf, which will be allocated and filled with the  **
** PCM data in the file filename.                                                 **
**                                                                                **
** On error it will throw a string with a proper error announcement               **
**--------------------------------------------------------------------------------*/

void OpenWaveFile (const std::string &filename, WAVEFORMATEX *pwfx, char* databuf){

    std::ifstream file;
    char csID[4];
    long fsize;
    long wfxsize;
    long datasize;

    file.open (filename.c_str (), std::ios_base::binary);
    if (file == NULL){
        std::string s ("Unable to open file ");
        s += filename;
        throw s;
    }

    file.read (csID, 4);
    if (std::string (csID) != "RIFF"){
        std::string s (" does not have a valid RIFF ID.");
        s = filename + s;
        throw s;
    }

    file.read ((char*)&fsize, 4);
    file.read (csID, 4);
    if (std::string (csID) != "WAVE"){
        std::string s (" is not a valid WAVE form-type.");
        s = filename + s;
        throw s;
    }

    file.read (csID, 4);
    if (std::string (csID) != "fmt "){
        std::string s (" does not have a valid wave-form chunk ID.");
        s = filename + s;
        throw s;
    }

    file.read ((char*)&wfxsize, 4);
    file.read ((char*)pwfx, wfxsize);
    if (wfm ().wFormatTag != WAVE_FORMAT_PCM){
        std::string s (" is not of type PCM wave format.");
        s = filename + s;
        throw s;
    }

    file.read (csID, 4);
    if (std::string (csID) != "data"){
        std::string s (" does not have a valid data chunk ID.");
        s = filename + s;
        throw s;
    }

    file.read ((char*)&datasize, 4);
    databuf = new char [datasize];
    file.read (databuf, datasize);
}

• Waveform Audio is in RIFF.
• There are 3 "chunks" in a waveform audio file. The three "chunks" are the "RIFF", "fmt ", and "data" sections
• The WaveFormat structure contains all the PCM format information.
• The "data" section contains all the PCM data.