mixertrack.cpp

miXo is a buzz machine (www.buzzmachines.com) - a plugin for the freely available jeskola buzz track

// MixerTrack.cpp: implementation of the CMixerTrack class.
//
//////////////////////////////////////////////////////////////////////
#include <sstream>
#include <math.h>
#include "dsplib.h"
#include "MixerTrack.h"

#ifdef _DEBUG
#include "stdafx.h"
#include <assert.h>
#include <string>
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////



CMixerTrack::CMixerTrack()
: //m_strKeySet(),
  m_fIncrement(0.05f),m_bStereo(false),
  m_strName(),m_cSampleData(),
//  m_fSampleData(0.0f),
  m_iSampleDataAccuracy(defSampleDataAccuracy),
  m_cRealValues(1.0,0.0),m_cHelperValues(1.0,0.0),
  m_eMode(em_Normal),m_fSlow(1.0),m_iKeySet(-1),
  m_iSampleDataCounter(1)
{
	m_pcMixingValues=&m_cRealValues;
}
CMixerTrack::CMixerTrack(const CMixerTrack &c) 
: //m_strKeySet(c.m_strKeySet),
  m_strName(c.m_strName),
  m_bStereo(c.m_bStereo),m_iKeySet(c.m_iKeySet),
//  m_fSampleData(c.m_fSampleData),
  m_cSampleData(c.m_cSampleData),
  m_fSlow(c.m_fSlow),
  m_iSampleDataAccuracy(c.m_iSampleDataAccuracy),
  m_cRealValues(c.m_cRealValues),m_cHelperValues(c.m_cHelperValues),
  m_eMode(em_Unknown),m_fIncrement(c.m_fIncrement),
  m_iSampleDataCounter(c.m_iSampleDataCounter),m_pcMixingValues(&m_cRealValues)
{ 
	SetMode(c.m_eMode); 
}

CMixerTrack::~CMixerTrack()
{
}
//void CMixerTrack::SetSampleData(float f) const
//{
//	static_cast<float>(m_fSampleData)=f;
//}
void CMixerTrack::Save(CMachineDataOutput * const pcOut)
{
	pcOut->Write(m_iKeySet);
//	pcOut->Write(m_strKeySet.c_str());
//	pcOut->Write(m_fLevel);
	m_cRealValues.Save(pcOut);
	pcOut->Write(m_fIncrement);
	pcOut->Write(m_bStereo);
	pcOut->Write(m_strName.c_str());
}
void CMixerTrack::Init(CMachineDataInput * const pcIn,unsigned uDataVersion)
{
	stringstream stmKeySetName;
	if(uDataVersion < 0x6)
	{
		char c='0';
		while(c != 0x0) {
			pcIn->Read(c);
			stmKeySetName << c;
		}
//		m_strKeySet=stmName.str();
		m_iKeySet=-1;
	}else{
		pcIn->Read(m_iKeySet);
	}
	m_cRealValues.Init(pcIn,uDataVersion);
	pcIn->Read(m_fIncrement);
	pcIn->Read(m_bStereo);
	char c='0';
	stringstream stmName;
	while(c != 0x0) {
		pcIn->Read(c);
		stmName << c;
	}
	if(m_iKeySet == -1) {
		stmName << "@" << stmKeySetName.str() << "(Old Version)" << ends;
	}
	m_strName=stmName.str();
}
void CMixerTrack::SetMode(TEMode m)
{
	switch(m) 
	{
	case em_Normal:
		m_pcMixingValues=&m_cRealValues;
		break;
	case em_Mute:
		m_cHelperValues.SetLevel(0.0);
		m_pcMixingValues=&m_cHelperValues;
		break;
	case em_Bypass:
		m_cHelperValues.SetLevel(1.0);
		m_pcMixingValues=&m_cHelperValues;
		break;
	default:
		m_pcMixingValues=&m_cRealValues;
		break;
	}
	m_eMode=m;
}
bool CMixerTrack::ProcessInput(float *psamples,int numsamples,float *pout,float fAmp)
{
//	if(numsamples > 0) {		//remove this later
//	assert((numsamples>1));
	if((m_iSampleDataCounter <= 0) && (numsamples > 2) && (psamples)) {
//		TakeSampleData(((psamples[0]+psamples[1])/2.0f)*fAmp);
//		TakeSampleData(((psamples[0]+psamples[1])/2.0f)*fAmp);
//		m_cSampleData.Set(m_bStereo,psamples[numsamples-1]*fAmp,psamples[numsamples-2]*fAmp);
		m_cSampleData.Set(m_bStereo,psamples[0]*fAmp,psamples[1]*fAmp);
		m_iSampleDataCounter=m_iSampleDataAccuracy;
	}
	m_iSampleDataCounter--;
//#ifdef _DEBUG
//		stringstream stm;
//		stm << psamples[0] << " " << m_fSampleData << ends;
//		OutputDebugString(stm.str().c_str());
//#endif
//
//	}else
//		return false;
	float fLevel=m_pcMixingValues->GetLevel();
	if(fLevel*fAmp >= 0.99) {
		if(m_bStereo)
			DSP_Add(pout,psamples,numsamples*2);   //S2S not in lib?
		else
			DSP_AddM2S(pout,psamples,numsamples);
		return true;
	}
	if(fLevel*fAmp <= 0.001) {
		return false;
	}
	if(m_bStereo) {
		DSP_AddS2S(pout,psamples,numsamples*2,fLevel*fAmp);
		return true;
	}
	DSP_AddM2S(pout,psamples,numsamples,fLevel*fAmp);
	return true;
}
void CMixerTrack::FilterCmd(cmd::TCmd c,cmd::TCmd mode,int iKeyDefId,float f1,float f2,float f3) 
{
	if(iKeyDefId == -1) {	//is part of "global"
		mode=cmd::ToAll;
	}
	switch(mode) {
	case cmd::ToOne:
	case cmd::ToMe:
		if(iKeyDefId == m_iKeySet)
			DoCmd(c,f1,f2,f3);
		break;
	case cmd::ToAll:
		DoCmd(c,f1,f2,f3);
		break;
	case cmd::ToAllButMe:
		if(iKeyDefId != m_iKeySet)
			DoCmd(c,f1,f2,f3);
		break;
	}
}
void CMixerTrack::DoCmd(cmd::TCmd TheCmd,float p1,float,float)
{
	switch(TheCmd) {
	case cmd::Max:
		m_cRealValues.SetLevel(1.0);
		return;
	case cmd::Min:
		m_cRealValues.SetLevel(0.0);
		return;
	case cmd::Plus:
		m_cRealValues.IncLevel(m_fIncrement*m_fSlow);
		break;
	case cmd::Minus:
		m_cRealValues.DecLevel(m_fIncrement*m_fSlow);
		break;
	case cmd::Inc:
		m_cRealValues.IncLevel(p1*m_fSlow);
		break;
	case cmd::Dec:
		m_cRealValues.DecLevel(p1*m_fSlow);
		break;
	case cmd::Slow:
		m_fSlow=p1;
		return;
	case cmd::Fast:
		m_fSlow=1.0+p1;
		return;
	case cmd::Mult:
		{
			float f=m_cRealValues.GetRealTargetLevel();
			float f1=1.0f-f;
			float fNewLevel;
			if(p1 >= 1.0f) {
				fNewLevel=1.0f-(f1*(2.0f-p1));
			}else{
				fNewLevel=f*(p1*(1.0f-f1));
			}
			m_cRealValues.SetLevel(fNewLevel);
		}
		break;
	}
	m_cRealValues.CorrectLevel();
}