jamulus/windows/sound.cpp

562 lines
19 KiB
C++
Raw Normal View History

/******************************************************************************\
* Copyright (c) 2004-2009
*
* Author(s):
* Volker Fischer
*
* Description:
* Sound card interface for Windows operating systems
*
******************************************************************************
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option) any later
* version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
\******************************************************************************/
#include "Sound.h"
/* Implementation *************************************************************/
2007-12-18 21:52:48 +01:00
// external references
extern AsioDrivers* asioDrivers;
bool loadAsioDriver ( char *name );
// TODO the following variables should be in the class definition but we cannot
// do it here since we have static callback functions which cannot access the
// class members :-(((
2008-07-11 23:06:15 +02:00
// ASIO stuff
ASIODriverInfo driverInfo;
ASIOBufferInfo bufferInfos[2 * NUM_IN_OUT_CHANNELS]; // for input and output buffers -> "2 *"
ASIOChannelInfo channelInfos[2 * NUM_IN_OUT_CHANNELS];
bool bASIOPostOutput;
ASIOCallbacks asioCallbacks;
2008-07-13 01:33:27 +02:00
int iBufferSizeMono;
int iBufferSizeStereo;
2008-07-13 09:26:16 +02:00
int iASIOBufferSizeMono;
2008-07-11 23:06:15 +02:00
CVector<short> vecsTmpAudioSndCrdStereo;
2008-07-13 22:03:37 +02:00
QMutex ASIOMutex;
// TEST
CSound* pSound;
2007-12-19 21:16:50 +01:00
/******************************************************************************\
* Common *
\******************************************************************************/
2008-10-31 00:23:26 +01:00
void CSound::SetDev ( const int iNewDev )
{
// check if an ASIO driver was already initialized
if ( lCurDev >= 0 )
{
// a device was already been initialized and is used, kill working
// thread and clean up
// stop driver
ASIOStop();
// dispose ASIO buffers
2008-10-31 00:23:26 +01:00
ASIODisposeBuffers();
// remove old driver
ASIOExit();
asioDrivers->removeCurrentDriver();
const std::string strErrorMessage = LoadAndInitializeDriver ( iNewDev );
if ( !strErrorMessage.empty() )
{
// loading and initializing the new driver failed, go back to original
// driver and display error message
LoadAndInitializeDriver ( lCurDev );
Init ( iBufferSizeStereo );
2008-10-31 00:23:26 +01:00
throw CGenErr ( strErrorMessage.c_str() );
}
Init ( iBufferSizeStereo );
2008-10-31 00:23:26 +01:00
}
else
{
if ( iNewDev != INVALID_SNC_CARD_DEVICE )
2008-10-31 00:23:26 +01:00
{
// This is the first time a driver is to be initialized, we first try
// to load the selected driver, if this fails, we try to load the first
// available driver in the system. If this fails, too, we throw an error
// that no driver is available -> it does not make sense to start the llcon
// software if no audio hardware is available
const std::string strErrorMessage = LoadAndInitializeDriver ( iNewDev );
if ( !strErrorMessage.empty() )
{
// loading and initializing the new driver failed, try to find at
// least one usable driver
if ( !LoadAndInitializeFirstValidDriver() )
{
throw CGenErr ( "No usable ASIO audio device (driver) found." );
}
}
}
else
{
// try to find one usable driver (select the first valid driver)
2008-10-31 00:23:26 +01:00
if ( !LoadAndInitializeFirstValidDriver() )
{
throw CGenErr ( "No usable ASIO audio device (driver) found." );
}
}
}
}
std::string CSound::LoadAndInitializeDriver ( int iDriverIdx )
2008-10-31 00:23:26 +01:00
{
// first check and correct input parameter
if ( iDriverIdx >= lNumDevs )
{
// we assume here that at least one driver is in the system
iDriverIdx = 0;
}
2008-10-31 00:23:26 +01:00
// load driver
loadAsioDriver ( cDriverNames[iDriverIdx] );
if ( ASIOInit ( &driverInfo ) != ASE_OK )
{
// clean up and return error string
asioDrivers->removeCurrentDriver();
return "The audio driver could not be initialized.";
}
2008-11-01 09:47:31 +01:00
const std::string strStat = PrepareDriver();
2008-10-31 00:23:26 +01:00
// store ID of selected driver if initialization was successful
if ( strStat.empty() )
2008-10-31 00:23:26 +01:00
{
lCurDev = iDriverIdx;
2008-10-31 00:23:26 +01:00
}
return strStat;
2008-10-31 00:23:26 +01:00
}
bool CSound::LoadAndInitializeFirstValidDriver()
{
// load and initialize first valid ASIO driver
bool bValidDriverDetected = false;
int iCurDriverIdx = 0;
// try all available drivers in the system ("lNumDevs" devices)
while ( !bValidDriverDetected && iCurDriverIdx < lNumDevs )
{
if ( loadAsioDriver ( cDriverNames[iCurDriverIdx] ) )
{
if ( ASIOInit ( &driverInfo ) == ASE_OK )
{
2008-11-01 09:47:31 +01:00
if ( PrepareDriver().empty() )
{
// initialization was successful
bValidDriverDetected = true;
2008-10-31 00:23:26 +01:00
// store ID of selected driver
lCurDev = iCurDriverIdx;
}
else
{
// driver could not be loaded, free memory
asioDrivers->removeCurrentDriver();
}
2008-10-31 00:23:26 +01:00
}
else
{
// driver could not be loaded, free memory
asioDrivers->removeCurrentDriver();
}
}
// try next driver
iCurDriverIdx++;
}
return bValidDriverDetected;
}
2008-11-01 09:47:31 +01:00
std::string CSound::PrepareDriver()
2007-12-19 21:16:50 +01:00
{
int i;
2007-12-19 21:16:50 +01:00
// check the number of available channels
long lNumInChan;
long lNumOutChan;
ASIOGetChannels ( &lNumInChan, &lNumOutChan );
if ( ( lNumInChan < NUM_IN_OUT_CHANNELS ) ||
( lNumOutChan < NUM_IN_OUT_CHANNELS ) )
{
// clean up and return error string
ASIOExit();
asioDrivers->removeCurrentDriver();
return "The audio device does not support the "
"required number of channels.";
}
// set the sample rate and check if sample rate is supported
ASIOSetSampleRate ( SND_CRD_SAMPLE_RATE );
ASIOSampleRate sampleRate;
ASIOGetSampleRate ( &sampleRate );
if ( sampleRate != SND_CRD_SAMPLE_RATE )
2008-04-13 18:43:21 +02:00
{
// clean up and return error string
ASIOExit();
asioDrivers->removeCurrentDriver();
return "The audio device does not support the "
"required sample rate.";
}
2008-07-13 01:33:27 +02:00
2009-03-05 14:55:00 +01:00
// TEST
iASIOBufferSizeMono = GetActualBufferSize ( iBufferSizeMono );
2009-03-05 14:55:00 +01:00
for ( i = 0; i < NUM_IN_OUT_CHANNELS; i++ )
{
2009-03-05 14:55:00 +01:00
// prepare input channels
bufferInfos[i].isInput = ASIOTrue;
bufferInfos[i].channelNum = i;
bufferInfos[i].buffers[0] = 0;
bufferInfos[i].buffers[1] = 0;
// prepare output channels
bufferInfos[NUM_IN_OUT_CHANNELS + i].isInput = ASIOFalse;
bufferInfos[NUM_IN_OUT_CHANNELS + i].channelNum = i;
bufferInfos[NUM_IN_OUT_CHANNELS + i].buffers[0] = 0;
bufferInfos[NUM_IN_OUT_CHANNELS + i].buffers[1] = 0;
}
2009-03-05 14:55:00 +01:00
// create and activate ASIO buffers (buffer size in samples)
ASIOCreateBuffers ( bufferInfos, 2 /* in/out */ * NUM_IN_OUT_CHANNELS /* stereo */,
iASIOBufferSizeMono, &asioCallbacks );
// now get some buffer details
for ( i = 0; i < 2 * NUM_IN_OUT_CHANNELS; i++ )
{
2009-03-05 14:55:00 +01:00
channelInfos[i].channel = bufferInfos[i].channelNum;
channelInfos[i].isInput = bufferInfos[i].isInput;
ASIOGetChannelInfo ( &channelInfos[i] );
// only 16/24/32 LSB is supported
if ( ( channelInfos[i].type != ASIOSTInt16LSB ) &&
( channelInfos[i].type != ASIOSTInt24LSB ) &&
( channelInfos[i].type != ASIOSTInt32LSB ) )
{
// clean up and return error string
ASIODisposeBuffers();
ASIOExit();
asioDrivers->removeCurrentDriver();
return "Required audio sample format not available (16/24/32 bit LSB).";
}
}
2009-03-05 14:55:00 +01:00
// check wether the driver requires the ASIOOutputReady() optimization
// (can be used by the driver to reduce output latency by one block)
bASIOPostOutput = ( ASIOOutputReady() == ASE_OK );
return "";
}
int CSound::GetActualBufferSize ( const int iDesiredBufferSizeMono )
{
int iActualBufferSizeMono;
// query the usable buffer sizes
ASIOGetBufferSize ( &HWBufferInfo.lMinSize,
&HWBufferInfo.lMaxSize,
&HWBufferInfo.lPreferredSize,
&HWBufferInfo.lGranularity );
// calculate "nearest" buffer size and set internal parameter accordingly
// first check minimum and maximum values
if ( iDesiredBufferSizeMono < HWBufferInfo.lMinSize )
{
2009-03-05 14:55:00 +01:00
iActualBufferSizeMono = HWBufferInfo.lMinSize;
}
else
{
if ( iDesiredBufferSizeMono > HWBufferInfo.lMaxSize )
2008-04-13 18:43:21 +02:00
{
2009-03-05 14:55:00 +01:00
iActualBufferSizeMono = HWBufferInfo.lMaxSize;
2008-04-13 18:43:21 +02:00
}
else
{
// initialization
int iTrialBufSize = HWBufferInfo.lMinSize;
int iLastTrialBufSize = HWBufferInfo.lMinSize;
bool bSizeFound = false;
// test loop
while ( ( iTrialBufSize <= HWBufferInfo.lMaxSize ) && ( !bSizeFound ) )
{
if ( iTrialBufSize >= iDesiredBufferSizeMono )
2008-04-13 18:43:21 +02:00
{
// test which buffer size fits better: the old one or the
// current one
if ( ( iTrialBufSize - iDesiredBufferSizeMono ) >
( iDesiredBufferSizeMono - iLastTrialBufSize ) )
2008-04-13 18:43:21 +02:00
{
iTrialBufSize = iLastTrialBufSize;
2008-04-13 18:43:21 +02:00
}
// exit while loop
bSizeFound = true;
2008-04-13 18:43:21 +02:00
}
2008-07-13 09:26:16 +02:00
if ( !bSizeFound )
{
// store old trial buffer size
iLastTrialBufSize = iTrialBufSize;
// increment trial buffer size (check for special case first)
if ( HWBufferInfo.lGranularity == -1 )
{
// special case: buffer sizes are a power of 2
iTrialBufSize *= 2;
}
else
{
iTrialBufSize += HWBufferInfo.lGranularity;
}
}
2008-04-13 18:43:21 +02:00
}
// set ASIO buffer size
2009-03-05 14:55:00 +01:00
iActualBufferSizeMono = iTrialBufSize;
2008-04-13 18:43:21 +02:00
}
}
2008-04-08 20:38:55 +02:00
2009-03-05 14:55:00 +01:00
return iActualBufferSizeMono;
}
2009-03-01 23:08:06 +01:00
int CSound::Init ( const int iNewPrefMonoBufferSize )
{
// first, stop audio and dispose ASIO buffers
ASIOStop();
ASIOMutex.lock(); // get mutex lock
{
// init base clasee
2009-03-01 23:08:06 +01:00
CSoundBase::Init ( iNewPrefMonoBufferSize );
2009-03-01 23:08:06 +01:00
// set internal buffer size value and calculate stereo buffer size
iBufferSizeMono = iNewPrefMonoBufferSize;
iBufferSizeStereo = 2 * iBufferSizeMono;
// TEST
PrepareDriver();
2008-07-14 00:57:31 +02:00
2009-03-05 14:55:00 +01:00
// TODO possible BUG!!!!!!!!!!!!!!!!!!!!!
// iBufferSizeMono must not be the same as iASIOBufferSizeMono
// create memory for intermediate audio buffer
vecsTmpAudioSndCrdStereo.Init ( iBufferSizeStereo );
}
ASIOMutex.unlock();
2007-12-19 21:16:50 +01:00
// initialization is done, (re)start audio
ASIOStart();
2009-03-01 23:08:06 +01:00
// TEST
return iNewPrefMonoBufferSize;
2007-12-19 21:16:50 +01:00
}
void CSound::Close()
{
// stop driver
ASIOStop();
}
CSound::CSound ( void (*fpNewCallback) ( CVector<short>& psData, void* arg ), void* arg ) :
CSoundBase ( true, fpNewCallback, arg )
{
// TEST
pSound = this;
2007-12-18 21:52:48 +01:00
// get available ASIO driver names in system
for ( int i = 0; i < MAX_NUMBER_SOUND_CARDS; i++ )
2007-12-18 21:52:48 +01:00
{
cDriverNames[i] = new char[32];
}
loadAsioDriver ( "dummy" ); // to initialize external object
2008-10-31 00:23:26 +01:00
lNumDevs = asioDrivers->getDriverNames ( cDriverNames, MAX_NUMBER_SOUND_CARDS );
2007-12-18 21:52:48 +01:00
// in case we do not have a driver available, throw error
2008-10-31 00:23:26 +01:00
if ( lNumDevs == 0 )
2007-12-19 21:16:50 +01:00
{
2008-10-31 00:23:26 +01:00
throw CGenErr ( "No ASIO audio device (driver) found." );
2007-12-19 21:16:50 +01:00
}
2007-12-18 21:52:48 +01:00
2008-10-31 00:23:26 +01:00
asioDrivers->removeCurrentDriver();
2007-12-19 21:16:50 +01:00
2008-10-31 00:23:26 +01:00
// init device index with illegal value to show that driver is not initialized
lCurDev = -1;
2007-12-19 21:16:50 +01:00
// set up the asioCallback structure
asioCallbacks.bufferSwitch = &bufferSwitch;
asioCallbacks.sampleRateDidChange = &sampleRateChanged;
asioCallbacks.asioMessage = &asioMessages;
asioCallbacks.bufferSwitchTimeInfo = &bufferSwitchTimeInfo;
}
CSound::~CSound()
{
2007-12-19 21:16:50 +01:00
// cleanup ASIO stuff
ASIOStop();
ASIODisposeBuffers();
ASIOExit();
asioDrivers->removeCurrentDriver();
}
2007-12-19 21:16:50 +01:00
// ASIO callbacks -------------------------------------------------------------
2008-07-13 09:26:16 +02:00
ASIOTime* CSound::bufferSwitchTimeInfo ( ASIOTime *timeInfo,
long index,
ASIOBool processNow )
2007-12-19 21:16:50 +01:00
{
bufferSwitch ( index, processNow );
return 0L;
2008-03-16 14:10:46 +01:00
}
2007-12-19 21:16:50 +01:00
2008-07-13 12:56:40 +02:00
void CSound::bufferSwitch ( long index, ASIOBool processNow )
2008-03-16 14:10:46 +01:00
{
int iCurSample;
ASIOMutex.lock(); // get mutex lock
{
// perform the processing for input and output
for ( int i = 0; i < 2 * NUM_IN_OUT_CHANNELS; i++ ) // stereo
{
if ( bufferInfos[i].isInput == ASIOTrue )
{
2008-07-13 01:33:27 +02:00
// CAPTURE -----------------------------------------------------
// copy new captured block in thread transfer buffer (copy
// mono data interleaved in stereo buffer)
switch ( channelInfos[i].type )
{
case ASIOSTInt16LSB:
for ( iCurSample = 0; iCurSample < iASIOBufferSizeMono; iCurSample++ )
{
vecsTmpAudioSndCrdStereo[2 * iCurSample + bufferInfos[i].channelNum] =
( (short*) bufferInfos[i].buffers[index] )[iCurSample];
}
break;
case ASIOSTInt24LSB:
// not yet tested, horrible things might happen with the following code ;-)
for ( iCurSample = 0; iCurSample < iASIOBufferSizeMono; iCurSample++ )
{
// convert current sample in 16 bit format
int iCurSam = 0;
memcpy ( &iCurSam, ( (char*) bufferInfos[i].buffers[index] ) + iCurSample * 3, 3 );
iCurSam >>= 8;
vecsTmpAudioSndCrdStereo[2 * iCurSample + bufferInfos[i].channelNum] =
static_cast<short> ( iCurSam );
}
break;
case ASIOSTInt32LSB:
for ( iCurSample = 0; iCurSample < iASIOBufferSizeMono; iCurSample++ )
{
// convert to 16 bit
vecsTmpAudioSndCrdStereo[2 * iCurSample + bufferInfos[i].channelNum] =
(((int*) bufferInfos[i].buffers[index])[iCurSample] >> 16);
}
break;
}
}
}
// call processing callback function
pSound->Callback( vecsTmpAudioSndCrdStereo );
// perform the processing for input and output
for ( int i = 0; i < 2 * NUM_IN_OUT_CHANNELS; i++ ) // stereo
{
if ( bufferInfos[i].isInput != ASIOTrue )
{
// PLAYBACK ----------------------------------------------------
// copy data from sound card in output buffer (copy
// interleaved stereo data in mono sound card buffer)
switch ( channelInfos[i].type )
{
case ASIOSTInt16LSB:
for ( iCurSample = 0; iCurSample < iASIOBufferSizeMono; iCurSample++ )
{
( (short*) bufferInfos[i].buffers[index] )[iCurSample] =
vecsTmpAudioSndCrdStereo[2 * iCurSample + bufferInfos[i].channelNum];
}
break;
case ASIOSTInt24LSB:
// not yet tested, horrible things might happen with the following code ;-)
for ( iCurSample = 0; iCurSample < iASIOBufferSizeMono; iCurSample++ )
{
// convert current sample in 24 bit format
int iCurSam = static_cast<int> ( vecsTmpAudioSndCrdStereo[2 * iCurSample + bufferInfos[i].channelNum] );
iCurSam <<= 8;
2008-07-13 01:33:27 +02:00
memcpy ( ( (char*) bufferInfos[i].buffers[index] ) + iCurSample * 3, &iCurSam, 3 );
}
break;
case ASIOSTInt32LSB:
for ( iCurSample = 0; iCurSample < iASIOBufferSizeMono; iCurSample++ )
{
// convert to 32 bit
int iCurSam = static_cast<int> ( vecsTmpAudioSndCrdStereo[2 * iCurSample + bufferInfos[i].channelNum] );
( (int*) bufferInfos[i].buffers[index] )[iCurSample] = ( iCurSam << 16 );
}
break;
}
}
2008-07-13 01:33:27 +02:00
}
2008-07-13 15:16:31 +02:00
2008-07-13 22:03:37 +02:00
// finally if the driver supports the ASIOOutputReady() optimization,
// do it here, all data are in place -----------------------------------
2008-07-13 22:03:37 +02:00
if ( bASIOPostOutput )
{
ASIOOutputReady();
2008-07-13 22:03:37 +02:00
}
}
ASIOMutex.unlock();
2007-12-19 21:16:50 +01:00
}
long CSound::asioMessages ( long selector, long value, void* message, double* opt )
{
long ret = 0;
switch(selector)
{
case kAsioEngineVersion:
// return the supported ASIO version of the host application
ret = 2L;
break;
}
return ret;
2007-12-19 21:16:50 +01:00
}