/* Copyright (c) Microsoft Corporation.
   Licensed under the MIT License. */

/***************************************************************************

	Actor Sound.

	Primary Author: ******
	Status:  Reviewed
		
***************************************************************************/

#include "soc.h"

ASSERTNAME


/***************************************************************************
	
	Add a sound event to the actor event list, and create an undo object

***************************************************************************/
bool ACTR::FSetSnd(PTAG ptag, bool fLoop, bool fQueue, bool fMotionMatch, long vlm, long sty)
{
	AssertThis(0);
	AssertVarMem(ptag);
	AssertIn(sty, 0, styLim);
	
	PACTR pactrDup;

	if (!FDup(&pactrDup))
		{
		return fFalse;
		}

    if (!FSetSndCore(ptag, fLoop, fQueue, fMotionMatch, vlm, sty))
		{
		Restore(pactrDup);
        ReleasePpo(&pactrDup);
		return fFalse;
		}

	if (!FCreateUndo(pactrDup, fTrue))
		{
		Restore(pactrDup);
        ReleasePpo(&pactrDup);
		return fFalse;
		}

	ReleasePpo(&pactrDup);
	return fTrue;
}


/***************************************************************************
	
	Add a sound event to the actor event list
	For user sounds, the chid must also be fetched for the argument *ptag
	and stored with the event, since for user sounds, the cno can change
	(eg on scene import)
	Note: ptag is current because the sound browser has just completed building
	a current tag.	

***************************************************************************/
bool ACTR::FSetSndCore(PTAG ptag, bool fLoop, bool fQueue, bool fMotionMatch, long vlm, long sty)
{
	AssertThis(0);
	AssertVarMem(ptag);
	AssertIn(sty, 0, styLim);

	PMSND pmsnd = pvNil;
	AEVSND aevsnd;
	long ccel;
	long iaev;
	AEV *paev;
	long sqn;
	long cbVar;

	// Verify sound before including in the event list
	pmsnd = (PMSND)vptagm->PbacoFetch(ptag, MSND::FReadMsnd);
	if (pvNil == pmsnd)
		goto LFail;
	
	if (pmsnd->Sty() == styMidi)
		{
		// There are no midi actor sounds in the product
		PushErc(ercSocNoActrMidi);
		goto LFail;
		}

	// Verify space up front
	cbVar = kcbVarStep + kcbVarSnd;
	if (!_pggaev->FEnsureSpace(2, cbVar, fgrpNil))
		return fFalse;
		
	aevsnd.fLoop = fLoop;
	aevsnd.fQueue = fQueue;
	aevsnd.vlm = (vlm == vlmNil) ? pmsnd->Vlm() : vlm;
	aevsnd.tag = *ptag;
	aevsnd.fNoSound = pmsnd->FNoSound();
	aevsnd.sty = (sty == styNil) ? pmsnd->Sty() : sty;
	sty = aevsnd.sty;
	vlm = aevsnd.vlm;

	if (ptag->sid != ksidUseCrf)
		TrashVar(&aevsnd.chid);
	else
		{
		if (!_pscen->Pmvie()->FChidFromUserSndCno(aevsnd.tag.cno, &aevsnd.chid))
			goto LFail;
		}

	if (!fMotionMatch)
		aevsnd.celn = smmNil;	// Not a motion match sound	  	
	else
		{
		if (!_ptmpl->FGetCcelActn(_anidCur, &ccel))
			goto LFail;
		aevsnd.celn = _celnCur % ccel;
		}

	if (!_FAddDoAev(aetSnd, kcbVarSnd, &aevsnd))
		goto LFail;

	ReleasePpo(&pmsnd);

	// Remove "no sounds" of this sqn between here and the next
	// sound of this sqn
	sqn = MSND::SqnActr(sty, _arid);
	for (iaev = _iaevCur; iaev < _pggaev->IvMac(); iaev++)
		{
		AEVSND aevsndT;
		paev = (AEV *)_pggaev->QvFixedGet(iaev);
		if (aetAdd == paev->aet)
			break;
		if (aetSnd != paev->aet)
			continue;
		_pggaev->Get(iaev, &aevsndT);
		if (MSND::SqnActr(aevsndT.sty, _arid) != sqn)
			continue;
		
		// Quit when reach real sound of same sqn
		if (!aevsndT.fNoSound)
			break;	
		_RemoveAev(iaev);
		iaev--;
		}


	// Enqueue the motion match sounds in the Msq
	// Allow the edit even if all sounds do not play
	if (!(_pscen->GrfScen() & fscenSounds))
		_FEnqueueSmmInMsq();		//Ignore errors : other sounds involved

	Pscen()->Pmvie()->Pmcc()->SetSndFrame(fTrue);
	return fTrue;

LFail:
	ReleasePpo(&pmsnd);
	return fFalse;
}


/***************************************************************************
	
	Enqueue the sound at event iaev.
	Enter motion match sounds in the smm gl.
	Enter non-motion match sounds in the Msq

***************************************************************************/
bool ACTR::_FEnqueueSnd(long iaev)
{
	AssertThis(0);
	AssertIn(iaev, 0, _pggaev->IvMac());

	AEVSND aevsnd;
	PMSND pmsnd = pvNil;
	long tool;

	_pggaev->Get(iaev, &aevsnd);

	//
	// Motion match sounds are not enqueued when event iaev is seen
	// Otherwise the sound would be played twice
	//
	if (aevsnd.celn != smmNil)
		{
		// Insert Smm for this cel in the gl
		return _FInsertSmm(iaev);
		}
	
	if (aevsnd.fLoop)
		tool = toolLooper;
	else
		tool = toolSounder;

	// If the scene was imported, the sound will need to be resolved
	if (aevsnd.tag.sid == ksidUseCrf)
		{
		if (!_pscen->Pmvie()->FResolveSndTag(&aevsnd.tag, aevsnd.chid))
			{
			Bug("Actrsnd: Expected to resolve snd tag");
			goto LFail;
			}
		_pggaev->Put(iaev, &aevsnd);	// Update event
		}

 	pmsnd = (PMSND)vptagm->PbacoFetch(&aevsnd.tag, MSND::FReadMsnd);
	if (pvNil == pmsnd)
		goto LFail;

	if (!_pscen->Pmvie()->Pmsq()->FEnqueue(pmsnd, _arid, aevsnd.fLoop, aevsnd.fQueue,
		aevsnd.vlm, pmsnd->Spr(tool), fTrue))
		{
		goto LFail;
		}
	
	ReleasePpo(&pmsnd);
	return fTrue;

LFail:
	ReleasePpo(&pmsnd);
	return fFalse;
}


/***************************************************************************
	
	Play the motion match sounds appropriate to the current cel

***************************************************************************/
bool ACTR::_FEnqueueSmmInMsq(void)
{
	AssertThis(0);

	long celn;
	long ccel;
	long ismm;
	SMM *psmm;
	bool fSuccess = fTrue;
	PMSND pmsnd = pvNil;

	if (!_ptmpl->FGetCcelActn(_anidCur, &ccel))
		return fFalse;
	celn = _celnCur % ccel;

	for (ismm = 0; ismm < _pglsmm->IvMac(); ismm++)
		{
		psmm = (SMM *)(_pglsmm->QvGet(ismm));
		Assert(psmm->aevsnd.celn != smmNil, "Logic error in smm");
		if (psmm->aevsnd.celn != celn)
			{
			continue;
			}

		if (psmm->aevsnd.tag.sid == ksidUseCrf)
			{
			if (!_pscen->Pmvie()->FResolveSndTag(&psmm->aevsnd.tag, psmm->aevsnd.chid))
				{
				Bug("Actrsnd: Expected to resolve snd tag");
				goto LFail;
				}
			_pglsmm->Put(ismm, psmm);	// Update event
			}

		pmsnd = (PMSND)vptagm->PbacoFetch(&psmm->aevsnd.tag, MSND::FReadMsnd);
		if (pvNil == pmsnd)
			{
			fSuccess = fFalse;
			continue;
			}

	  	// Motion match sounds need to be entered at low priority as sounds of the
		// same type take precedence over them
		if (!_pscen->Pmvie()->Pmsq()->FEnqueue(pmsnd, _arid, psmm->aevsnd.fLoop,
			psmm->aevsnd.fQueue, psmm->aevsnd.vlm, pmsnd->Spr(toolMatcher), fTrue, 0, fTrue))
			{
			// Continuing would result in additional error
			goto LFail;
			}

		ReleasePpo(&pmsnd);
		}

	return fSuccess;
LFail:
	ReleasePpo(&pmsnd);
	return fFalse;
}


/***************************************************************************
	
	Insert a motion match sound in the smm queue

***************************************************************************/
bool ACTR::_FInsertSmm(long iaev)
{
	AssertThis(0);
	AssertIn(iaev, 0, _pggaev->IvMac());

	long ismm;
	SMM smm;
	SMM *psmm;
	AEV *paev;
	AEVSND *paevsnd;

	paev = (AEV *)_pggaev->QvFixedGet(iaev);
	paevsnd = (AEVSND *)_pggaev->QvGet(iaev);

	smm.aev = *paev;
	smm.aevsnd = *paevsnd;

	for (ismm = 0; ismm < _pglsmm->IvMac(); ismm++)
		{
		psmm = (SMM *)_pglsmm->QvGet(ismm);
		if (psmm->aevsnd.celn != paevsnd->celn)
			continue;
		if (psmm->aevsnd.sty != paevsnd->sty)
			continue;

		// Replace the current smm with the new
		_pglsmm->Put(ismm, &smm);
		return fTrue;
		}

	// No sound for this cel was found
	// Add a new mm sound
	return _pglsmm->FAdd(&smm);
}


/***************************************************************************
	
	Delete old motion sounds in event list

***************************************************************************/
bool ACTR::_FRemoveAevMm(long anid)
{
	AssertThis(0);

	long iaev;
	AEV *paev;
	AEVSND aevsnd;
	AEVACTN aevactn;

	// Remove motion match sounds from the previous action
	for (iaev = _iaevCur; iaev < _pggaev->IvMac(); iaev++)
		{
		paev = (AEV *)_pggaev->QvFixedGet(iaev);
		if (aetAdd == paev->aet)
			break;
		if (aetActn == paev->aet)
			{
			_pggaev->Get(iaev, &aevactn);
			if (aevactn.anid != anid)
				break;
			continue;
			}
		if (aetSnd != paev->aet)
			continue;

		// Test if sound is motion match
		_pggaev->Get(iaev, &aevsnd);
		if (smmNil == aevsnd.celn)
			continue;
		_RemoveAev(iaev);
		iaev--;
		}

	return fTrue;
}

/***************************************************************************
	
	Insert default motion match sounds in event list

***************************************************************************/
bool ACTR::_FAddAevDefMm(long anid)
{
	AssertThis(0);
	TAG tag;
	PMSND pmsnd;
	long iceln;
	long ccel;
	long vlm;
	long sty;
	bool fSoundExists;

	// Insert new motion match sounds
	if (!_ptmpl->FGetCcelActn(anid, &ccel))
		return fFalse;

	for (iceln = 0; iceln < ccel; iceln++)
		{
		if (!_ptmpl->FGetSndActnCel(anid, iceln, &fSoundExists, &tag))
			continue;		//Ignore failure
		if (!fSoundExists)
			continue;

		pmsnd = (PMSND)vptagm->PbacoFetch(&tag, MSND::FReadMsnd);
		if (pvNil == pmsnd)
			continue;  		//Ignore failure
	
		vlm = pmsnd->Vlm();
		sty = pmsnd->Sty();

		if (!FSetSndCore(&tag, fFalse, vlm, fFalse,	sty, fTrue))
			{
			goto LFail;		// Continuing pointless
			}

		ReleasePpo(&pmsnd);
		}

	 return fTrue;

LFail:
	ReleasePpo(&pmsnd);
	return fFalse;
}


/***************************************************************************
	
	Set the Volume for sounds in the current frame of the specified sty

***************************************************************************/
bool ACTR::FSetVlmSnd(long sty, bool fMotionMatch, long vlm)
{
	AssertThis(0);
	AssertIn(sty, 0, styLim);
	AssertIn(vlm, 0, kvlmFull + 1);

	AEVSND aevsnd;
	bool fActnThisFrame = fFalse;
	long celn;
	long ccel;
	long iaev;
	long ismm;
	AEV aev;
	SMM smm;
	long nfrmMM = ivNil;

	if (!_ptmpl->FGetCcelActn(_anidCur, &ccel))
		return fFalse;

	celn = _celnCur % ccel;

	// Set the volume for any events in the actor list for this frame
	for (iaev = _iaevFrmMin; iaev < _iaevCur; iaev++)
		{
		_pggaev->GetFixed(iaev, &aev);
		if (aev.aet == aetActn)
			fActnThisFrame = fTrue;

		if (aev.aet != aetSnd)
			continue;
		
		_pggaev->Get(iaev, &aevsnd);
		if (FPure(aevsnd.celn != smmNil) != fMotionMatch)
		   	continue;

		if (aevsnd.sty != sty)
			continue;
		aevsnd.vlm = vlm;
		_pggaev->Put(iaev, &aevsnd);		
		}

	// Set the volume for any earlier motion match sounds
	// which land in this cel
	if (fMotionMatch && !fActnThisFrame)
		{
		for (iaev = _iaevFrmMin - 1; iaev > 0; iaev--)
			{
			_pggaev->GetFixed(iaev, &aev);

			// Quit when the action changes
			if (aev.aet == aetActn || (nfrmMM != ivNil && nfrmMM > aev.nfrm))
				break;

			if (aev.aet != aetSnd)
				continue;
			_pggaev->Get(iaev, &aevsnd);

			if (aevsnd.sty != sty)
				continue;

			// Only adjust sounds that match this cel
			if (aevsnd.celn != celn)
				continue;
			aevsnd.vlm = vlm;
			_pggaev->Put(iaev, &aevsnd);
			nfrmMM = aev.nfrm;
			// There are no queued motion match sounds by spec
			break;
			}
		}
	
	if (fMotionMatch)
		{
		// Adjust the volume in the smm also
		for (ismm = 0; ismm < _pglsmm->IvMac(); ismm++)
			{
			_pglsmm->Get(ismm, &smm);
			Assert(smm.aevsnd.celn != smmNil, "Logic error in smm");

			if (smm.aevsnd.celn != celn)
				continue;
		
			if (smm.aevsnd.sty != sty)
				continue;

			// Set the volume in the smm
			smm.aevsnd.vlm = vlm;
			_pglsmm->Put(ismm, &smm);
			}
		}

	_pscen->MarkDirty();
	return fTrue;	
}


/***************************************************************************
	
	Query actor for current frame sounds

***************************************************************************/
bool ACTR::FQuerySnd(long sty, bool fMotionMatch, PGL *pglTagSnd, long *pvlm, bool *pfLoop)
{
	AssertThis(0);
	AssertIn(sty, 0, styLim);
	AssertVarMem(pvlm);
	AssertVarMem(pfLoop);

	PGL pgltag = pvNil;
	AEVSND aevsnd;
	long ccel;
	long celn;
	AEV aev;
	long iaev;
	long ismm;
	SMM smm;

	if (pvNil == (pgltag = GL::PglNew(size(TAG), kctagSndGrow)))
		return fFalse;
	pgltag->SetMinGrow(kctagSndGrow);

	if (!fMotionMatch)
		{
		// Non-motion match sounds
		for (iaev = _iaevFrmMin; iaev < _iaevCur; iaev++)
			{
			_pggaev->GetFixed(iaev, &aev);
			if (aev.aet != aetSnd)
				continue;
		
			_pggaev->Get(iaev, &aevsnd);
			if (aevsnd.sty != sty)
				continue;

			// Handle motion match sounds later
			if (aevsnd.celn != smmNil)
				continue;
			if (aevsnd.tag.sid == ksidUseCrf)
				{
				if (!_pscen->Pmvie()->FResolveSndTag(&aevsnd.tag, aevsnd.chid))
					goto LFail;
				}
			if (!pgltag->FAdd(&aevsnd.tag))
				goto LFail;
			*pvlm = aevsnd.vlm;
			*pfLoop = aevsnd.fLoop;
			}
		}

	if (fMotionMatch)
		{
		if (!_ptmpl->FGetCcelActn(_anidCur, &ccel))
			goto LFail;

		celn = _celnCur % ccel;

		// Motion match sounds
		for (ismm = 0; ismm < _pglsmm->IvMac(); ismm++)
			{
			_pglsmm->Get(ismm, &smm);
			if (smm.aevsnd.sty != sty)
				continue;
			if (smm.aevsnd.celn != celn)
				continue;
			if (smm.aevsnd.tag.sid == ksidUseCrf)
				{
				if (!_pscen->Pmvie()->FResolveSndTag(&smm.aevsnd.tag, smm.aevsnd.chid))
					goto LFail;
				}
			if (!pgltag->FAdd(&smm.aevsnd.tag))
				goto LFail;
			*pvlm = smm.aevsnd.vlm;
			*pfLoop = smm.aevsnd.fLoop;
			break;
			}
		}

	if (pgltag->IvMac() == 0)
		{
		ReleasePpo(&pgltag);
		*pglTagSnd = pvNil;
		return fTrue;
		}

	*pglTagSnd = pgltag;
	return fTrue;

LFail:
	ReleasePpo(&pgltag);
	return fFalse;

}


/***************************************************************************
	
	Delete a sound in this frame

***************************************************************************/
bool ACTR::FDeleteSndCore(long sty, bool fMotionMatch)
{
	AssertThis(0);
	AssertIn(sty, 0, styLim);

	AEVSND aevsnd;
	long iaevFirst;
	long iaev;
	long ismm;
	long ccel;
	long celn;
	AEV aev;
	SMM smm;
	long nfrmMM = ivNil;		// For motion match, this may be an earlier frame

	// First the actor event list
	if (!_ptmpl->FGetCcelActn(_anidCur, &ccel))
		return fFalse;
	celn = _celnCur % ccel;

	iaevFirst = (fMotionMatch) ? _iaevActnCur : _iaevFrmMin;
	for (iaev = _iaevCur - 1; iaev >= iaevFirst; iaev--)
		{
		_pggaev->GetFixed(iaev, &aev);
		if (fMotionMatch && nfrmMM != ivNil && nfrmMM > aev.nfrm)
			break;

		if (aev.aet != aetSnd)
			continue;
		
		_pggaev->Get(iaev, &aevsnd);
		if (aevsnd.sty != sty)
			continue;
 		if ((aevsnd.celn != smmNil) != fMotionMatch)
		   	continue;

		// Only delete the sound that match this cel
		if (fMotionMatch && aevsnd.celn != celn)
			continue;

		// Delete this sound & continue to remove any
		// other sounds which are possibly chained
		_RemoveAev(iaev);
		nfrmMM = aev.nfrm;
		}

	
	if (fMotionMatch)
		{
	  	// Also the motion match sound list : smm
		if (!_ptmpl->FGetCcelActn(_anidCur, &ccel))
			return fFalse;
		celn = _celnCur % ccel;

		// Motion match sounds
		for (ismm = 0; ismm < _pglsmm->IvMac(); ismm++)
			{
			_pglsmm->Get(ismm, &smm);
			if (smm.aevsnd.sty != sty)
				continue;
			if (smm.aevsnd.celn != celn)
				continue;
			_pglsmm->Delete(ismm);
			ismm--;
			}
		}

	_pscen->MarkDirty();
	return fTrue;
}


/******************************************************************************
	FSoundInFrm
		Enumerates all actor events for current frame looking for a sound
		event.
	
	Returns: fTrue if a sound event was found, fFalse otherwise
	
************************************************************ PETED ***********/
bool ACTR::FSoundInFrm(void)
{
	AssertThis(0);
	AssertPo(Pscen(), 0);

	/* Can't provide useful info if we're not at the current scene frame */
	if (Pscen()->Nfrm() != _nfrmCur)
		return fFalse;

	for (long iaev = _iaevFrmMin; iaev < _iaevCur; iaev++)
		{
		AEV aev;

		_pggaev->GetFixed(iaev, &aev);
		if (aev.aet == aetSnd)
			return fTrue;
		}
	return fFalse;
}

/******************************************************************************
	Resolve all sound tags
	
******************************************************************************/
bool ACTR::FResolveAllSndTags(CNO cnoScen)
{
	AssertThis(0);
	long iaev;
	AEV *paev;
	AEVSND aevsnd;
	bool fSuccess = fTrue;

	for (iaev = 0; iaev < _pggaev->IvMac(); iaev++)
		{
		paev = (AEV *)_pggaev->QvFixedGet(iaev);
		if (paev->aet != aetSnd)
			continue;
		_pggaev->Get(iaev, &aevsnd);
		if (aevsnd.tag.sid == ksidUseCrf)
			{
			if (!_pscen->Pmvie()->FResolveSndTag(&aevsnd.tag, aevsnd.chid, cnoScen))
				{
				fSuccess = fFalse;
				continue;
				}
			_pggaev->Put(iaev, &aevsnd);
			}
		}
	return fSuccess;
}