#ifndef _SAMPLE_WAVEFORMATEX_HPP_
#define _SAMPLE_WAVEFORMATEX_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_MMSYSTEM_HPP_
#include <common/mmsystem.hpp>
#endif
#ifndef _COMMON_MMREG_HPP_
#include <common/mmreg.hpp>
#endif
#ifndef _SAMPLE_FORMATCHUNK_HPP_
#include <sample/fmtchnk.hpp>
#endif

class WaveFormatEx : private WAVEFORMATEX
{
public:
	enum FormatType{PulseCodeModulation=WAVE_FORMAT_PCM,AdPulseCodeModulation=WAVE_FORMAT_ADPCM};
	WaveFormatEx(void);
	WaveFormatEx(const WaveFormatEx &someWaveFormatEx);
	WaveFormatEx(const FormatChunk &someFormatChunk);
	~WaveFormatEx();
	WaveFormatEx &operator=(const WaveFormatEx &someWaveFormatEx);
	WaveFormatEx &operator=(const FormatChunk &someFormatChunk);
	WORD formatTag(void)const;
	void formatTag(WORD formatTag);
	WORD channels(void)const;
	void channels(WORD channels);
	DWORD samplePerSecond(void)const;
	void samplesPerSecond(DWORD samplesPerSecond);
	DWORD averageBytesPerSecond(void)const;
	void averageBytesPerSecond(DWORD averageBytesPerSecond);
	WORD blockAlign(void)const;
	void blockAlign(WORD blockAlign);
	WORD bitsPerSample(void)const;
	void bitsPerSample(WORD bitsPerSample);
	WORD size(void)const;
  void size(WORD size);
  operator WAVEFORMATEX &(void)const;
private:
};

inline
WaveFormatEx::WaveFormatEx(void)
{
	::memset(this,0,sizeof(*this));
}

inline
WaveFormatEx::WaveFormatEx(const WaveFormatEx &someWaveFormatEx)
{
	*this=someWaveFormatEx;
}

inline
WaveFormatEx::WaveFormatEx(const FormatChunk &someFormatChunk)
{
	*this=someFormatChunk;
}

inline
WaveFormatEx::~WaveFormatEx()
{
}

inline
WaveFormatEx &WaveFormatEx::operator=(const WaveFormatEx &someWaveFormatEx)
{
	::memcpy(this,&someWaveFormatEx,sizeof(*this));
	return *this;
}

inline
WORD WaveFormatEx::formatTag(void)const
{
	return WAVEFORMATEX::wFormatTag;
}

inline
void WaveFormatEx::formatTag(WORD formatTag)
{
	WAVEFORMATEX::wFormatTag=formatTag;
}

inline
WORD WaveFormatEx::channels(void)const
{
	return WAVEFORMATEX::nChannels;
}

inline
void WaveFormatEx::channels(WORD channels)
{
	WAVEFORMATEX::nChannels=channels;
}

inline
DWORD WaveFormatEx::samplePerSecond(void)const
{
	return WAVEFORMATEX::nSamplesPerSec;
}

inline
void WaveFormatEx::samplesPerSecond(DWORD samplesPerSecond)
{
	WAVEFORMATEX::nSamplesPerSec=samplesPerSecond;
}

inline
DWORD WaveFormatEx::averageBytesPerSecond(void)const
{
	return WAVEFORMATEX::nAvgBytesPerSec;
}

inline
void WaveFormatEx::averageBytesPerSecond(DWORD averageBytesPerSecond)
{
	WAVEFORMATEX::nAvgBytesPerSec=averageBytesPerSecond;
}

inline
WORD WaveFormatEx::blockAlign(void)const
{
	return WAVEFORMATEX::nBlockAlign;
}

inline
void WaveFormatEx::blockAlign(WORD blockAlign)
{
	WAVEFORMATEX::nBlockAlign=blockAlign;
}

inline
WORD WaveFormatEx::bitsPerSample(void)const
{
	return WAVEFORMATEX::wBitsPerSample;
}

inline
void WaveFormatEx::bitsPerSample(WORD bitsPerSample)
{
  WAVEFORMATEX::wBitsPerSample=bitsPerSample;
}

inline
WORD WaveFormatEx::size(void)const
{
	return WAVEFORMATEX::cbSize;
}

inline
void WaveFormatEx::size(WORD size)
{
	WAVEFORMATEX::cbSize=size;
}

inline
WaveFormatEx::operator WAVEFORMATEX &(void)const
{
  return *((WAVEFORMATEX*)this);
}

inline
WaveFormatEx &WaveFormatEx::operator=(const FormatChunk &someFormatChunk)
{
	formatTag(someFormatChunk.formatTag());
	channels(someFormatChunk.channels());
	samplesPerSecond(someFormatChunk.samplesPerSecond());
	averageBytesPerSecond(someFormatChunk.averageBytesPerSecond());
	blockAlign(someFormatChunk.blockAlign());
	bitsPerSample(someFormatChunk.bitsPerSample());
  return *this;
}
#endif