/*
 * audioproc.c
 *
 *  Created on: 2021Äê11ÔÂ2ÈÕ
 *      Author: graydon
 */
#include <stdlib.h>
#include <stdio.h>
//#include <fstream>
#include "tob.h"
#include "crc.h"
#include "config.h"
#include "protocol.h"
#include "IModule.h"
#include "f2f.h"
#include "../drv/memory.h"
//#include "../lz/quicklz.h"
#include <string.h>
#include <cassert>
#include "scene.h"


ToB* ToB::tob = NULL;
//std::map<u32, convert_fn> ToB::ProcConvert = CreateProcConvert();
std::map<u32, ParamEntry*> ToB::ProcParamCtrl = CreateParamCtrl();

#define DEBUG_1
#ifdef DEBUG
	const s8* type_string[ModuleType::PROC_COUNT] = {
			//"none"
			"input"
			,"meter"
			,"peq"
			,"expander"
			,"compresser"
			,"limiter"
			,"mixer"
			,"delay"
			,"crossover"
			,"output"
			,"gain"
			,"nhs"
			,"gain sharing am"
			,"agc"
			,"aec"
			,"ans"
			,"sysctrl"
			,"shelf"
			,"selector"
			,"gating am"
			,"spl"
			,"gating"
			,"ducker"
			,"reverb"
			,"echo"
			,"geq"
			,"fir"
			,"afc"
			,"signal gen"
			,"pitch"
			,"route"
			,"dummuy input"
			,"dummy output"
	};
#endif



ToB::ToB(ubool dualDsp, u32 dspIndex )
	: dual_dsp(dualDsp), dsp_index(dspIndex),mList(32)
{
	if(tob != NULL) {
		delete tob;
	}
	tob = this;
	frames = NULL;
	processed = ufalse;
	mModuleNum =0;
}

ToB::~ToB()
{
	toClear();
	tob = NULL;
}

uvoid ToB::SetMute(ubool mute)
{
	processed = (mute==0);
}

ErrStatus ToB::toClear()
{
	processed = ufalse;
	for (std::vector<IModule*>::iterator iter = mList.begin();
		iter != mList.end() ;iter++) {
		delete *iter;
	}
	mList.clear();
	mModuleIndex.clear();

	if(frames != NULL) {
		delete frames;
	}
	mModuleNum =0;

	return ErrStatus::SUCCESS;
}

IModule* ToB::CreateBaseModule(u32 moduleType, u16 tag ,u16 rxNum, u16 txNum)
{
	ExportModules& em = ExportModules::Instance();
	ModuleEntry* entry = em.GetModuleEntry(moduleType);
	if (entry) {
		Create create = entry->GetEntry();
		if (create) {
			return create(tag, entry->link_enable , SAMPLE_RATE, SAMPLE_NUM, rxNum, txNum);
		}
	}
	return 	0;//new IModule(SAMPLE_RATE, SAMPLE_NUM, rxNum, txNum);
}


ErrStatus ToB::CreateModule(const u8* bin, u32 nbytes)
{
//	extern uvoid SetNumOfChannels(u16 rxNum, u16 txNum);
//	extern uvoid SetRxChannelPtr(u32 channel ,ufloat* rxBuffer);
//	extern uvoid SetTxChannelPtr(u32 channel, ufloat* txBuffer);
//	FlowChartHead* head = (FlowChartHead*)bin;
//
//	//check crc
//	u32 tmp_crc ,crc = head->crcLsb|(head->crcMsb<<16);
//	head->crcLsb = head->crcMsb = 0;
//	tmp_crc = CRC::crc32(bin, nbytes);
//	if (tmp_crc != crc) {
//		dbg_printf("flowchar crc check fail.\n");
//		return ERR_PARAM;
//	}
//	dbg_printf("modules num %d, DSP1 Buffer %d,DSP2 Buffer %d.\n"
//			,head->module_num
//			,head->dsp_buffer_num[0]
//			,dual_dsp?head->dsp_buffer_num[1]:0);
//
//	u32 size = sizeof(FlowChartHead);
//	u32 nPhyInput =0 ,nPhyOutput=0;
//
//	processed = ufalse;
//
//	frames = new Frames(head->dsp_buffer_num[dsp_index]);
//
//
//	do {
//		Module* pmod = (Module*)(bin+ size);
//		size += sizeof(Module);
//		u16* mRxbufID = (u16*)(bin + size);	size += pmod->mRxNum * sizeof(u16);
//		u16* mTxbufID = (u16*)(bin + size);	size += pmod->mTxNum * sizeof(u16);
//
//#ifdef DEBUG
//		printf("Module ID %d type %s rxnum %d txnum %d. \n",pmod->mID ,type_string[pmod->mType], pmod->mRxNum,pmod->mTxNum);
//#endif
//		if (/*dual_dsp &&*/ pmod->mDsp != dsp_index)  {
//			dbg_printf("Module ID %d dsp index %d do not match %d .\n", pmod->mID,pmod->mDsp,dsp_index);
//			continue;
//		}
//
//		ubool bInput=ufalse,bOutput=ufalse;
//		if(pmod->mPhyModule == ModuleInterfaceType::PHY_INPUT) {
//			bInput = utrue;
//		}
//		else if(pmod->mPhyModule == ModuleInterfaceType::PHY_OUTPUT) {
//			bOutput = utrue;
//		}
//
//		IModule* m = CreateBaseModule(pmod->mType,pmod->mTag, pmod->mRxNum,pmod->mTxNum);
//		if(!m) {
//			dbg_printf("Module ID Create fail.\n", pmod->mID);
//			continue;
//		}
//
//		//if(pmod->mType == PROC_DELAY) continue;
//
//		m->SetModuleInfo(pmod->mID ,pmod->mType,pmod->mTag);
//		mList.push_back(m);
//
//		if(pmod->mID >= mModuleIndex.size()) {
//			mModuleIndex.resize(pmod->mID + 1, 0);
//		}
//		mModuleIndex[pmod->mID] = ++mModuleNum ;
//
//		for (size_t i = 0; i < pmod->mTxNum; i++){
//			if (mTxbufID[i] > 0) {
//				Frame* pcm = frames->GetFrame(mTxbufID[i]-1);
//				m->SetOutputChannelDataPtr(i, pcm);
//				if (bOutput) {
//					SetTxChannelPtr(nPhyOutput++, pcm->Data());
//				}
//			}
//			else {
//				m->SetOutputChannelDataPtr(i, 0);
//			}
//		}
//
//		for (size_t i = 0; i < pmod->mRxNum ; i++) {
//			if (mRxbufID[i] > 0) {
//				Frame* pcm = frames->GetFrame(mRxbufID[i]-1);
//				m->SetInputChannelDataPtr(i, pcm);
//				if (bInput) {
//					SetRxChannelPtr(nPhyInput++, pcm->Data());
//				}
//			}
//			else {
//				m->SetInputChannelDataPtr(i, 0);
//			}
//		}
//
//		m->Init();
//
//	} while (size < nbytes);
//
//	if (size != nbytes) {
//		dbg_printf("check flowchart some error!\n");
//	}
//	dbg_printf("Phy InputNum %d, Output Num %d\n",nPhyInput,nPhyOutput);
//	SetNumOfChannels(nPhyInput, nPhyOutput);
	//processed = utrue;

	return 	ErrStatus::SUCCESS;
}
#define DBG() do{ static int cnt = 0; printf("%s: %d\n", __FUNCTION__, ++cnt); }while(0)
ErrStatus ToB::CreateModule(const u8* bin, u32 nbytes, const u8 *scene_bin)
{
	extern uvoid SetNumOfChannels(u16 rxNum, u16 txNum);
	extern uvoid SetRxChannelPtr(u32 channel ,ufloat* rxBuffer);
	extern uvoid SetTxChannelPtr(u32 channel, ufloat* txBuffer);

	FlowChartHead* head = (FlowChartHead*)bin;

	//check crc
	u32 tmp_crc ,crc = head->crcLsb|(head->crcMsb<<16);
	head->crcLsb = head->crcMsb = 0;
	tmp_crc = CRC::crc32(bin, nbytes);
	if (tmp_crc != crc) {
		dbg_printf("flowchar crc check fail.\n");
		return ERR_PARAM;
	}
	dbg_printf("modules num %d, DSP1 Buffer %d,DSP2 Buffer %d.\n"
			,head->module_num
			,head->dsp_buffer_num[0]
			,dual_dsp?head->dsp_buffer_num[1]:0);

	u32 size = sizeof(FlowChartHead);
	u32 nPhyInput =0 ,nPhyOutput=0;

	//u32 offset = sizeof(scenehead);
	int plen;

	processed = ufalse;

	frames = new Frames(head->dsp_buffer_num[dsp_index]);

	do {
		ModuleParam* pmod = (ModuleParam*)(bin+ size);
		size += sizeof(ModuleParam);
		u16* mRxbufID = (u16*)(bin + size);	size += pmod->mRxNum * sizeof(u16);
		u16* mTxbufID = (u16*)(bin + size);	size += pmod->mTxNum * sizeof(u16);

#ifdef DEBUG
		printf("Module ID %d type %s rxnum %d txnum %d. \n",pmod->mID ,type_string[pmod->mType], pmod->mRxNum,pmod->mTxNum);
#endif

		if (/*dual_dsp &&*/ pmod->mDsp != dsp_index)  {
			dbg_printf("Module ID %d dsp index %d do not match %d .\n", pmod->mID,pmod->mDsp,dsp_index);
			continue;
		}

		ubool bInput=ufalse,bOutput=ufalse;
		if(pmod->mPhyModule == ModuleInterfaceType::PHY_INPUT) {
			bInput = utrue;
		}
		else if(pmod->mPhyModule == ModuleInterfaceType::PHY_OUTPUT) {
			bOutput = utrue;
		}

		IModule* m = CreateBaseModule(pmod->mType,pmod->mTag, pmod->mRxNum,pmod->mTxNum);
		if(!m) {
			dbg_printf("Module ID Create fail.\n", pmod->mID);
			continue;
		}

		m->SetModuleInfo(pmod->mID ,pmod->mType,pmod->mTag);
		m->SetParamDataPtr(pmod->handle);
		mList.push_back(m);

		if(pmod->mID >= mModuleIndex.size()) {
			mModuleIndex.resize(pmod->mID + 1, 0);
		}
		mModuleIndex[pmod->mID] = ++mModuleNum ;

		for (size_t i = 0; i < pmod->mTxNum; i++){
			if (mTxbufID[i] > 0) {
				Frame* pcm = frames->GetFrame(mTxbufID[i]-1);
				m->SetOutputChannelDataPtr(i, pcm);
				if (bOutput) {
					SetTxChannelPtr(nPhyOutput++, pcm->Data());
				}
			}
			else {
				m->SetOutputChannelDataPtr(i, 0);
			}
		}

		for (size_t i = 0; i < pmod->mRxNum ; i++) {
			if (mRxbufID[i] > 0) {
				Frame* pcm = frames->GetFrame(mRxbufID[i]-1);
				m->SetInputChannelDataPtr(i, pcm);
				if (bInput) {
					SetRxChannelPtr(nPhyInput++, pcm->Data());
				}
			}
			else {
				m->SetInputChannelDataPtr(i, 0);
			}
		}

		m->Init();

		ToB::ProcParamCtrl[pmod->mType]->GetParamEntry()(m, pmod->handle, plen);
		//offset += plen;

	} while (size < nbytes);
	//DBG();
	if (size != nbytes) {
		dbg_printf("check flowchart some error!\n");
	}
	dbg_printf("Phy InputNum %d, Output Num %d\n",nPhyInput,nPhyOutput);

	Frame* UsbRx = frames->GetFrame(nPhyInput+1);
	Frame* UsbTx = frames->GetFrame(nPhyOutput);

	SetRxChannelPtr(nPhyInput+1, UsbRx->Data());
	SetTxChannelPtr(nPhyOutput, UsbTx->Data());

	SetNumOfChannels(nPhyInput+2, nPhyOutput+1);

	processed = utrue;

	return 	ErrStatus::SUCCESS;
}

ErrStatus ToB::toProc()
{
	if(processed) {
		for (std::vector<IModule*>::iterator iter = mList.begin();
			iter != mList.end() ;iter++) {
			//if((*iter)->GetModuleType() != PROC_ANS && (*iter)->GetModuleType() != PROC_AEC){
				(*iter)->Proc();
			//}
		}
	}
	else {
		MuteOutput();
	}
	return ErrStatus::SUCCESS;
}
#define NORMALIZE(X) (((X)&0x8000)?(-((~(X))&0xffff)-1):(X)) //»¹Ô­·ûºÅλ
ErrStatus ToB::toCtrl(u32 mID, u32 pID, s16* val, u32 num)
{
//	if(mID >= mModuleIndex.size() || mModuleIndex[mID] == 0) {
//		return ErrStatus::ERR_PARAM;
//	}
//
//	IModule* m = mList[mModuleIndex[mID]-1];
//	if( m != NULL) {
//		for(u32 i=0; i < num;  i++){
//			val[i] = NORMALIZE(val[i]);
//		}
//		m->Ctrl(pID, val, num);
//	}

	return ErrStatus::SUCCESS;
}

ErrStatus ToB::toCtrl(u32 mID, u32 pID, s16* val)
{
	if(mID >= MAX_MODULE_NUM) {
		return ErrStatus::ERR_PARAM;
	}

	u32 proc_type  = scene_get_proc_type(mID);

	if(proc_type == PROC_INPUT && (pID == INPUT_TYPE || pID == INPUT_FREQ || pID == INPUT_LEVEL)){
		proc_type = PROC_SIGNALGEN;
		mID = 300;
	}
	else if(proc_type == PROC_DUCKER && pID == DUCKER_MIX){
		proc_type = PROC_MIXER;
		mID = mID + 320;
	}

	IModule* m = mList[mModuleIndex[mID]-1];
	if( m != NULL) {
		ToB::ProcParamCtrl[proc_type]->GetCtrlEntry()(m, pID, val);
	}
	return ErrStatus::SUCCESS;
}

#if 0
ErrStatus ToB::toCtrl(const u8* bin , u32 nbytes)
{
	struct scenehead* head = (struct scenehead*)bin;
	u32 compressLen;
	u32 tmp_crc = 0xffffffff;
	u32 crc = (head->crc[1] << 16) | (head->crc[0] & 0xffff);
	head->crc[1] = head->crc[0] = 0;
	//tmp_crc = CRC::crc32(bin, nbytes);
	int size = sizeof(struct scenehead);
	int tmp = 2048;
	while(size < nbytes)
	{
		tmp_crc = CRC::ssh_crc32_block(tmp_crc, bin+size, tmp);
		size += tmp;
		if((nbytes-size) < tmp)
		{
			tmp = (nbytes-size);
		}
	}
	if (tmp_crc != crc) {
		dbg_printf("flowchar crc check fail.\n");
		return ErrStatus::ERR_PARAM;
	}


	size = sizeof(struct scenehead);
	u8* bin_scene = (u8*)DDRMalloc(nbytes*4);
	assert(bin_scene != NULL);
	int offset = 0;
	int datalen = 0;
	short plen = 0;

	for(std::vector<IModule*>::iterator iter = mList.begin();iter != mList.end() ;iter++) {
		datalen = ToB::ProcConvert[(*iter)->GetModuleType()]((void *)(bin+size),(*iter)->GetModuleID(), bin_scene+offset, &plen);
		//printf("%s\n",type_string[(*iter)->GetModuleType()]);
		size +=plen;
		offset +=datalen;
	}

	if(size != nbytes) {
		dbg_printf("Parameter conversion error!\n");
		//printf("Parameter conversion error!\n");
	}

	bin = bin_scene;
	size = 0;

	while(size < offset) {
		Param* h = (Param*)(bin+size);
		size += sizeof(Param);
		s16* val = (s16*)(bin+size);

		toCtrl(h->mID, h->pID, val, h->num);
		size += h->num*sizeof(s16);
	}

	if(size != offset) {
		dbg_printf("check preset has some error!\n");
		//printf("check preset has some error!\n");
	}

	//DDRFree((uvoid*)bin);
	DDRFree((uvoid*)bin_scene);
	bin_scene = NULL;

	processed = utrue;
	return ErrStatus::SUCCESS;
}
#else
ErrStatus ToB::toCtrl(const u8* bin , u32 nbytes)
{
	struct scenehead* head = (struct scenehead*)bin;
	u32 compressLen;
	u32 tmp_crc = 0xffffffff;
	u32 crc = (head->crc[1] << 16) | (head->crc[0] & 0xffff);
	head->crc[1] = head->crc[0] = 0;
	int size = sizeof(struct scenehead);
	int tmp = 2048;
	while(size < nbytes)
	{
		tmp_crc = CRC::ssh_crc32_block(tmp_crc, bin+size, tmp);
		size += tmp;
		if((nbytes-size) < tmp)
		{
			tmp = (nbytes-size);
		}
	}
	if (tmp_crc != crc) {
		dbg_printf("flowchar crc check fail.\n");
		return ErrStatus::ERR_PARAM;
	}


	size = sizeof(struct scenehead);

	int offset = 0;
	int result = 0;
	int plen = 0;

	for(std::vector<IModule*>::iterator iter = mList.begin();iter != mList.end() ;iter++) {
		result = ToB::ProcParamCtrl[(*iter)->GetModuleType()]->GetParamEntry()(*iter, (void *)(bin+size), plen);
		if(result != 0){
			printf("error!\n");
		}
		size += plen;
	}

	if(size != nbytes) {
		dbg_printf("Parameter conversion error!\n");
		//printf("Parameter conversion error!\n");
	}


	processed = utrue;
	return ErrStatus::SUCCESS;
}
#endif

uvoid ToB::SetModuleParam(u32 proc_type, u32 mID, void *handle)
{
	int plen;
	IModule* m = mList[mModuleIndex[mID]-1];
	if( m != NULL) {
		ToB::ProcParamCtrl[proc_type]->GetParamEntry()(m, handle, plen);
	}
}

u32 ToB::GetLevels(s16 * buffer)
{
	u32 n =0, size;
	if( !processed ) {
		return 0;
	}

	for (std::vector<IModule*>::iterator iter = mList.begin();
		iter != mList.end() ; iter++) {
		size = (*iter)->GetLevel(buffer + n );
		//printf("%s:%d\n",type_string[(*iter)->GetModuleType()],size);
		n += size;
	}
	mLevelNum = n;

	return n;
}


u32 ToB::GetRuntime(u16 * buffer)
{
	u32 n =0;
	u32 cpu = SAMPLE_RATE*10000 /SAMPLE_NUM ;

	if( !processed ) {
		return 0;
	}

	for (std::vector<IModule*>::iterator iter = mList.begin();
		iter != mList.end() ; iter++) {
		ufloat time = (*iter)->GetRuntime() ;
		buffer[n++] = (u16)(time* cpu); //percent*100.
	}

	return n;
}