Work/mixer/Main.cpp

#include <common/windows.hpp>
#include <mixer/mainwnd.hpp>

#include <sample/wave.hpp>



/*
//#include <mixer/SampleDataInterface.hpp>
//#include <mixer/SampleDataImpl.hpp>
//#include <mixer/SampleData.hpp>

typedef struct _SAMPLE_DATA
{
  union
	{
	  int b4:4;
		int b8:8;
		int b16:16;
		int b32:32;
	};
}SAMPLE_DATA;

typedef SAMPLE_DATA SampleData;

class PureSampleEx
{
public:  
  typedef enum BitsPerSample{Bit4=4,Bit8=8,Bit16=16,Bit32=32};
	enum{BitsPerByte=8};
	PureSampleEx();
	virtual ~PureSampleEx();
  PureSampleEx &operator=(const PureSampleEx &pureSampleEx);
	bool operator==(const PureSampleEx &pureSampleEx);
  bool convert(BitsPerSample bitsPerSample);
  bool convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample);
  bool initialize(BitsPerSample bitsPerSample,int numSamples);
	bool getAt(int sampleIndex,SampleData &sampleData);
	bool setAt(int sampleIndex,SampleData &sampleData);
	bool isOkay(void)const;
	DWORD getSizeBytes(void)const;
	DWORD getNumSamples(void)const;
private:
  static int getRequiredLength(BitsPerSample bitsPerSample,int numSamples);
  static void translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample);

  Array<BYTE> mSampleData;
	BitsPerSample mBitsPerSample;
	DWORD mNumSamples;
};

inline
PureSampleEx::PureSampleEx()
: mBitsPerSample(Bit8), mNumSamples(0)
{
}

inline
PureSampleEx::~PureSampleEx()
{
}

inline
bool PureSampleEx::initialize(BitsPerSample bitsPerSample,int numSamples)
{
  mBitsPerSample=bitsPerSample;
	mNumSamples=numSamples;
	mSampleData.size(getRequiredLength(bitsPerSample,numSamples));
	return true;
}

inline
int PureSampleEx::getRequiredLength(BitsPerSample bitsPerSample,int numSamples)
{
  return ((float)bitsPerSample/(float)BitsPerByte)*numSamples;
}

inline
PureSampleEx &PureSampleEx::operator=(const PureSampleEx &pureSampleEx)
{
  mSampleData=pureSampleEx.mSampleData;
	mBitsPerSample=pureSampleEx.mBitsPerSample;
  mNumSamples=pureSampleEx.mNumSamples;
	return *this;
}

inline
bool PureSampleEx::operator==(const PureSampleEx &pureSampleEx)
{
  if(mBitsPerSample!=pureSampleEx.mBitsPerSample || mNumSamples!=pureSampleEx.mNumSamples)return false;
	return mSampleData==pureSampleEx.mSampleData;
}

bool PureSampleEx::convert(BitsPerSample bitsPerSample)
{
  PureSampleEx pureSampleEx;
  
	convert(pureSampleEx,bitsPerSample);
	*this=pureSampleEx;
	return true;
}

bool PureSampleEx::convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample)
{
	SampleData srcData;
	SampleData dstData;

	if(!isOkay())return false;
	pureSampleEx.initialize(bitsPerSample,getNumSamples());
	for(int index=0;index<getNumSamples();index++)
	{
	  getAt(index,srcData);
		translate(srcData,mBitsPerSample,dstData,bitsPerSample);
		pureSampleEx.setAt(index,dstData);
	}
	return pureSampleEx.isOkay();
}

void PureSampleEx::translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample)
{
  if(Bit4==srcBitsPerSample)
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b4;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b4;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b4;
		else dstData.b32=srcData.b4;
	}
	else if(Bit8==srcBitsPerSample)
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b8;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b8;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b8;
		else dstData.b32=srcData.b8;
	}
	else if(Bit16==srcBitsPerSample)
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b16;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b16;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b16;
		else dstData.b32=srcData.b16;
	}
	else
	{
	  if(Bit4==dstBitsPerSample)dstData.b4=srcData.b32;
		else if(Bit8==dstBitsPerSample)dstData.b8=srcData.b32;
		else if(Bit16==dstBitsPerSample)dstData.b16=srcData.b32;
		else dstData.b32=srcData.b32;
	}
}

inline
bool PureSampleEx::getAt(int sampleIndex,SampleData &sampleData)
{
  float index;
	int byteIndex;

  if(sampleIndex>=mNumSamples)return false;
	index=((float)mBitsPerSample/(float)BitsPerByte)*(float)sampleIndex;
  byteIndex=index;
	if(Bit4==mBitsPerSample)
	{
	  BYTE b=mSampleData[byteIndex];
		if(0.00==(float)byteIndex-index)sampleData.b4=b;
		else sampleData.b4=(b>>4);
	}
	else if(Bit8==mBitsPerSample)
	{
	  sampleData.b8=mSampleData[byteIndex];
	}
	else if(Bit16==mBitsPerSample)
	{
	  sampleData.b16=*((WORD*)&mSampleData[byteIndex]);
	}
	else if(Bit32==mBitsPerSample)
	{
	  sampleData.b32=*((DWORD*)&mSampleData[byteIndex]);
	}
	return true;
}

inline
bool PureSampleEx::setAt(int sampleIndex,SampleData &sampleData)
{
  float index;
	int byteIndex;

  if(sampleIndex>=mNumSamples)return false;
	index=((float)mBitsPerSample/(float)BitsPerByte)*(float)sampleIndex;
  byteIndex=index;
	if(Bit4==mBitsPerSample)
	{
	  BYTE b=mSampleData[byteIndex];
		if(0.00==(float)byteIndex-index)mSampleData[byteIndex]=(b&0xF0)|sampleData.b4;
		else mSampleData[byteIndex]=(b&0x0F)|(((BYTE)sampleData.b4)<<4);
	}
	else if(Bit8==mBitsPerSample)
	{
	  mSampleData[byteIndex]=sampleData.b8;
	}
	else if(Bit16==mBitsPerSample)
	{
	  *((WORD*)&mSampleData[byteIndex])=sampleData.b16;
	}
	else if(Bit32==mBitsPerSample)
	{
	  *((DWORD*)&mSampleData[byteIndex])=sampleData.b32;
	}
	return true;
}

inline
DWORD PureSampleEx::getSizeBytes(void)const
{
  return getRequiredLength(mBitsPerSample,getNumSamples());
}

inline
DWORD PureSampleEx::getNumSamples(void)const
{
  return mNumSamples;
}

inline
bool PureSampleEx::isOkay(void)const
{
  return mNumSamples?true:false;
}
*/

// *************************************************************************************************


/*
  PureSampleEx bm;
  PureSampleEx bm2;
	PureSampleEx bm3;
	SampleData sampleData;

  bm.initialize(PureSampleEx::Bit4,1000000);
	for(int index=0;index<bm.getNumSamples();index++)
	{
	  sampleData.b4=index;
		bm.setAt(index,sampleData);
	}
	bm.getAt(1,sampleData);
	bm.convert(bm2,PureSampleEx::Bit16);
	bm3=bm2;
	if(bm3==bm2)::OutputDebugString("Equal\n");
	else ::OutputDebugString("Not Equal\n");
*/

/*  WaveForm wave;
	SmartPointer<SampleData> sample;

	if(!wave.open("D:\\Program Files\\FruityLoops3\\Samples\\Packs\\Basic\\Kicks\\Kick.wav"))return 0;
  FormatChunk &formatChunk=wave.getFormatChunk();
	PureSample &pureSample=wave.getPureSample();

	if(16==formatChunk.bitsPerSample())
	{
	  UHUGE *sampleData=pureSample.sampleData();
	}
	else if(8==formatChunk.bitsPerSample())
	{
	  UHUGE *sampleData=pureSample.sampleData();
	}
*/


int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR lpszCmdLine,int /*nCmdShow*/)
{
  MainWindow mainWindow;
	return mainWindow.messageLoop();
}