292 lines
7.0 KiB
C++
292 lines
7.0 KiB
C++
#ifndef _SAMPLE_PURESAMPLEEX_HPP_
|
|
#define _SAMPLE_PURESAMPLEEX_HPP_
|
|
#ifndef _COMMON_EXCEPTION_HPP_
|
|
#include <common/except.hpp>
|
|
#endif
|
|
#ifndef _COMMON_WINDOWS_HPP_
|
|
#include <common/windows.hpp>
|
|
#endif
|
|
#ifndef _COMMON_MEMFILE_HPP_
|
|
#include <common/memfile.hpp>
|
|
#endif
|
|
#ifndef _COMMON_OPENFILE_HPP_
|
|
#include <common/openfile.hpp>
|
|
#endif
|
|
|
|
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 InitOptions{ParamIsNumSamples,ParamIsSizeBytes};
|
|
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);
|
|
PureSampleEx &operator+=(const PureSampleEx &pureSampleEx);
|
|
bool write(MemFile &memFile)const;
|
|
bool read(FileHandle &handle);
|
|
bool convert(BitsPerSample bitsPerSample);
|
|
bool convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample);
|
|
bool initialize(BitsPerSample bitsPerSample,int param,InitOptions initOption);
|
|
bool getAt(int sampleIndex,SampleData &sampleData);
|
|
bool setAt(int sampleIndex,SampleData &sampleData);
|
|
bool isOkay(void)const;
|
|
DWORD getSizeBytes(void)const;
|
|
DWORD getNumSamples(void)const;
|
|
BitsPerSample getBitsPerSample(void)const;
|
|
BYTE *getSampleData(void);
|
|
private:
|
|
static int getRequiredLength(BitsPerSample bitsPerSample,int numSamples);
|
|
static void translate(SampleData &srcData,BitsPerSample srcBitsPerSample,SampleData &dstData,BitsPerSample &dstBitsPerSample);
|
|
static int getNumSamples(BitsPerSample bitsPerSample,int sizeBytes);
|
|
|
|
Array<BYTE> mSampleData;
|
|
BitsPerSample mBitsPerSample;
|
|
DWORD mNumSamples;
|
|
};
|
|
|
|
inline
|
|
PureSampleEx::PureSampleEx()
|
|
: mBitsPerSample(Bit8), mNumSamples(0)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PureSampleEx::~PureSampleEx()
|
|
{
|
|
}
|
|
|
|
inline
|
|
bool PureSampleEx::initialize(BitsPerSample bitsPerSample,int param,InitOptions initOption)
|
|
{
|
|
if(ParamIsNumSamples==initOption)
|
|
{
|
|
mBitsPerSample=bitsPerSample;
|
|
mNumSamples=param;
|
|
mSampleData.size(getRequiredLength(bitsPerSample,mNumSamples));
|
|
}
|
|
else
|
|
{
|
|
mBitsPerSample=bitsPerSample;
|
|
mNumSamples=getNumSamples(bitsPerSample,param);
|
|
mSampleData.size(param);
|
|
}
|
|
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;
|
|
}
|
|
|
|
inline
|
|
PureSampleEx &PureSampleEx::operator+=(const PureSampleEx &pureSampleEx)
|
|
{
|
|
throw Exception("PureSampleEx::operator+=() not implemented");
|
|
return *this;
|
|
}
|
|
|
|
inline
|
|
bool PureSampleEx::convert(BitsPerSample bitsPerSample)
|
|
{
|
|
PureSampleEx pureSampleEx;
|
|
|
|
convert(pureSampleEx,bitsPerSample);
|
|
*this=pureSampleEx;
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
bool PureSampleEx::convert(PureSampleEx &pureSampleEx,BitsPerSample bitsPerSample)
|
|
{
|
|
SampleData srcData;
|
|
SampleData dstData;
|
|
|
|
if(!isOkay())return false;
|
|
pureSampleEx.initialize(bitsPerSample,getNumSamples(),PureSampleEx::ParamIsNumSamples);
|
|
for(int index=0;index<getNumSamples();index++)
|
|
{
|
|
getAt(index,srcData);
|
|
translate(srcData,mBitsPerSample,dstData,bitsPerSample);
|
|
pureSampleEx.setAt(index,dstData);
|
|
}
|
|
return pureSampleEx.isOkay();
|
|
}
|
|
|
|
inline
|
|
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
|
|
bool PureSampleEx::write(MemFile &memFile)const
|
|
{
|
|
if(!isOkay())return false;
|
|
if(!memFile.write((char*)&((Array<BYTE>&)mSampleData)[0],mSampleData.size()))return false;
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
bool PureSampleEx::read(FileHandle &handle)
|
|
{
|
|
if(!isOkay())return false;
|
|
if(!handle.read(&mSampleData[0],mSampleData.size()))return false;
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
DWORD PureSampleEx::getSizeBytes(void)const
|
|
{
|
|
return getRequiredLength(mBitsPerSample,getNumSamples());
|
|
}
|
|
|
|
inline
|
|
DWORD PureSampleEx::getNumSamples(void)const
|
|
{
|
|
return mNumSamples;
|
|
}
|
|
|
|
inline
|
|
PureSampleEx::BitsPerSample PureSampleEx::getBitsPerSample(void)const
|
|
{
|
|
return mBitsPerSample;
|
|
}
|
|
|
|
inline
|
|
int PureSampleEx::getNumSamples(BitsPerSample bitsPerSample,int sizeBytes)
|
|
{
|
|
return ((float)BitsPerByte/(float)bitsPerSample)*(float)sizeBytes;
|
|
}
|
|
|
|
inline
|
|
BYTE *PureSampleEx::getSampleData(void)
|
|
{
|
|
return &mSampleData[0];
|
|
}
|
|
|
|
inline
|
|
bool PureSampleEx::isOkay(void)const
|
|
{
|
|
return mNumSamples?true:false;
|
|
}
|
|
#endif
|