1567 lines
41 KiB
C++
1567 lines
41 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "audio_pch.h"
|
|
#include "circularbuffer.h"
|
|
#include "voice.h"
|
|
#include "voice_wavefile.h"
|
|
#include "r_efx.h"
|
|
#include "cdll_int.h"
|
|
#include "voice_gain.h"
|
|
#include "voice_mixer_controls.h"
|
|
|
|
#include "ivoicerecord.h"
|
|
#include "ivoicecodec.h"
|
|
#include "filesystem.h"
|
|
#include "../../filesystem_engine.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#if defined( _X360 )
|
|
#include "xauddefs.h"
|
|
#endif
|
|
|
|
#include "steam/steam_api.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
static CSteamAPIContext g_SteamAPIContext;
|
|
static CSteamAPIContext *steamapicontext = NULL;
|
|
|
|
void Voice_EndChannel( int iChannel );
|
|
void VoiceTweak_EndVoiceTweakMode();
|
|
void EngineTool_OverrideSampleRate( int& rate );
|
|
|
|
// A fallback codec that should be the most likely to work for local/offline use
|
|
#define VOICE_FALLBACK_CODEC "vaudio_celt"
|
|
|
|
// Special entity index used for tweak mode.
|
|
#define TWEAKMODE_ENTITYINDEX -500
|
|
|
|
// Special channel index passed to Voice_AddIncomingData when in tweak mode.
|
|
#define TWEAKMODE_CHANNELINDEX -100
|
|
|
|
|
|
// How long does the sign stay above someone's head when they talk?
|
|
#define SPARK_TIME 0.2
|
|
|
|
// How long a voice channel has to be inactive before we free it.
|
|
#define DIE_COUNTDOWN 0.5
|
|
|
|
#define VOICE_RECEIVE_BUFFER_SIZE (VOICE_OUTPUT_SAMPLE_RATE_MAX * BYTES_PER_SAMPLE)
|
|
|
|
#define LOCALPLAYERTALKING_TIMEOUT 0.2f // How long it takes for the client to decide the server isn't sending acks
|
|
// of voice data back.
|
|
|
|
// If this is defined, then the data is converted to 8-bit and sent otherwise uncompressed.
|
|
// #define VOICE_SEND_RAW_TEST
|
|
|
|
// The format we sample voice in.
|
|
WAVEFORMATEX g_VoiceSampleFormat =
|
|
{
|
|
WAVE_FORMAT_PCM, // wFormatTag
|
|
1, // nChannels
|
|
// These two can be dynamically changed by voice_init
|
|
VOICE_OUTPUT_SAMPLE_RATE_LOW, // nSamplesPerSec
|
|
VOICE_OUTPUT_SAMPLE_RATE_LOW*2, // nAvgBytesPerSec
|
|
2, // nBlockAlign
|
|
16, // wBitsPerSample
|
|
sizeof(WAVEFORMATEX) // cbSize
|
|
};
|
|
|
|
static bool Voice_SetSampleRate( DWORD rate )
|
|
{
|
|
if ( g_VoiceSampleFormat.nSamplesPerSec != rate ||
|
|
g_VoiceSampleFormat.nAvgBytesPerSec != rate * 2 )
|
|
{
|
|
g_VoiceSampleFormat.nSamplesPerSec = rate;
|
|
g_VoiceSampleFormat.nAvgBytesPerSec = rate * 2;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int Voice_SamplesPerSec()
|
|
{
|
|
int rate = g_VoiceSampleFormat.nSamplesPerSec;
|
|
EngineTool_OverrideSampleRate( rate );
|
|
return rate;
|
|
}
|
|
|
|
int Voice_AvgBytesPerSec()
|
|
{
|
|
int rate = g_VoiceSampleFormat.nSamplesPerSec;
|
|
EngineTool_OverrideSampleRate( rate );
|
|
return ( rate * g_VoiceSampleFormat.wBitsPerSample ) >> 3;
|
|
}
|
|
|
|
ConVar voice_avggain( "voice_avggain", "0.5" );
|
|
ConVar voice_maxgain( "voice_maxgain", "10" );
|
|
ConVar voice_scale( "voice_scale", "1", FCVAR_ARCHIVE );
|
|
|
|
ConVar voice_loopback( "voice_loopback", "0", FCVAR_USERINFO );
|
|
ConVar voice_fadeouttime( "voice_fadeouttime", "0.1" ); // It fades to no sound at the tail end of your voice data when you release the key.
|
|
|
|
// Debugging cvars.
|
|
ConVar voice_profile( "voice_profile", "0" );
|
|
ConVar voice_showchannels( "voice_showchannels", "0" ); // 1 = list channels
|
|
// 2 = show timing info, etc
|
|
ConVar voice_showincoming( "voice_showincoming", "0" ); // show incoming voice data
|
|
|
|
ConVar voice_enable( "voice_enable", "1", FCVAR_ARCHIVE ); // Globally enable or disable voice.
|
|
#ifdef VOICE_VOX_ENABLE
|
|
ConVar voice_threshold( "voice_threshold", "2000", FCVAR_ARCHIVE );
|
|
#endif // VOICE_VOX_ENABLE
|
|
|
|
// Have it force your mixer control settings so waveIn comes from the microphone.
|
|
// CD rippers change your waveIn to come from the CD drive
|
|
ConVar voice_forcemicrecord( "voice_forcemicrecord", "1", FCVAR_ARCHIVE );
|
|
|
|
// This should not be lower than the maximum difference between clients' frame durations (due to cmdrate/updaterate),
|
|
// plus some jitter allowance.
|
|
ConVar voice_buffer_ms( "voice_buffer_ms", "100", FCVAR_INTERNAL_USE,
|
|
"How many milliseconds of voice to buffer to avoid dropouts due to jitter and frame time differences." );
|
|
|
|
int g_nVoiceFadeSamples = 1; // Calculated each frame from the cvar.
|
|
float g_VoiceFadeMul = 1; // 1 / (g_nVoiceFadeSamples - 1).
|
|
|
|
// While in tweak mode, you can't hear anything anyone else is saying, and your own voice data
|
|
// goes directly to the speakers.
|
|
bool g_bInTweakMode = false;
|
|
int g_VoiceTweakSpeakingVolume = 0;
|
|
|
|
bool g_bVoiceAtLeastPartiallyInitted = false;
|
|
|
|
// The codec and sample rate passed to Voice_Init. "" and -1 if voice is not initialized
|
|
char g_szVoiceCodec[_MAX_PATH] = { 0 };
|
|
int g_nVoiceRequestedSampleRate = -1;
|
|
|
|
const char *Voice_ConfiguredCodec() { return g_szVoiceCodec; }
|
|
int Voice_ConfiguredSampleRate() { return g_nVoiceRequestedSampleRate; }
|
|
|
|
// Timing info for each frame.
|
|
static double g_CompressTime = 0;
|
|
static double g_DecompressTime = 0;
|
|
static double g_GainTime = 0;
|
|
static double g_UpsampleTime = 0;
|
|
|
|
class CVoiceTimer
|
|
{
|
|
public:
|
|
inline void Start()
|
|
{
|
|
if( voice_profile.GetInt() )
|
|
{
|
|
m_StartTime = Plat_FloatTime();
|
|
}
|
|
}
|
|
|
|
inline void End(double *out)
|
|
{
|
|
if( voice_profile.GetInt() )
|
|
{
|
|
*out += Plat_FloatTime() - m_StartTime;
|
|
}
|
|
}
|
|
|
|
double m_StartTime;
|
|
};
|
|
|
|
|
|
static bool g_bLocalPlayerTalkingAck = false;
|
|
static float g_LocalPlayerTalkingTimeout = 0;
|
|
|
|
|
|
CSysModule *g_hVoiceCodecDLL = 0;
|
|
|
|
// Voice recorder. Can be waveIn, DSound, or whatever.
|
|
static IVoiceRecord *g_pVoiceRecord = NULL;
|
|
static IVoiceCodec *g_pEncodeCodec = NULL;
|
|
|
|
static bool g_bVoiceRecording = false; // Are we recording at the moment?
|
|
static bool g_bVoiceRecordStopping = false; // Are we waiting to stop?
|
|
bool g_bUsingSteamVoice = false;
|
|
|
|
#ifdef WIN32
|
|
extern IVoiceRecord* CreateVoiceRecord_DSound(int nSamplesPerSec);
|
|
#elif defined( OSX )
|
|
extern IVoiceRecord* CreateVoiceRecord_AudioQueue(int sampleRate);
|
|
#endif
|
|
|
|
#ifdef POSIX
|
|
extern IVoiceRecord* CreateVoiceRecord_OpenAL(int sampleRate);
|
|
#endif
|
|
|
|
|
|
static bool VoiceRecord_Start()
|
|
{
|
|
if ( g_bUsingSteamVoice )
|
|
{
|
|
if ( steamapicontext && steamapicontext->SteamUser() )
|
|
{
|
|
steamapicontext->SteamUser()->StartVoiceRecording();
|
|
return true;
|
|
}
|
|
}
|
|
else if ( g_pVoiceRecord )
|
|
{
|
|
return g_pVoiceRecord->RecordStart();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void VoiceRecord_Stop()
|
|
{
|
|
if ( g_bUsingSteamVoice )
|
|
{
|
|
if ( steamapicontext && steamapicontext->SteamUser() )
|
|
{
|
|
steamapicontext->SteamUser()->StopVoiceRecording();
|
|
}
|
|
}
|
|
else if ( g_pVoiceRecord )
|
|
{
|
|
return g_pVoiceRecord->RecordStop();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Used for storing incoming voice data from an entity.
|
|
//
|
|
class CVoiceChannel
|
|
{
|
|
public:
|
|
CVoiceChannel();
|
|
|
|
// Called when someone speaks and a new voice channel is setup to hold the data.
|
|
void Init(int nEntity);
|
|
|
|
public:
|
|
int m_iEntity; // Number of the entity speaking on this channel (index into cl_entities).
|
|
// This is -1 when the channel is unused.
|
|
|
|
|
|
CSizedCircularBuffer
|
|
<VOICE_RECEIVE_BUFFER_SIZE> m_Buffer; // Circular buffer containing the voice data.
|
|
|
|
// Used for upsampling..
|
|
double m_LastFraction; // Fraction between m_LastSample and the next sample.
|
|
short m_LastSample;
|
|
|
|
bool m_bStarved; // Set to true when the channel runs out of data for the mixer.
|
|
// The channel is killed at that point.
|
|
|
|
float m_TimePad; // Set to TIME_PADDING when the first voice packet comes in from a sender.
|
|
// We add time padding (for frametime differences)
|
|
// by waiting a certain amount of time before starting to output the sound.
|
|
|
|
IVoiceCodec *m_pVoiceCodec; // Each channel gets is own IVoiceCodec instance so the codec can maintain state.
|
|
|
|
CAutoGain m_AutoGain; // Gain we're applying to this channel
|
|
|
|
CVoiceChannel *m_pNext;
|
|
|
|
bool m_bProximity;
|
|
int m_nViewEntityIndex;
|
|
int m_nSoundGuid;
|
|
};
|
|
|
|
|
|
CVoiceChannel::CVoiceChannel()
|
|
{
|
|
m_iEntity = -1;
|
|
m_pVoiceCodec = NULL;
|
|
m_nViewEntityIndex = -1;
|
|
m_nSoundGuid = -1;
|
|
}
|
|
|
|
void CVoiceChannel::Init(int nEntity)
|
|
{
|
|
m_iEntity = nEntity;
|
|
m_bStarved = false;
|
|
m_Buffer.Flush();
|
|
m_TimePad = Clamp( voice_buffer_ms.GetFloat(), 1.f, 5000.f ) / 1000.f;
|
|
m_LastSample = 0;
|
|
m_LastFraction = 0.999;
|
|
|
|
m_AutoGain.Reset( 128, voice_maxgain.GetFloat(), voice_avggain.GetFloat(), voice_scale.GetFloat() );
|
|
}
|
|
|
|
|
|
|
|
// Incoming voice channels.
|
|
CVoiceChannel g_VoiceChannels[VOICE_NUM_CHANNELS];
|
|
|
|
|
|
// These are used for recording the wave data into files for debugging.
|
|
#define MAX_WAVEFILEDATA_LEN 1024*1024
|
|
char *g_pUncompressedFileData = NULL;
|
|
int g_nUncompressedDataBytes = 0;
|
|
const char *g_pUncompressedDataFilename = NULL;
|
|
|
|
char *g_pDecompressedFileData = NULL;
|
|
int g_nDecompressedDataBytes = 0;
|
|
const char *g_pDecompressedDataFilename = NULL;
|
|
|
|
char *g_pMicInputFileData = NULL;
|
|
int g_nMicInputFileBytes = 0;
|
|
int g_CurMicInputFileByte = 0;
|
|
double g_MicStartTime;
|
|
|
|
static ConVar voice_writevoices( "voice_writevoices", "0", 0, "Saves each speaker's voice data into separate .wav files\n" );
|
|
class CVoiceWriterData
|
|
{
|
|
public:
|
|
CVoiceWriterData() :
|
|
m_pChannel( NULL ),
|
|
m_nCount( 0 ),
|
|
m_Buffer()
|
|
{
|
|
}
|
|
|
|
// Copy ctor is needed to insert into CVoiceWriter's CUtlRBTree.
|
|
CVoiceWriterData(const CVoiceWriterData& other) :
|
|
m_pChannel( other.m_pChannel ),
|
|
m_nCount( other.m_nCount ),
|
|
m_Buffer( )
|
|
{
|
|
m_Buffer.CopyBuffer( other.m_Buffer );
|
|
}
|
|
|
|
static bool Less( const CVoiceWriterData &lhs, const CVoiceWriterData &rhs )
|
|
{
|
|
return lhs.m_pChannel < rhs.m_pChannel;
|
|
}
|
|
|
|
CVoiceChannel *m_pChannel;
|
|
int m_nCount;
|
|
CUtlBuffer m_Buffer;
|
|
|
|
private:
|
|
CVoiceWriterData& operator=(const CVoiceWriterData&);
|
|
};
|
|
|
|
class CVoiceWriter
|
|
{
|
|
public:
|
|
CVoiceWriter() :
|
|
m_VoiceWriter( 0, 0, CVoiceWriterData::Less )
|
|
{
|
|
}
|
|
|
|
void Flush()
|
|
{
|
|
for ( int i = m_VoiceWriter.FirstInorder(); i != m_VoiceWriter.InvalidIndex(); i = m_VoiceWriter.NextInorder( i ) )
|
|
{
|
|
CVoiceWriterData *data = &m_VoiceWriter[ i ];
|
|
|
|
if ( data->m_Buffer.TellPut() <= 0 )
|
|
continue;
|
|
data->m_Buffer.Purge();
|
|
}
|
|
}
|
|
|
|
void Finish()
|
|
{
|
|
if ( !g_pSoundServices->IsConnected() )
|
|
{
|
|
Flush();
|
|
return;
|
|
}
|
|
|
|
for ( int i = m_VoiceWriter.FirstInorder(); i != m_VoiceWriter.InvalidIndex(); i = m_VoiceWriter.NextInorder( i ) )
|
|
{
|
|
CVoiceWriterData *data = &m_VoiceWriter[ i ];
|
|
|
|
if ( data->m_Buffer.TellPut() <= 0 )
|
|
continue;
|
|
|
|
int index = data->m_pChannel - g_VoiceChannels;
|
|
Assert( index >= 0 && index < (int)ARRAYSIZE( g_VoiceChannels ) );
|
|
|
|
char path[ MAX_PATH ];
|
|
Q_snprintf( path, sizeof( path ), "%s/voice", g_pSoundServices->GetGameDir() );
|
|
g_pFileSystem->CreateDirHierarchy( path );
|
|
|
|
char fn[ MAX_PATH ];
|
|
Q_snprintf( fn, sizeof( fn ), "%s/pl%02d_slot%d-time%d.wav", path, index, data->m_nCount, (int)g_pSoundServices->GetClientTime() );
|
|
|
|
WriteWaveFile( fn, (const char *)data->m_Buffer.Base(), data->m_Buffer.TellPut(), g_VoiceSampleFormat.wBitsPerSample, g_VoiceSampleFormat.nChannels, Voice_SamplesPerSec() );
|
|
|
|
Msg( "Writing file %s\n", fn );
|
|
|
|
++data->m_nCount;
|
|
data->m_Buffer.Purge();
|
|
}
|
|
}
|
|
|
|
|
|
void AddDecompressedData( CVoiceChannel *ch, const byte *data, size_t datalen )
|
|
{
|
|
if ( !voice_writevoices.GetBool() )
|
|
return;
|
|
|
|
CVoiceWriterData search;
|
|
search.m_pChannel = ch;
|
|
int idx = m_VoiceWriter.Find( search );
|
|
if ( idx == m_VoiceWriter.InvalidIndex() )
|
|
{
|
|
idx = m_VoiceWriter.Insert( search );
|
|
}
|
|
|
|
CVoiceWriterData *slot = &m_VoiceWriter[ idx ];
|
|
slot->m_Buffer.Put( data, datalen );
|
|
}
|
|
private:
|
|
|
|
CUtlRBTree< CVoiceWriterData > m_VoiceWriter;
|
|
};
|
|
|
|
static CVoiceWriter g_VoiceWriter;
|
|
|
|
inline void ApplyFadeToSamples(short *pSamples, int nSamples, int fadeOffset, float fadeMul)
|
|
{
|
|
for(int i=0; i < nSamples; i++)
|
|
{
|
|
float percent = (i+fadeOffset) * fadeMul;
|
|
pSamples[i] = (short)(pSamples[i] * (1 - percent));
|
|
}
|
|
}
|
|
|
|
|
|
bool Voice_Enabled( void )
|
|
{
|
|
return voice_enable.GetBool();
|
|
}
|
|
|
|
|
|
int Voice_GetOutputData(
|
|
const int iChannel, //! The voice channel it wants samples from.
|
|
char *copyBufBytes, //! The buffer to copy the samples into.
|
|
const int copyBufSize, //! Maximum size of copyBuf.
|
|
const int samplePosition, //! Which sample to start at.
|
|
const int sampleCount //! How many samples to get.
|
|
)
|
|
{
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[iChannel];
|
|
short *pCopyBuf = (short*)copyBufBytes;
|
|
|
|
|
|
int maxOutSamples = copyBufSize / BYTES_PER_SAMPLE;
|
|
|
|
// Find out how much we want and get it from the received data channel.
|
|
CCircularBuffer *pBuffer = &pChannel->m_Buffer;
|
|
int nBytesToRead = pBuffer->GetReadAvailable();
|
|
nBytesToRead = min(min(nBytesToRead, (int)maxOutSamples), sampleCount * BYTES_PER_SAMPLE);
|
|
int nSamplesGotten = pBuffer->Read(pCopyBuf, nBytesToRead) / BYTES_PER_SAMPLE;
|
|
|
|
// Are we at the end of the buffer's data? If so, fade data to silence so it doesn't clip.
|
|
int readSamplesAvail = pBuffer->GetReadAvailable() / BYTES_PER_SAMPLE;
|
|
if(readSamplesAvail < g_nVoiceFadeSamples)
|
|
{
|
|
int bufferFadeOffset = max((readSamplesAvail + nSamplesGotten) - g_nVoiceFadeSamples, 0);
|
|
int globalFadeOffset = max(g_nVoiceFadeSamples - (readSamplesAvail + nSamplesGotten), 0);
|
|
|
|
ApplyFadeToSamples(
|
|
&pCopyBuf[bufferFadeOffset],
|
|
nSamplesGotten - bufferFadeOffset,
|
|
globalFadeOffset,
|
|
g_VoiceFadeMul);
|
|
}
|
|
|
|
// If there weren't enough samples in the received data channel,
|
|
// pad it with a copy of the most recent data, and if there
|
|
// isn't any, then use zeros.
|
|
if ( nSamplesGotten < sampleCount )
|
|
{
|
|
int wantedSampleCount = min( sampleCount, maxOutSamples );
|
|
int nAdditionalNeeded = (wantedSampleCount - nSamplesGotten);
|
|
if ( nSamplesGotten > 0 )
|
|
{
|
|
short *dest = (short *)&pCopyBuf[ nSamplesGotten ];
|
|
int nSamplesToDuplicate = min( nSamplesGotten, nAdditionalNeeded );
|
|
const short *src = (short *)&pCopyBuf[ nSamplesGotten - nSamplesToDuplicate ];
|
|
|
|
Q_memcpy( dest, src, nSamplesToDuplicate * BYTES_PER_SAMPLE );
|
|
|
|
//Msg( "duplicating %d samples\n", nSamplesToDuplicate );
|
|
|
|
nAdditionalNeeded -= nSamplesToDuplicate;
|
|
if ( nAdditionalNeeded > 0 )
|
|
{
|
|
dest = (short *)&pCopyBuf[ nSamplesGotten + nSamplesToDuplicate ];
|
|
Q_memset(dest, 0, nAdditionalNeeded * BYTES_PER_SAMPLE);
|
|
|
|
// Msg( "zeroing %d samples\n", nAdditionalNeeded );
|
|
|
|
Assert( ( nAdditionalNeeded + nSamplesGotten + nSamplesToDuplicate ) == wantedSampleCount );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Q_memset( &pCopyBuf[ nSamplesGotten ], 0, nAdditionalNeeded * BYTES_PER_SAMPLE );
|
|
}
|
|
nSamplesGotten = wantedSampleCount;
|
|
}
|
|
|
|
// If the buffer is out of data, mark this channel to go away.
|
|
if(pBuffer->GetReadAvailable() == 0)
|
|
{
|
|
pChannel->m_bStarved = true;
|
|
}
|
|
|
|
if(voice_showchannels.GetInt() >= 2)
|
|
{
|
|
Msg("Voice - mixed %d samples from channel %d\n", nSamplesGotten, iChannel);
|
|
}
|
|
|
|
VoiceSE_MoveMouth(pChannel->m_iEntity, (short*)copyBufBytes, nSamplesGotten);
|
|
return nSamplesGotten;
|
|
}
|
|
|
|
|
|
void Voice_OnAudioSourceShutdown( int iChannel )
|
|
{
|
|
Voice_EndChannel( iChannel );
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------ //
|
|
// Internal stuff.
|
|
// ------------------------------------------------------------------------ //
|
|
|
|
CVoiceChannel* GetVoiceChannel(int iChannel, bool bAssert=true)
|
|
{
|
|
if(iChannel < 0 || iChannel >= VOICE_NUM_CHANNELS)
|
|
{
|
|
if(bAssert)
|
|
{
|
|
Assert(false);
|
|
}
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
return &g_VoiceChannels[iChannel];
|
|
}
|
|
}
|
|
|
|
// Helper for doing a default-init with some codec if we weren't passed specific parameters
|
|
bool Voice_InitWithDefault( const char *pCodecName )
|
|
{
|
|
if ( !pCodecName || !*pCodecName )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int nRate = Voice_GetDefaultSampleRate( pCodecName );
|
|
if ( nRate < 0 )
|
|
{
|
|
Msg( "Voice_InitWithDefault: Unable to determine defaults for codec \"%s\"\n", pCodecName );
|
|
return false;
|
|
}
|
|
|
|
return Voice_Init( pCodecName, Voice_GetDefaultSampleRate( pCodecName ) );
|
|
}
|
|
|
|
bool Voice_Init( const char *pCodecName, int nSampleRate )
|
|
{
|
|
if ( voice_enable.GetInt() == 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( !pCodecName || !pCodecName[0] )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool bSpeex = Q_stricmp( pCodecName, "vaudio_speex" ) == 0;
|
|
bool bCelt = Q_stricmp( pCodecName, "vaudio_celt" ) == 0;
|
|
bool bSteam = Q_stricmp( pCodecName, "steam" ) == 0;
|
|
// Miles has not been in use for voice in a long long time. Not worth the surface to support ancient demos that may
|
|
// use it (and probably do not work for other reasons)
|
|
// "vaudio_miles"
|
|
|
|
if ( !( bSpeex || bCelt || bSteam ) )
|
|
{
|
|
Msg( "Voice_Init Failed: invalid voice codec %s.\n", pCodecName );
|
|
return false;
|
|
}
|
|
|
|
Voice_Deinit();
|
|
|
|
g_bVoiceAtLeastPartiallyInitted = true;
|
|
V_strncpy( g_szVoiceCodec, pCodecName, sizeof(g_szVoiceCodec) );
|
|
g_nVoiceRequestedSampleRate = nSampleRate;
|
|
|
|
g_bUsingSteamVoice = bSteam;
|
|
|
|
if ( !steamapicontext )
|
|
{
|
|
steamapicontext = &g_SteamAPIContext;
|
|
steamapicontext->Init();
|
|
}
|
|
|
|
if ( g_bUsingSteamVoice )
|
|
{
|
|
if ( !steamapicontext->SteamFriends() || !steamapicontext->SteamUser() )
|
|
{
|
|
Msg( "Voice_Init: Requested Steam voice, but cannot access API. Voice will not function\n" );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// For steam, nSampleRate 0 means "use optimal steam sample rate".
|
|
if ( bSteam && nSampleRate == 0 )
|
|
{
|
|
Msg( "Voice_Init: Using Steam voice optimal sample rate %d\n",
|
|
steamapicontext->SteamUser()->GetVoiceOptimalSampleRate() );
|
|
// Steam's sample rate may change and not be supported by our rather unflexible sound engine. However, steam
|
|
// will resample as necessary in DecompressVoice, so we can pretend we're outputting at native rates.
|
|
//
|
|
// Behind the scenes, we'll request steam give us the encoded stream at its "optimal" rate, then we'll try to
|
|
// decompress the output at this rate, making it transparent to us that the encoded stream is not at our output
|
|
// rate.
|
|
Voice_SetSampleRate( SOUND_DMA_SPEED );
|
|
}
|
|
else
|
|
{
|
|
Voice_SetSampleRate( nSampleRate );
|
|
}
|
|
|
|
if(!VoiceSE_Init())
|
|
return false;
|
|
|
|
// Get the voice input device.
|
|
#ifdef OSX
|
|
g_pVoiceRecord = CreateVoiceRecord_AudioQueue( Voice_SamplesPerSec() );
|
|
if ( !g_pVoiceRecord )
|
|
{
|
|
// Fall back to OpenAL
|
|
g_pVoiceRecord = CreateVoiceRecord_OpenAL( Voice_SamplesPerSec() );
|
|
}
|
|
#elif defined( WIN32 )
|
|
g_pVoiceRecord = CreateVoiceRecord_DSound( Voice_SamplesPerSec() );
|
|
#else
|
|
g_pVoiceRecord = CreateVoiceRecord_OpenAL( Voice_SamplesPerSec() );
|
|
#endif
|
|
|
|
if( !g_pVoiceRecord )
|
|
{
|
|
Msg( "Unable to initialize sound capture. You won't be able to speak to other players." );
|
|
}
|
|
|
|
// Init codec DLL for non-steam
|
|
if ( !bSteam )
|
|
{
|
|
// CELT's qualities are 0-3, we historically just passed 4 to the other two even though they don't really map to the
|
|
// same thing.
|
|
//
|
|
// Changing the quality level we use here will require either extending SVC_VoiceInit to pass down which quality is
|
|
// in use or using a different codec name (vaudio_celtHD!) for backwards compatibility
|
|
int quality = bCelt ? 3 : 4;
|
|
|
|
// Get the codec.
|
|
CreateInterfaceFn createCodecFn = NULL;
|
|
g_hVoiceCodecDLL = FileSystem_LoadModule(pCodecName);
|
|
|
|
if ( !g_hVoiceCodecDLL || (createCodecFn = Sys_GetFactory(g_hVoiceCodecDLL)) == NULL ||
|
|
(g_pEncodeCodec = (IVoiceCodec*)createCodecFn(pCodecName, NULL)) == NULL || !g_pEncodeCodec->Init( quality ) )
|
|
{
|
|
Msg("Unable to load voice codec '%s'. Voice disabled. (module %i, iface %i, codec %i)\n",
|
|
pCodecName, !!g_hVoiceCodecDLL, !!createCodecFn, !!g_pEncodeCodec);
|
|
Voice_Deinit();
|
|
return false;
|
|
}
|
|
|
|
for (int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
{
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[i];
|
|
|
|
if ((pChannel->m_pVoiceCodec = (IVoiceCodec*)createCodecFn(pCodecName, NULL)) == NULL || !pChannel->m_pVoiceCodec->Init( quality ))
|
|
{
|
|
Voice_Deinit();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// XXX(JohnS): These don't do much in Steam codec mode, but code below uses their presence to mean 'voice fully
|
|
// initialized' and other things assume they will succeed.
|
|
InitMixerControls();
|
|
|
|
// Steam mode uses steam for raw input so this isn't meaningful and could have side-effects
|
|
if( voice_forcemicrecord.GetInt() && !bSteam )
|
|
{
|
|
if( g_pMixerControls )
|
|
g_pMixerControls->SelectMicrophoneForWaveInput();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void Voice_EndChannel(int iChannel)
|
|
{
|
|
Assert(iChannel >= 0 && iChannel < VOICE_NUM_CHANNELS);
|
|
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[iChannel];
|
|
|
|
if ( pChannel->m_iEntity != -1 )
|
|
{
|
|
int iEnt = pChannel->m_iEntity;
|
|
pChannel->m_iEntity = -1;
|
|
|
|
if ( pChannel->m_bProximity == true )
|
|
{
|
|
VoiceSE_EndChannel( iChannel, iEnt );
|
|
}
|
|
else
|
|
{
|
|
VoiceSE_EndChannel( iChannel, pChannel->m_nViewEntityIndex );
|
|
}
|
|
|
|
g_pSoundServices->OnChangeVoiceStatus( iEnt, false );
|
|
VoiceSE_CloseMouth( iEnt );
|
|
|
|
pChannel->m_nViewEntityIndex = -1;
|
|
pChannel->m_nSoundGuid = -1;
|
|
|
|
// If the tweak mode channel is ending
|
|
if ( iChannel == 0 &&
|
|
g_bInTweakMode )
|
|
{
|
|
VoiceTweak_EndVoiceTweakMode();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Voice_EndAllChannels()
|
|
{
|
|
for(int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
{
|
|
Voice_EndChannel(i);
|
|
}
|
|
}
|
|
|
|
bool EngineTool_SuppressDeInit();
|
|
|
|
void Voice_Deinit()
|
|
{
|
|
// This call tends to be expensive and when voice is not enabled it will continually
|
|
// call in here, so avoid the work if possible.
|
|
if( !g_bVoiceAtLeastPartiallyInitted )
|
|
return;
|
|
|
|
if ( EngineTool_SuppressDeInit() )
|
|
return;
|
|
|
|
Voice_EndAllChannels();
|
|
|
|
Voice_RecordStop();
|
|
|
|
for(int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
{
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[i];
|
|
|
|
if ( pChannel->m_pVoiceCodec )
|
|
{
|
|
pChannel->m_pVoiceCodec->Release();
|
|
pChannel->m_pVoiceCodec = NULL;
|
|
}
|
|
}
|
|
|
|
if( g_pEncodeCodec )
|
|
{
|
|
g_pEncodeCodec->Release();
|
|
g_pEncodeCodec = NULL;
|
|
}
|
|
|
|
if(g_hVoiceCodecDLL)
|
|
{
|
|
FileSystem_UnloadModule(g_hVoiceCodecDLL);
|
|
g_hVoiceCodecDLL = NULL;
|
|
}
|
|
|
|
if(g_pVoiceRecord)
|
|
{
|
|
g_pVoiceRecord->Release();
|
|
g_pVoiceRecord = NULL;
|
|
}
|
|
|
|
VoiceSE_Term();
|
|
|
|
g_bVoiceAtLeastPartiallyInitted = false;
|
|
g_szVoiceCodec[0] = '\0';
|
|
g_nVoiceRequestedSampleRate = -1;
|
|
g_bUsingSteamVoice = false;
|
|
}
|
|
|
|
bool Voice_GetLoopback()
|
|
{
|
|
return !!voice_loopback.GetInt();
|
|
}
|
|
|
|
|
|
void Voice_LocalPlayerTalkingAck()
|
|
{
|
|
if(!g_bLocalPlayerTalkingAck)
|
|
{
|
|
// Tell the client DLL when this changes.
|
|
g_pSoundServices->OnChangeVoiceStatus(-2, TRUE);
|
|
}
|
|
|
|
g_bLocalPlayerTalkingAck = true;
|
|
g_LocalPlayerTalkingTimeout = 0;
|
|
}
|
|
|
|
|
|
void Voice_UpdateVoiceTweakMode()
|
|
{
|
|
if(!g_bInTweakMode || !g_pVoiceRecord)
|
|
return;
|
|
|
|
CVoiceChannel *pTweakChannel = GetVoiceChannel( 0 );
|
|
|
|
if ( pTweakChannel->m_nSoundGuid != -1 &&
|
|
!S_IsSoundStillPlaying( pTweakChannel->m_nSoundGuid ) )
|
|
{
|
|
VoiceTweak_EndVoiceTweakMode();
|
|
return;
|
|
}
|
|
|
|
char uchVoiceData[4096];
|
|
bool bFinal = false;
|
|
int nDataLength = Voice_GetCompressedData(uchVoiceData, sizeof(uchVoiceData), bFinal);
|
|
|
|
Voice_AddIncomingData(TWEAKMODE_CHANNELINDEX, uchVoiceData, nDataLength, 0);
|
|
}
|
|
|
|
|
|
void Voice_Idle(float frametime)
|
|
{
|
|
if( voice_enable.GetInt() == 0 )
|
|
{
|
|
Voice_Deinit();
|
|
return;
|
|
}
|
|
|
|
if( g_bLocalPlayerTalkingAck )
|
|
{
|
|
g_LocalPlayerTalkingTimeout += frametime;
|
|
if(g_LocalPlayerTalkingTimeout > LOCALPLAYERTALKING_TIMEOUT)
|
|
{
|
|
g_bLocalPlayerTalkingAck = false;
|
|
|
|
// Tell the client DLL.
|
|
g_pSoundServices->OnChangeVoiceStatus(-2, FALSE);
|
|
}
|
|
}
|
|
|
|
// Precalculate these to speedup the voice fadeout.
|
|
g_nVoiceFadeSamples = max((int)(voice_fadeouttime.GetFloat() * g_VoiceSampleFormat.nSamplesPerSec ), 2);
|
|
g_VoiceFadeMul = 1.0f / (g_nVoiceFadeSamples - 1);
|
|
|
|
if(g_pVoiceRecord)
|
|
g_pVoiceRecord->Idle();
|
|
|
|
// If we're in voice tweak mode, feed our own data back to us.
|
|
Voice_UpdateVoiceTweakMode();
|
|
|
|
// Age the channels.
|
|
int nActive = 0;
|
|
for(int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
{
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[i];
|
|
|
|
if(pChannel->m_iEntity != -1)
|
|
{
|
|
if(pChannel->m_bStarved)
|
|
{
|
|
// Kill the channel. It's done playing.
|
|
Voice_EndChannel(i);
|
|
pChannel->m_nSoundGuid = -1;
|
|
}
|
|
else
|
|
{
|
|
float oldpad = pChannel->m_TimePad;
|
|
pChannel->m_TimePad -= frametime;
|
|
if(oldpad > 0 && pChannel->m_TimePad <= 0)
|
|
{
|
|
// Start its audio.
|
|
pChannel->m_nViewEntityIndex = g_pSoundServices->GetViewEntity();
|
|
pChannel->m_nSoundGuid = VoiceSE_StartChannel( i, pChannel->m_iEntity, pChannel->m_bProximity, pChannel->m_nViewEntityIndex );
|
|
g_pSoundServices->OnChangeVoiceStatus(pChannel->m_iEntity, TRUE);
|
|
|
|
VoiceSE_InitMouth(pChannel->m_iEntity);
|
|
}
|
|
|
|
++nActive;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(nActive == 0)
|
|
VoiceSE_EndOverdrive();
|
|
|
|
VoiceSE_Idle(frametime);
|
|
|
|
// voice_showchannels.
|
|
if( voice_showchannels.GetInt() >= 1 )
|
|
{
|
|
for(int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
{
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[i];
|
|
|
|
if(pChannel->m_iEntity == -1)
|
|
continue;
|
|
|
|
Msg("Voice - chan %d, ent %d, bufsize: %d\n", i, pChannel->m_iEntity, pChannel->m_Buffer.GetReadAvailable());
|
|
}
|
|
}
|
|
|
|
// Show profiling data?
|
|
if( voice_profile.GetInt() )
|
|
{
|
|
Msg("Voice - compress: %7.2fu, decompress: %7.2fu, gain: %7.2fu, upsample: %7.2fu, total: %7.2fu\n",
|
|
g_CompressTime*1000000.0,
|
|
g_DecompressTime*1000000.0,
|
|
g_GainTime*1000000.0,
|
|
g_UpsampleTime*1000000.0,
|
|
(g_CompressTime+g_DecompressTime+g_GainTime+g_UpsampleTime)*1000000.0
|
|
);
|
|
|
|
g_CompressTime = g_DecompressTime = g_GainTime = g_UpsampleTime = 0;
|
|
}
|
|
}
|
|
|
|
|
|
bool Voice_IsRecording()
|
|
{
|
|
return g_bVoiceRecording && !g_bInTweakMode;
|
|
}
|
|
|
|
|
|
bool Voice_RecordStart(
|
|
const char *pUncompressedFile,
|
|
const char *pDecompressedFile,
|
|
const char *pMicInputFile)
|
|
{
|
|
if( !g_pEncodeCodec && !g_bUsingSteamVoice )
|
|
return false;
|
|
|
|
g_VoiceWriter.Flush();
|
|
|
|
Voice_RecordStop();
|
|
|
|
if ( !g_bUsingSteamVoice )
|
|
{
|
|
g_pEncodeCodec->ResetState();
|
|
}
|
|
|
|
if(pMicInputFile)
|
|
{
|
|
int a, b, c;
|
|
ReadWaveFile(pMicInputFile, g_pMicInputFileData, g_nMicInputFileBytes, a, b, c);
|
|
g_CurMicInputFileByte = 0;
|
|
g_MicStartTime = Plat_FloatTime();
|
|
}
|
|
|
|
if(pUncompressedFile)
|
|
{
|
|
g_pUncompressedFileData = new char[MAX_WAVEFILEDATA_LEN];
|
|
g_nUncompressedDataBytes = 0;
|
|
g_pUncompressedDataFilename = pUncompressedFile;
|
|
}
|
|
|
|
if(pDecompressedFile)
|
|
{
|
|
g_pDecompressedFileData = new char[MAX_WAVEFILEDATA_LEN];
|
|
g_nDecompressedDataBytes = 0;
|
|
g_pDecompressedDataFilename = pDecompressedFile;
|
|
}
|
|
|
|
g_bVoiceRecording = false;
|
|
if ( g_pVoiceRecord )
|
|
{
|
|
g_bVoiceRecording = VoiceRecord_Start();
|
|
if ( g_bVoiceRecording )
|
|
{
|
|
if ( steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUser() )
|
|
{
|
|
// Tell Friends' Voice chat that the local user has started speaking
|
|
steamapicontext->SteamFriends()->SetInGameVoiceSpeaking( steamapicontext->SteamUser()->GetSteamID(), true );
|
|
}
|
|
|
|
g_pSoundServices->OnChangeVoiceStatus( -1, true ); // Tell the client DLL.
|
|
}
|
|
}
|
|
|
|
return g_bVoiceRecording;
|
|
}
|
|
|
|
|
|
void Voice_UserDesiresStop()
|
|
{
|
|
if ( g_bVoiceRecordStopping )
|
|
return;
|
|
|
|
g_bVoiceRecordStopping = true;
|
|
g_pSoundServices->OnChangeVoiceStatus( -1, false ); // Tell the client DLL.
|
|
|
|
// If we're using Steam voice, we'll keep recording until Steam tells us we
|
|
// received all the data.
|
|
if ( g_bUsingSteamVoice )
|
|
{
|
|
steamapicontext->SteamUser()->StopVoiceRecording();
|
|
}
|
|
else
|
|
{
|
|
VoiceRecord_Stop();
|
|
}
|
|
}
|
|
|
|
|
|
bool Voice_RecordStop()
|
|
{
|
|
// Write the files out for debugging.
|
|
if(g_pMicInputFileData)
|
|
{
|
|
delete [] g_pMicInputFileData;
|
|
g_pMicInputFileData = NULL;
|
|
}
|
|
|
|
if(g_pUncompressedFileData)
|
|
{
|
|
WriteWaveFile(g_pUncompressedDataFilename, g_pUncompressedFileData, g_nUncompressedDataBytes, g_VoiceSampleFormat.wBitsPerSample, g_VoiceSampleFormat.nChannels, Voice_SamplesPerSec() );
|
|
delete [] g_pUncompressedFileData;
|
|
g_pUncompressedFileData = NULL;
|
|
}
|
|
|
|
if(g_pDecompressedFileData)
|
|
{
|
|
WriteWaveFile(g_pDecompressedDataFilename, g_pDecompressedFileData, g_nDecompressedDataBytes, g_VoiceSampleFormat.wBitsPerSample, g_VoiceSampleFormat.nChannels, Voice_SamplesPerSec() );
|
|
delete [] g_pDecompressedFileData;
|
|
g_pDecompressedFileData = NULL;
|
|
}
|
|
|
|
g_VoiceWriter.Finish();
|
|
|
|
VoiceRecord_Stop();
|
|
|
|
if ( g_bVoiceRecording )
|
|
{
|
|
if ( steamapicontext->SteamFriends() && steamapicontext->SteamUser() )
|
|
{
|
|
// Tell Friends' Voice chat that the local user has stopped speaking
|
|
steamapicontext->SteamFriends()->SetInGameVoiceSpeaking( steamapicontext->SteamUser()->GetSteamID(), false );
|
|
}
|
|
}
|
|
|
|
g_bVoiceRecording = false;
|
|
g_bVoiceRecordStopping = false;
|
|
return(true);
|
|
}
|
|
|
|
|
|
int Voice_GetCompressedData(char *pchDest, int nCount, bool bFinal)
|
|
{
|
|
// Check g_bVoiceRecordStopping in case g_bUsingSteamVoice changes on us
|
|
// while waiting for the end of voice data.
|
|
if ( g_bUsingSteamVoice || g_bVoiceRecordStopping )
|
|
{
|
|
uint32 cbCompressedWritten = 0;
|
|
uint32 cbUncompressedWritten = 0;
|
|
uint32 cbCompressed = 0;
|
|
uint32 cbUncompressed = 0;
|
|
// We're going to always request steam give us the encoded stream at the optimal rate, unless our final output
|
|
// rate is lower than it. We'll pass our output rate when we actually extract the data, which Steam will
|
|
// happily upsample from its optimal rate for us.
|
|
int nEncodeRate = min( (int)steamapicontext->SteamUser()->GetVoiceOptimalSampleRate(), Voice_SamplesPerSec() );
|
|
EVoiceResult result = steamapicontext->SteamUser()->GetAvailableVoice( &cbCompressed, &cbUncompressed, nEncodeRate );
|
|
if ( result == k_EVoiceResultOK )
|
|
{
|
|
result = steamapicontext->SteamUser()->GetVoice( true, pchDest, nCount, &cbCompressedWritten,
|
|
g_pUncompressedFileData != NULL, g_pUncompressedFileData,
|
|
MAX_WAVEFILEDATA_LEN - g_nUncompressedDataBytes,
|
|
&cbUncompressedWritten, nEncodeRate );
|
|
|
|
if ( g_pUncompressedFileData )
|
|
{
|
|
g_nUncompressedDataBytes += cbUncompressedWritten;
|
|
}
|
|
g_pSoundServices->OnChangeVoiceStatus( -3, true );
|
|
}
|
|
else
|
|
{
|
|
if ( result == k_EVoiceResultNotRecording && g_bVoiceRecording )
|
|
{
|
|
Voice_RecordStop();
|
|
}
|
|
|
|
g_pSoundServices->OnChangeVoiceStatus( -3, false );
|
|
}
|
|
return cbCompressedWritten;
|
|
}
|
|
|
|
IVoiceCodec *pCodec = g_pEncodeCodec;
|
|
if( g_pVoiceRecord && pCodec )
|
|
{
|
|
#ifdef VOICE_VOX_ENABLE
|
|
static ConVarRef voice_vox( "voice_vox" );
|
|
#endif // VOICE_VOX_ENABLE
|
|
|
|
short tempData[8192];
|
|
int samplesWanted = min(nCount/BYTES_PER_SAMPLE, (int)sizeof(tempData)/BYTES_PER_SAMPLE);
|
|
int gotten = g_pVoiceRecord->GetRecordedData(tempData, samplesWanted);
|
|
|
|
// If they want to get the data from a file instead of the mic, use that.
|
|
if(g_pMicInputFileData)
|
|
{
|
|
double curtime = Plat_FloatTime();
|
|
int nShouldGet = (curtime - g_MicStartTime) * Voice_SamplesPerSec();
|
|
gotten = min(sizeof(tempData)/BYTES_PER_SAMPLE,
|
|
(size_t)min(nShouldGet, (g_nMicInputFileBytes - g_CurMicInputFileByte) / BYTES_PER_SAMPLE));
|
|
memcpy(tempData, &g_pMicInputFileData[g_CurMicInputFileByte], gotten*BYTES_PER_SAMPLE);
|
|
g_CurMicInputFileByte += gotten * BYTES_PER_SAMPLE;
|
|
g_MicStartTime = curtime;
|
|
}
|
|
#ifdef VOICE_VOX_ENABLE
|
|
else if ( gotten && voice_vox.GetBool() == true )
|
|
{
|
|
// If the voice data is essentially silent, don't transmit
|
|
short *pData = tempData;
|
|
int averageData = 0;
|
|
int minData = 16384;
|
|
int maxData = -16384;
|
|
for ( int i=0; i<gotten; ++i )
|
|
{
|
|
short val = *pData;
|
|
averageData += val;
|
|
minData = min( val, minData );
|
|
maxData = max( val, maxData );
|
|
++pData;
|
|
}
|
|
averageData /= gotten;
|
|
int deltaData = maxData - minData;
|
|
|
|
if ( deltaData < voice_threshold.GetFloat() && maxData < voice_threshold.GetFloat() )
|
|
{
|
|
// -3 signals that we're silent
|
|
g_pSoundServices->OnChangeVoiceStatus( -3, false );
|
|
return 0;
|
|
}
|
|
}
|
|
#endif // VOICE_VOX_ENABLE
|
|
|
|
#ifdef VOICE_SEND_RAW_TEST
|
|
int nCompressedBytes = min( gotten, nCount );
|
|
for ( int i=0; i < nCompressedBytes; i++ )
|
|
{
|
|
pchDest[i] = (char)(tempData[i] >> 8);
|
|
}
|
|
#else
|
|
int nCompressedBytes = pCodec->Compress((char*)tempData, gotten, pchDest, nCount, !!bFinal);
|
|
#endif
|
|
|
|
// Write to our file buffers..
|
|
if(g_pUncompressedFileData)
|
|
{
|
|
int nToWrite = min(gotten*BYTES_PER_SAMPLE, MAX_WAVEFILEDATA_LEN - g_nUncompressedDataBytes);
|
|
memcpy(&g_pUncompressedFileData[g_nUncompressedDataBytes], tempData, nToWrite);
|
|
g_nUncompressedDataBytes += nToWrite;
|
|
}
|
|
#ifdef VOICE_VOX_ENABLE
|
|
// -3 signals that we're talking
|
|
g_pSoundServices->OnChangeVoiceStatus( -3, (nCompressedBytes > 0) );
|
|
#endif // VOICE_VOX_ENABLE
|
|
return nCompressedBytes;
|
|
}
|
|
else
|
|
{
|
|
#ifdef VOICE_VOX_ENABLE
|
|
// -3 signals that we're silent
|
|
g_pSoundServices->OnChangeVoiceStatus( -3, false );
|
|
#endif // VOICE_VOX_ENABLE
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
|
|
// Purpose: Assigns a channel to an entity by searching for either a channel
|
|
// already assigned to that entity or picking the least recently used
|
|
// channel. If the LRU channel is picked, it is flushed and all other
|
|
// channels are aged.
|
|
// Input : nEntity - entity number to assign to a channel.
|
|
// Output : A channel index to which the entity has been assigned.
|
|
//------------------------------------------------------------------------------
|
|
int Voice_AssignChannel(int nEntity, bool bProximity)
|
|
{
|
|
if(g_bInTweakMode)
|
|
return VOICE_CHANNEL_IN_TWEAK_MODE;
|
|
|
|
// See if a channel already exists for this entity and if so, just return it.
|
|
int iFree = -1;
|
|
for(int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
{
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[i];
|
|
|
|
if(pChannel->m_iEntity == nEntity)
|
|
{
|
|
return i;
|
|
}
|
|
else if(pChannel->m_iEntity == -1 && ( pChannel->m_pVoiceCodec || g_bUsingSteamVoice ) )
|
|
{
|
|
// Won't exist in steam voice mode
|
|
if ( pChannel->m_pVoiceCodec )
|
|
{
|
|
pChannel->m_pVoiceCodec->ResetState();
|
|
}
|
|
iFree = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If they're all used, then don't allow them to make a new channel.
|
|
if(iFree == -1)
|
|
{
|
|
return VOICE_CHANNEL_ERROR;
|
|
}
|
|
|
|
CVoiceChannel *pChannel = &g_VoiceChannels[iFree];
|
|
pChannel->Init(nEntity);
|
|
pChannel->m_bProximity = bProximity;
|
|
VoiceSE_StartOverdrive();
|
|
|
|
return iFree;
|
|
}
|
|
|
|
|
|
//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
|
|
// Purpose: Determines which channel has been assigened to a given entity.
|
|
// Input : nEntity - entity number.
|
|
// Output : The index of the channel assigned to the entity, VOICE_CHANNEL_ERROR
|
|
// if no channel is currently assigned to the given entity.
|
|
//------------------------------------------------------------------------------
|
|
int Voice_GetChannel(int nEntity)
|
|
{
|
|
for(int i=0; i < VOICE_NUM_CHANNELS; i++)
|
|
if(g_VoiceChannels[i].m_iEntity == nEntity)
|
|
return i;
|
|
|
|
return VOICE_CHANNEL_ERROR;
|
|
}
|
|
|
|
|
|
double UpsampleIntoBuffer(
|
|
const short *pSrc,
|
|
int nSrcSamples,
|
|
CCircularBuffer *pBuffer,
|
|
double startFraction,
|
|
double rate)
|
|
{
|
|
double maxFraction = nSrcSamples - 1;
|
|
|
|
while(1)
|
|
{
|
|
if(startFraction >= maxFraction)
|
|
break;
|
|
|
|
int iSample = (int)startFraction;
|
|
double frac = startFraction - floor(startFraction);
|
|
|
|
double val1 = pSrc[iSample];
|
|
double val2 = pSrc[iSample+1];
|
|
short newSample = (short)(val1 + (val2 - val1) * frac);
|
|
pBuffer->Write(&newSample, sizeof(newSample));
|
|
|
|
startFraction += rate;
|
|
}
|
|
|
|
return startFraction - floor(startFraction);
|
|
}
|
|
|
|
|
|
//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
|
|
// Purpose: Adds received voice data to
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
int Voice_AddIncomingData(int nChannel, const char *pchData, int nCount, int iSequenceNumber)
|
|
{
|
|
CVoiceChannel *pChannel;
|
|
|
|
// If in tweak mode, we call this during Idle with -1 as the channel, so any channel data from the network
|
|
// gets rejected.
|
|
if(g_bInTweakMode)
|
|
{
|
|
if(nChannel == TWEAKMODE_CHANNELINDEX)
|
|
nChannel = 0;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
if ( ( pChannel = GetVoiceChannel(nChannel)) == NULL || ( !g_bUsingSteamVoice && !pChannel->m_pVoiceCodec ) )
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
pChannel->m_bStarved = false; // This only really matters if you call Voice_AddIncomingData between the time the mixer
|
|
// asks for data and Voice_Idle is called.
|
|
|
|
// Decompress.
|
|
// @note Tom Bui: suggested destination buffer for Steam voice is 22kb
|
|
char decompressed[22528];
|
|
|
|
#ifdef VOICE_SEND_RAW_TEST
|
|
|
|
int nDecompressed = nCount;
|
|
for ( int i=0; i < nDecompressed; i++ )
|
|
((short*)decompressed)[i] = pchData[i] << 8;
|
|
|
|
#else
|
|
|
|
int nDecompressed = 0;
|
|
if ( g_bUsingSteamVoice )
|
|
{
|
|
uint32 nBytesWritten = 0;
|
|
EVoiceResult result = steamapicontext->SteamUser()->DecompressVoice( pchData, nCount,
|
|
decompressed, sizeof( decompressed ),
|
|
&nBytesWritten, Voice_SamplesPerSec() );
|
|
if ( result == k_EVoiceResultOK )
|
|
{
|
|
nDecompressed = nBytesWritten / BYTES_PER_SAMPLE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nDecompressed = pChannel->m_pVoiceCodec->Decompress(pchData, nCount, decompressed, sizeof(decompressed));
|
|
}
|
|
|
|
#endif
|
|
|
|
if ( g_bInTweakMode )
|
|
{
|
|
short *data = (short *)decompressed;
|
|
g_VoiceTweakSpeakingVolume = 0;
|
|
|
|
// Find the highest value
|
|
for ( int i=0; i<nDecompressed; ++i )
|
|
{
|
|
g_VoiceTweakSpeakingVolume = max((int)abs(data[i]), g_VoiceTweakSpeakingVolume);
|
|
}
|
|
|
|
// Smooth it out
|
|
g_VoiceTweakSpeakingVolume &= 0xFE00;
|
|
}
|
|
|
|
pChannel->m_AutoGain.ProcessSamples((short*)decompressed, nDecompressed);
|
|
|
|
// Upsample into the dest buffer. We could do this in a mixer but it complicates the mixer.
|
|
pChannel->m_LastFraction = UpsampleIntoBuffer( (short*)decompressed,
|
|
nDecompressed,
|
|
&pChannel->m_Buffer,
|
|
pChannel->m_LastFraction,
|
|
(double)Voice_SamplesPerSec()/g_VoiceSampleFormat.nSamplesPerSec );
|
|
pChannel->m_LastSample = decompressed[nDecompressed];
|
|
|
|
// Write to our file buffer..
|
|
if(g_pDecompressedFileData)
|
|
{
|
|
int nToWrite = min(nDecompressed*2, MAX_WAVEFILEDATA_LEN - g_nDecompressedDataBytes);
|
|
memcpy(&g_pDecompressedFileData[g_nDecompressedDataBytes], decompressed, nToWrite);
|
|
g_nDecompressedDataBytes += nToWrite;
|
|
}
|
|
|
|
g_VoiceWriter.AddDecompressedData( pChannel, (const byte *)decompressed, nDecompressed * 2 );
|
|
|
|
if( voice_showincoming.GetInt() != 0 )
|
|
{
|
|
Msg("Voice - %d incoming samples added to channel %d\n", nDecompressed, nChannel);
|
|
}
|
|
|
|
return(nChannel);
|
|
}
|
|
|
|
|
|
#if DEAD
|
|
//------------------ Copyright (c) 1999 Valve, LLC. ----------------------------
|
|
// Purpose: Flushes a given receive channel.
|
|
// Input : nChannel - index of channel to flush.
|
|
//------------------------------------------------------------------------------
|
|
void Voice_FlushChannel(int nChannel)
|
|
{
|
|
if ((nChannel < 0) || (nChannel >= VOICE_NUM_CHANNELS))
|
|
{
|
|
Assert(false);
|
|
return;
|
|
}
|
|
|
|
g_VoiceChannels[nChannel].m_Buffer.Flush();
|
|
}
|
|
#endif
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IVoiceTweak implementation.
|
|
//------------------------------------------------------------------------------
|
|
|
|
int VoiceTweak_StartVoiceTweakMode()
|
|
{
|
|
// If we're already in voice tweak mode, return an error.
|
|
if(g_bInTweakMode)
|
|
{
|
|
Assert(!"VoiceTweak_StartVoiceTweakMode called while already in tweak mode.");
|
|
return 0;
|
|
}
|
|
|
|
if ( !g_pMixerControls && voice_enable.GetBool() )
|
|
{
|
|
Voice_ForceInit();
|
|
}
|
|
|
|
if( !g_pMixerControls )
|
|
return 0;
|
|
|
|
Voice_EndAllChannels();
|
|
Voice_RecordStart(NULL, NULL, NULL);
|
|
Voice_AssignChannel(TWEAKMODE_ENTITYINDEX, false );
|
|
g_bInTweakMode = true;
|
|
InitMixerControls();
|
|
|
|
return 1;
|
|
}
|
|
|
|
void VoiceTweak_EndVoiceTweakMode()
|
|
{
|
|
if(!g_bInTweakMode)
|
|
{
|
|
Assert(!"VoiceTweak_EndVoiceTweakMode called when not in tweak mode.");
|
|
return;
|
|
}
|
|
|
|
g_bInTweakMode = false;
|
|
Voice_RecordStop();
|
|
}
|
|
|
|
void VoiceTweak_SetControlFloat(VoiceTweakControl iControl, float flValue)
|
|
{
|
|
if(!g_pMixerControls)
|
|
return;
|
|
|
|
if(iControl == MicrophoneVolume)
|
|
{
|
|
g_pMixerControls->SetValue_Float(IMixerControls::MicVolume, flValue);
|
|
}
|
|
else if ( iControl == MicBoost )
|
|
{
|
|
g_pMixerControls->SetValue_Float( IMixerControls::MicBoost, flValue );
|
|
}
|
|
else if(iControl == OtherSpeakerScale)
|
|
{
|
|
voice_scale.SetValue( flValue );
|
|
}
|
|
}
|
|
|
|
void Voice_ForceInit()
|
|
{
|
|
if ( g_pMixerControls || !voice_enable.GetBool() )
|
|
{
|
|
// Nothing to do
|
|
return;
|
|
}
|
|
|
|
// Lacking a better default, just peak at what the server's sv_voicecodec is set to
|
|
static ConVarRef sv_voicecodec( "sv_voicecodec" );
|
|
if ( !Voice_InitWithDefault( sv_voicecodec.GetString() ) )
|
|
{
|
|
// Try ultimate fallback
|
|
Voice_InitWithDefault( VOICE_FALLBACK_CODEC );
|
|
}
|
|
}
|
|
|
|
float VoiceTweak_GetControlFloat(VoiceTweakControl iControl)
|
|
{
|
|
Voice_ForceInit();
|
|
|
|
if(!g_pMixerControls)
|
|
return 0;
|
|
|
|
if(iControl == MicrophoneVolume)
|
|
{
|
|
float value = 1;
|
|
g_pMixerControls->GetValue_Float(IMixerControls::MicVolume, value);
|
|
return value;
|
|
}
|
|
else if(iControl == OtherSpeakerScale)
|
|
{
|
|
return voice_scale.GetFloat();
|
|
}
|
|
else if(iControl == SpeakingVolume)
|
|
{
|
|
return g_VoiceTweakSpeakingVolume * 1.0f / 32768;
|
|
}
|
|
else if ( iControl == MicBoost )
|
|
{
|
|
float flValue = 1;
|
|
g_pMixerControls->GetValue_Float( IMixerControls::MicBoost, flValue );
|
|
return flValue;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
bool VoiceTweak_IsStillTweaking()
|
|
{
|
|
return g_bInTweakMode;
|
|
}
|
|
|
|
void Voice_Spatialize( channel_t *channel )
|
|
{
|
|
if ( !g_bInTweakMode )
|
|
return;
|
|
|
|
Assert( channel->sfx );
|
|
Assert( channel->sfx->pSource );
|
|
Assert( channel->sfx->pSource->GetType() == CAudioSource::AUDIO_SOURCE_VOICE );
|
|
|
|
// Place the tweak mode sound back at the view entity
|
|
CVoiceChannel *pVoiceChannel = GetVoiceChannel( 0 );
|
|
Assert( pVoiceChannel );
|
|
if ( !pVoiceChannel )
|
|
return;
|
|
|
|
if ( pVoiceChannel->m_nSoundGuid != channel->guid )
|
|
return;
|
|
|
|
// No change
|
|
if ( g_pSoundServices->GetViewEntity() == pVoiceChannel->m_nViewEntityIndex )
|
|
return;
|
|
|
|
DevMsg( 1, "Voice_Spatialize changing voice tweak entity from %d to %d\n", pVoiceChannel->m_nViewEntityIndex, g_pSoundServices->GetViewEntity() );
|
|
|
|
pVoiceChannel->m_nViewEntityIndex = g_pSoundServices->GetViewEntity();
|
|
channel->soundsource = pVoiceChannel->m_nViewEntityIndex;
|
|
}
|
|
|
|
IVoiceTweak g_VoiceTweakAPI =
|
|
{
|
|
VoiceTweak_StartVoiceTweakMode,
|
|
VoiceTweak_EndVoiceTweakMode,
|
|
VoiceTweak_SetControlFloat,
|
|
VoiceTweak_GetControlFloat,
|
|
VoiceTweak_IsStillTweaking,
|
|
};
|
|
|
|
|