path: root/engine/audio/private/voice_sound_engine_interface.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "audio_pch.h"
#include <assert.h>
#include "voice.h"
#include "ivoicecodec.h"

#if defined( _X360 )
#include "xauddefs.h"
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

// ------------------------------------------------------------------------- //
// CAudioSourceVoice.
// This feeds the data from an incoming voice channel (a guy on the server
// who is speaking) into the sound engine.
// ------------------------------------------------------------------------- //

class CAudioSourceVoice : public CAudioSourceWave
{
public:
								CAudioSourceVoice(CSfxTable *pSfx, int iEntity);
								virtual ~CAudioSourceVoice();
	
	virtual int					GetType( void )
	{
		return AUDIO_SOURCE_VOICE;
	}
	virtual void				GetCacheData( CAudioSourceCachedInfo *info )
	{
		Assert( 0 );
	}


	virtual CAudioMixer			*CreateMixer( int initialStreamPosition = 0 );
	virtual int					GetOutputData( void **pData, int samplePosition, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] );
	virtual int					SampleRate( void );
	
	// Sample size is in bytes.  It will not be accurate for compressed audio.  This is a best estimate.
	// The compressed audio mixers understand this, but in general do not assume that SampleSize() * SampleCount() = filesize
	// or even that SampleSize() is 100% accurate due to compression.
	virtual int					SampleSize( void );

	// Total number of samples in this source.  NOTE: Some sources are infinite (mic input), they should return
	// a count equal to one second of audio at their current rate.
	virtual int					SampleCount( void );

	virtual bool				IsVoiceSource()				{return true;}

	virtual bool				IsLooped()					{return false;}
	virtual bool				IsStreaming()				{return true;}
	virtual bool				IsStereoWav()				{return false;}
	virtual int					GetCacheStatus()			{return AUDIO_IS_LOADED;}
	virtual void				CacheLoad()					{}
	virtual void				CacheUnload()				{}
	virtual CSentence			*GetSentence()				{return NULL;}

	virtual int					ZeroCrossingBefore( int sample )	{return sample;}
	virtual int					ZeroCrossingAfter( int sample )		{return sample;}
	
	// mixer's references
	virtual void				ReferenceAdd( CAudioMixer *pMixer );
	virtual void				ReferenceRemove( CAudioMixer *pMixer );

	// check reference count, return true if nothing is referencing this
	virtual bool				CanDelete();

	virtual void				Prefetch() {}

	// Nothing, not a cache object...
	virtual void				CheckAudioSourceCache() {} 

private:

	class CWaveDataVoice : public IWaveData
	{
	public:
							CWaveDataVoice( CAudioSourceWave &source ) : m_source(source) {}
							~CWaveDataVoice( void ) {}

		virtual CAudioSource &Source( void )
		{
			return m_source;
		}
		
		// this file is in memory, simply pass along the data request to the source
		virtual int ReadSourceData( void **pData, int sampleIndex, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] )
		{
			return m_source.GetOutputData( pData, sampleIndex, sampleCount, copyBuf );
		}

		virtual bool IsReadyToMix() 
		{ 
			return true; 
		}

	private:
		CAudioSourceWave		&m_source;	// pointer to source
	};


private:
	CAudioSourceVoice( const CAudioSourceVoice & );

	// Which entity's voice this is for.
	int							m_iChannel;
	
	// How many mixers are referencing us.
	int							m_refCount;
};



// ----------------------------------------------------------------------------- //
// Globals.
// ----------------------------------------------------------------------------- //

// The format we sample voice in.
extern WAVEFORMATEX g_VoiceSampleFormat;

class CVoiceSfx : public CSfxTable
{
public:
	virtual const char *getname()
	{
		return "?VoiceSfx";
	}
};

static CVoiceSfx g_CVoiceSfx[VOICE_NUM_CHANNELS];

static float	g_VoiceOverdriveDuration = 0;
static bool		g_bVoiceOverdriveOn = false;

// When voice is on, all other sounds are decreased by this factor.
static ConVar voice_overdrive( "voice_overdrive", "2" );
static ConVar voice_overdrivefadetime( "voice_overdrivefadetime", "0.4" ); // How long it takes to fade in and out of the voice overdrive.

// The sound engine uses this to lower all sound volumes.
// All non-voice sounds are multiplied by this and divided by 256.
int g_SND_VoiceOverdriveInt = 256;


extern int Voice_SamplesPerSec();
extern int Voice_AvgBytesPerSec();

// ----------------------------------------------------------------------------- //
// CAudioSourceVoice implementation.
// ----------------------------------------------------------------------------- //

CAudioSourceVoice::CAudioSourceVoice( CSfxTable *pSfx, int iChannel )
	: CAudioSourceWave( pSfx )
{
	m_iChannel = iChannel;
	m_refCount = 0;

	WAVEFORMATEX tmp = g_VoiceSampleFormat;
	tmp.nSamplesPerSec = Voice_SamplesPerSec();
	tmp.nAvgBytesPerSec = Voice_AvgBytesPerSec();
	Init((char*)&tmp, sizeof(tmp));
	m_sampleCount = tmp.nSamplesPerSec;
}

CAudioSourceVoice::~CAudioSourceVoice()
{
	Voice_OnAudioSourceShutdown( m_iChannel );
}

CAudioMixer *CAudioSourceVoice::CreateMixer( int initialStreamPosition )
{
	CWaveDataVoice *pVoice = new CWaveDataVoice(*this);
	if(!pVoice)
		return NULL;

	CAudioMixer *pMixer = CreateWaveMixer( pVoice, WAVE_FORMAT_PCM, 1, BYTES_PER_SAMPLE*8, 0 );
	if(!pMixer)
	{
		delete pVoice;
		return NULL;
	}

	return pMixer;
}

int CAudioSourceVoice::GetOutputData( void **pData, int samplePosition, int sampleCount, char copyBuf[AUDIOSOURCE_COPYBUF_SIZE] )
{
	int nSamplesGotten = Voice_GetOutputData(
		m_iChannel,
		copyBuf,
		AUDIOSOURCE_COPYBUF_SIZE,
		samplePosition,
		sampleCount );
	
	// If there weren't enough bytes in the received data channel, pad it with zeros.
	if( nSamplesGotten < sampleCount )
	{
		memset( &copyBuf[nSamplesGotten], 0, (sampleCount - nSamplesGotten) * BYTES_PER_SAMPLE );
		nSamplesGotten = sampleCount;
	}

	*pData = copyBuf;
	return nSamplesGotten;
}

int CAudioSourceVoice::SampleRate()
{
	return Voice_SamplesPerSec();
}

int CAudioSourceVoice::SampleSize()
{
	return BYTES_PER_SAMPLE;
}

int CAudioSourceVoice::SampleCount()
{
	return Voice_SamplesPerSec();
}

void CAudioSourceVoice::ReferenceAdd(CAudioMixer *pMixer)
{
	m_refCount++;
}

void CAudioSourceVoice::ReferenceRemove(CAudioMixer *pMixer)
{
	m_refCount--;
	if ( m_refCount <= 0 )
		delete this;
}

bool CAudioSourceVoice::CanDelete()
{
	return m_refCount == 0;
}


// ----------------------------------------------------------------------------- //
// Interface implementation.
// ----------------------------------------------------------------------------- //

bool VoiceSE_Init()
{
	if( !snd_initialized )
		return false;

	g_SND_VoiceOverdriveInt = 256;
	return true;
}

void VoiceSE_Term()
{
	// Disable voice ducking.
	g_SND_VoiceOverdriveInt = 256;
}


void VoiceSE_Idle(float frametime)
{
	g_SND_VoiceOverdriveInt = 256;

	if( g_bVoiceOverdriveOn )
	{
		g_VoiceOverdriveDuration = min( g_VoiceOverdriveDuration+frametime, voice_overdrivefadetime.GetFloat() );
	}
	else
	{
		if(g_VoiceOverdriveDuration == 0)
			return;

		g_VoiceOverdriveDuration = max(g_VoiceOverdriveDuration-frametime, 0.f);
	}

	float percent = g_VoiceOverdriveDuration / voice_overdrivefadetime.GetFloat();
	percent = (float)(-cos(percent * 3.1415926535) * 0.5 + 0.5);		// Smooth it out..
	float voiceOverdrive = 1 + (voice_overdrive.GetFloat() - 1) * percent;
	g_SND_VoiceOverdriveInt = (int)(256 / voiceOverdrive);
}


int VoiceSE_StartChannel(
	int iChannel,	//! Which channel to start.
	int iEntity,
	bool bProximity,
	int nViewEntityIndex )
{
	Assert( iChannel >= 0 && iChannel < VOICE_NUM_CHANNELS );

	// Start the sound.
	CSfxTable *sfx = &g_CVoiceSfx[iChannel];
	sfx->pSource = NULL;
	Vector vOrigin(0,0,0);

	StartSoundParams_t params;
	params.staticsound = false;
	params.entchannel = (CHAN_VOICE_BASE+iChannel);
	params.pSfx = sfx;
	params.origin = vOrigin;
	params.fvol = 1.0f;
	params.flags = 0;
	params.pitch = PITCH_NORM;


	if ( bProximity == true )
	{
		params.bUpdatePositions = true;
		params.soundlevel = SNDLVL_TALKING;
		params.soundsource = iEntity;
	}
	else
	{
		params.soundlevel = SNDLVL_IDLE;
		params.soundsource = nViewEntityIndex;
	}


	return S_StartSound( params );
}

void VoiceSE_EndChannel(
	int iChannel,	//! Which channel to stop.
	int iEntity
	)
{
	Assert( iChannel >= 0 && iChannel < VOICE_NUM_CHANNELS );

	S_StopSound( iEntity, CHAN_VOICE_BASE+iChannel );

	// Start the sound.
	CSfxTable *sfx = &g_CVoiceSfx[iChannel];
	sfx->pSource = NULL;
}

void VoiceSE_StartOverdrive()
{
	g_bVoiceOverdriveOn = true;
}

void VoiceSE_EndOverdrive()
{
	g_bVoiceOverdriveOn = false;
}


void VoiceSE_InitMouth(int entnum)
{
}

void VoiceSE_CloseMouth(int entnum)
{
}

void VoiceSE_MoveMouth(int entnum, short *pSamples, int nSamples)
{
}


CAudioSource* Voice_SetupAudioSource( int soundsource, int entchannel )
{
	int iChannel = entchannel - CHAN_VOICE_BASE;
	if( iChannel >= 0 && iChannel < VOICE_NUM_CHANNELS )
	{
		CSfxTable *sfx = &g_CVoiceSfx[iChannel];
		return new CAudioSourceVoice( sfx, iChannel );
	}
	else
		return NULL;
}