#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__