#ifndef __FRAME_H__
|
#define __FRAME_H__
|
|
#include <math.h>
|
#include <cstring>
|
#include "typedefs.h"
|
#include "errcode.h"
|
|
class Frame {
|
private:
|
ubool mMute;
|
ubool mExtBuffer;
|
u16 mSize;
|
ufloat* mData;
|
public:
|
Frame() {mData = NULL; mSize =0 ; mExtBuffer =0 ; mMute = ufalse;} // = delete ;
|
Frame(u16 size) {
|
mData = new ufloat[size];
|
mSize = size;
|
mExtBuffer = ufalse;
|
mMute = ufalse;
|
}
|
uvoid SetBuffer(ufloat* buffer, u16 size) {
|
if(mData != NULL) {
|
delete []mData;
|
}
|
mData = buffer;
|
mSize = size;
|
mExtBuffer = utrue;
|
}
|
~Frame(){
|
if(mExtBuffer == ufalse)
|
delete []mData;
|
mData = NULL;
|
}
|
Frame& operator=(const Frame& ptr) {
|
if(&ptr != this) {
|
memcpy(mData, ptr.mData, mSize*sizeof(ufloat));
|
}
|
return *this;
|
}
|
Frame& operator+=(const Frame& rhs) {
|
for (u32 i = 0; i < mSize; i++) {
|
mData[i] += rhs.mData[i] - (mData[i] * rhs.mData[i] * (1.0f / 0x7fffffff));
|
}
|
return *this;
|
}
|
Frame& operator*=(ufloat g) {
|
for(u32 i =0 ;i < mSize;i ++) mData[i] *= g;
|
return *this;
|
}
|
|
inline uvoid SetMute() {
|
mMute = utrue;
|
Clear();
|
}
|
inline uvoid UnMute() {
|
mMute = ufalse;
|
}
|
inline ubool Mute() {return mMute;}
|
inline ufloat* Data() { return mData; }
|
inline const ufloat* Data() const { return mData; }
|
|
inline uvoid Copy(const ufloat* data){
|
if(data != mData) {
|
memcpy(mData, data, mSize*sizeof(ufloat));
|
}
|
}
|
|
inline uvoid Clear(){
|
memset(mData, 0 , sizeof(ufloat)*mSize);
|
}
|
|
inline ufloat Peak() const {
|
ufloat maxData =0, tmp;
|
for (u32 i = 0 ;i < mSize;i++) {
|
tmp = fabs(mData[i]);
|
maxData = fmax(maxData, tmp);
|
}
|
return maxData;
|
}
|
inline ufloat Peak(ufloat* nFrameMaxData, u32 nFrameNum) const {
|
ufloat peak = 0;
|
for (u32 i = 0;i<nFrameNum -1 ;i++ ){
|
nFrameMaxData[i] = nFrameMaxData[i + 1];
|
peak = fmax(peak , nFrameMaxData[i]);
|
}
|
nFrameMaxData[nFrameNum - 1] = Peak();
|
|
return fmax(peak , nFrameMaxData[nFrameNum - 1]);
|
}
|
inline ufloat Rms() const{
|
ufloat e = 0;
|
for (u32 i =0;i < mSize ;i++){
|
e += mData[i] * mData[i];
|
}
|
return e;
|
}
|
inline ufloat Rms(ufloat* nFrameMaxData, u32 nFrameNum) const {
|
u32 frameLen = mSize * nFrameNum;
|
ufloat curEnerge = Rms();
|
ufloat totalEnerge = curEnerge;
|
|
for (u32 i = 0;i < nFrameNum -1 ;i++){
|
nFrameMaxData[i] = nFrameMaxData[i + 1];
|
totalEnerge += nFrameMaxData[i];
|
}
|
nFrameMaxData[nFrameNum - 1] = curEnerge;
|
totalEnerge /= frameLen;
|
|
return sqrtf(totalEnerge);
|
}
|
};
|
|
|
#endif //__FRAME_H__
|
