370 lines
11 KiB
C++
Executable file
370 lines
11 KiB
C++
Executable file
/******************************************************************************\
|
|
* Copyright (c) 2004-2009
|
|
*
|
|
* Author(s):
|
|
* Volker Fischer, Alexander Kurpiers
|
|
*
|
|
* This code is based on the Open-Source sound interface implementation of
|
|
* the Dream DRM Receiver project.
|
|
*
|
|
\******************************************************************************/
|
|
|
|
#include "sound.h"
|
|
|
|
#ifdef WITH_SOUND
|
|
// Wave in *********************************************************************
|
|
void CSound::InitRecording()
|
|
{
|
|
int err;
|
|
|
|
// if recording device was already open, close it first
|
|
if ( rhandle != NULL )
|
|
{
|
|
snd_pcm_close ( rhandle );
|
|
}
|
|
|
|
/* record device: The most important ALSA interfaces to the PCM devices are
|
|
the "plughw" and the "hw" interface. If you use the "plughw" interface,
|
|
you need not care much about the sound hardware. If your soundcard does
|
|
not support the sample rate or sample format you specify, your data will
|
|
be automatically converted. This also applies to the access type and the
|
|
number of channels. With the "hw" interface, you have to check whether
|
|
your hardware supports the configuration you would like to use */
|
|
// either "hw:0,0" or "plughw:0,0"
|
|
if ( err = snd_pcm_open ( &rhandle, "hw:0,0", SND_PCM_STREAM_CAPTURE, 0 ) != 0 )
|
|
{
|
|
qDebug ( "open error: %s", snd_strerror ( err ) );
|
|
}
|
|
|
|
// recording should be blocking
|
|
if ( err = snd_pcm_nonblock ( rhandle, FALSE ) != 0 )
|
|
{
|
|
qDebug ( "cannot set blocking: %s", snd_strerror ( err ) );
|
|
}
|
|
|
|
// set hardware parameters
|
|
SetHWParams ( rhandle, iBufferSizeIn, iCurPeriodSizeIn );
|
|
|
|
// start record
|
|
snd_pcm_reset ( rhandle );
|
|
snd_pcm_start ( rhandle );
|
|
|
|
qDebug ( "alsa init record done" );
|
|
}
|
|
|
|
bool CSound::Read ( CVector<short>& psData )
|
|
{
|
|
int ret;
|
|
|
|
// check if device must be opened or reinitialized
|
|
if ( bChangParamIn == true )
|
|
{
|
|
InitRecording();
|
|
|
|
// reset flag
|
|
bChangParamIn = false;
|
|
}
|
|
|
|
ret = snd_pcm_readi ( rhandle, &psData[0], iBufferSizeIn );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
if ( ret == -EPIPE )
|
|
{
|
|
// under-run
|
|
qDebug ( "rprepare" );
|
|
|
|
ret = snd_pcm_prepare ( rhandle );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
qDebug ( "Can't recover from underrun, prepare failed: %s", snd_strerror ( ret ) );
|
|
}
|
|
|
|
ret = snd_pcm_start ( rhandle );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
qDebug ( "Can't recover from underrun, start failed: %s", snd_strerror ( ret ) );
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
else if ( ret == -ESTRPIPE )
|
|
{
|
|
qDebug ( "strpipe" );
|
|
|
|
// wait until the suspend flag is released
|
|
while ( ( ret = snd_pcm_resume ( rhandle ) ) == -EAGAIN )
|
|
{
|
|
sleep ( 1 );
|
|
}
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
ret = snd_pcm_prepare ( rhandle );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
qDebug ( "Can't recover from suspend, prepare failed: %s", snd_strerror ( ret ) );
|
|
}
|
|
throw CGenErr ( "CSound:Read" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
qDebug ( "CSound::Read: %s", snd_strerror ( ret ) );
|
|
throw CGenErr ( "CSound:Read" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// Wave out ********************************************************************
|
|
void CSound::InitPlayback()
|
|
{
|
|
int err;
|
|
|
|
// if playback device was already open, close it first
|
|
if ( phandle != NULL )
|
|
{
|
|
snd_pcm_close ( phandle );
|
|
}
|
|
|
|
// playback device (either "hw:0,0" or "plughw:0,0")
|
|
if ( err = snd_pcm_open ( &phandle, "hw:0,0",
|
|
SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK ) != 0 )
|
|
{
|
|
qDebug ( "open error: %s", snd_strerror ( err ) );
|
|
}
|
|
|
|
// non-blocking playback
|
|
if ( err = snd_pcm_nonblock ( phandle, TRUE ) != 0 )
|
|
{
|
|
qDebug ( "cannot set blocking: %s", snd_strerror ( err ) );
|
|
}
|
|
|
|
// set hardware parameters
|
|
SetHWParams ( phandle, iBufferSizeOut, iCurPeriodSizeOut );
|
|
|
|
// start playback
|
|
snd_pcm_start ( phandle );
|
|
|
|
qDebug ( "alsa init playback done" );
|
|
}
|
|
|
|
bool CSound::Write ( CVector<short>& psData )
|
|
{
|
|
int size = iBufferSizeOut;
|
|
int start = 0;
|
|
int ret;
|
|
|
|
// check if device must be opened or reinitialized
|
|
if ( bChangParamOut == true )
|
|
{
|
|
InitPlayback();
|
|
|
|
// reset flag
|
|
bChangParamOut = false;
|
|
}
|
|
|
|
while ( size )
|
|
{
|
|
ret = snd_pcm_writei ( phandle, &psData[start], size );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
if ( ret == -EPIPE )
|
|
{
|
|
// under-run
|
|
qDebug ( "wunderrun" );
|
|
|
|
ret = snd_pcm_prepare ( phandle );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
qDebug ( "Can't recover from underrun, prepare failed: %s", snd_strerror ( ret ) );
|
|
}
|
|
continue;
|
|
}
|
|
else if ( ret == -EAGAIN )
|
|
{
|
|
if ( ( ret = snd_pcm_wait ( phandle, 1000 ) ) < 0 )
|
|
{
|
|
qDebug ( "poll failed (%s)", snd_strerror ( ret ) );
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
else if ( ret == -ESTRPIPE )
|
|
{
|
|
qDebug ( "wstrpipe" );
|
|
|
|
// wait until the suspend flag is released
|
|
while ( ( ret = snd_pcm_resume ( phandle ) ) == -EAGAIN )
|
|
{
|
|
sleep ( 1 );
|
|
}
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
ret = snd_pcm_prepare ( phandle );
|
|
|
|
if ( ret < 0 )
|
|
{
|
|
qDebug ( "Can't recover from suspend, prepare failed: %s", snd_strerror ( ret ) );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
qDebug ( "Write error: %s", snd_strerror ( ret ) );
|
|
}
|
|
break; // skip one period
|
|
}
|
|
|
|
if ( ret > 0 )
|
|
{
|
|
size -= ret;
|
|
start += ret;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Common ***********************************************************************
|
|
bool CSound::SetHWParams ( snd_pcm_t* handle, const int iDesiredBufferSize,
|
|
const int iNumPeriodBlocks )
|
|
{
|
|
int err;
|
|
snd_pcm_hw_params_t* hwparams;
|
|
|
|
// allocate an invalid snd_pcm_hw_params_t using standard malloc
|
|
if ( err = snd_pcm_hw_params_malloc ( &hwparams ) < 0 )
|
|
{
|
|
qDebug ( "cannot allocate hardware parameter structure (%s)\n", snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// fill params with a full configuration space for a PCM
|
|
if ( err = snd_pcm_hw_params_any ( handle, hwparams ) < 0 )
|
|
{
|
|
qDebug ( "cannot initialize hardware parameter structure (%s)\n", snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// restrict a configuration space to contain only one access type:
|
|
// set the interleaved read/write format
|
|
if ( err = snd_pcm_hw_params_set_access ( handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED ) < 0 )
|
|
{
|
|
qDebug ( "Access type not available : %s", snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// restrict a configuration space to contain only one format:
|
|
// set the sample format PCM, 16 bit
|
|
if ( err = snd_pcm_hw_params_set_format ( handle, hwparams, SND_PCM_FORMAT_S16 ) < 0 )
|
|
{
|
|
qDebug ( "Sample format not available : %s", snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// restrict a configuration space to contain only one channels count:
|
|
// set the count of channels (usually stereo, 2 channels)
|
|
if ( err = snd_pcm_hw_params_set_channels ( handle, hwparams, NUM_IN_OUT_CHANNELS ) < 0 )
|
|
{
|
|
qDebug ( "Channels count (%i) not available s: %s", NUM_IN_OUT_CHANNELS, snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// restrict a configuration space to have rate nearest to a target:
|
|
// set the sample-rate
|
|
unsigned int rrate = SND_CRD_SAMPLE_RATE;
|
|
if ( err = snd_pcm_hw_params_set_rate_near ( handle, hwparams, &rrate, 0 ) < 0 )
|
|
{
|
|
qDebug ( "Rate %iHz not available : %s", rrate, snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
if ( rrate != SND_CRD_SAMPLE_RATE ) // check if rate is possible
|
|
{
|
|
qDebug ( "Rate doesn't match (requested %iHz, get %iHz)", rrate, err );
|
|
return true;
|
|
}
|
|
|
|
// set the period size
|
|
snd_pcm_uframes_t PeriodSize = iDesiredBufferSize;
|
|
if ( err = snd_pcm_hw_params_set_period_size_near ( handle, hwparams, &PeriodSize, 0 ) < 0 )
|
|
{
|
|
qDebug ( "cannot set period size (%s)\n", snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// set the buffer size and period size
|
|
snd_pcm_uframes_t BufferFrames = iDesiredBufferSize * iNumPeriodBlocks;
|
|
if ( err = snd_pcm_hw_params_set_buffer_size_near ( handle, hwparams, &BufferFrames ) < 0 )
|
|
{
|
|
qDebug ( "cannot set buffer size (%s)\n", snd_strerror ( err ) );
|
|
return true;
|
|
}
|
|
|
|
// check period and buffer size
|
|
snd_pcm_uframes_t period_size;
|
|
err = snd_pcm_hw_params_get_period_size ( hwparams, &period_size, 0 );
|
|
if ( err < 0 )
|
|
{
|
|
qDebug ( "Unable to get period size: %s\n", snd_strerror ( err ) );
|
|
}
|
|
qDebug ( "frame size: %d (desired: %d)", (int) period_size, iDesiredBufferSize );
|
|
|
|
snd_pcm_uframes_t buffer_size;
|
|
if ( err = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size ) < 0 )
|
|
{
|
|
qDebug ( "Unable to get buffer size: %s\n", snd_strerror ( err ) );
|
|
}
|
|
qDebug ( "buffer size: %d (desired: %d)", (int) buffer_size, iDesiredBufferSize * iNumPeriodBlocks );
|
|
|
|
|
|
|
|
// write the parameters to device
|
|
if ( err = snd_pcm_hw_params ( handle, hwparams ) < 0 )
|
|
{
|
|
qDebug("Unable to set hw params : %s", snd_strerror(err));
|
|
return true;
|
|
}
|
|
|
|
// clean-up
|
|
snd_pcm_hw_params_free ( hwparams );
|
|
|
|
return false;
|
|
}
|
|
|
|
void CSound::Close()
|
|
{
|
|
// read
|
|
if ( rhandle != NULL )
|
|
{
|
|
snd_pcm_close ( rhandle );
|
|
}
|
|
|
|
rhandle = NULL;
|
|
|
|
// playback
|
|
if ( phandle != NULL )
|
|
{
|
|
snd_pcm_close ( phandle );
|
|
}
|
|
|
|
phandle = NULL;
|
|
}
|
|
|
|
#endif /* WITH_SOUND */
|