KB8PMY
/
DStarRepeater
mirror of https://github.com/g4klx/DStarRepeater.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2bafb2f67c'
${ noResults }
DStarRepeater/Common/SoundCardReaderWriter.cpp

788 lines
20 KiB
Raw Blame History

/*
* Copyright (C) 2006-2010,2015 by Jonathan Naylor G4KLX
* Copyright (C) 2014 by John Wiseman, G8BPQ
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "SoundCardReaderWriter.h"
#if (defined(__APPLE__) && defined(__MACH__)) || defined(__WINDOWS__)
static int scrwCallback(const void* input, void* output, unsigned long nSamples, const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags, void* userData)
{
wxASSERT(userData != NULL);
CSoundCardReaderWriter* object = reinterpret_cast<CSoundCardReaderWriter*>(userData);
object->callback(static_cast<const wxFloat32*>(input), static_cast<wxFloat32*>(output), nSamples);
return paContinue;
}
CSoundCardReaderWriter::CSoundCardReaderWriter(const wxString& readDevice, const wxString& writeDevice, unsigned int sampleRate, unsigned int blockSize) :
m_readDevice(readDevice),
m_writeDevice(writeDevice),
m_sampleRate(sampleRate),
m_blockSize(blockSize),
m_callback(NULL),
m_id(-1),
m_stream(NULL)
{
}
CSoundCardReaderWriter::~CSoundCardReaderWriter()
{
}
wxArrayString CSoundCardReaderWriter::getReadDevices()
{
wxArrayString devices;
devices.Alloc(10);
PaError error = ::Pa_Initialize();
if (error != paNoError)
return devices;
#if defined(__WINDOWS__)
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paDirectSound);
#elif defined(__APPLE__) && defined(__MACH__)
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paCoreAudio);
#else
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paALSA);
#endif
if (apiIndex == paHostApiNotFound) {
::Pa_Terminate();
return devices;
}
PaDeviceIndex n = ::Pa_GetDeviceCount();
if (n <= 0) {
::Pa_Terminate();
return devices;
}
for (PaDeviceIndex i = 0; i < n; i++) {
const PaDeviceInfo* device = ::Pa_GetDeviceInfo(i);
if (device->hostApi != apiIndex)
continue;
if (device->maxInputChannels > 0) {
wxString name(device->name, wxConvLocal);
devices.Add(name);
}
}
::Pa_Terminate();
return devices;
}
wxArrayString CSoundCardReaderWriter::getWriteDevices()
{
wxArrayString devices;
devices.Alloc(10);
PaError error = ::Pa_Initialize();
if (error != paNoError)
return devices;
#if defined(__WINDOWS__)
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paDirectSound);
#elif defined(__APPLE__) && defined(__MACH__)
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paCoreAudio);
#else
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paALSA);
#endif
if (apiIndex == paHostApiNotFound) {
::Pa_Terminate();
return devices;
}
PaDeviceIndex n = ::Pa_GetDeviceCount();
if (n <= 0) {
::Pa_Terminate();
return devices;
}
for (PaDeviceIndex i = 0; i < n; i++) {
const PaDeviceInfo* device = ::Pa_GetDeviceInfo(i);
if (device->hostApi != apiIndex)
continue;
if (device->maxOutputChannels > 0) {
wxString name(device->name, wxConvLocal);
devices.Add(name);
}
}
::Pa_Terminate();
return devices;
}
void CSoundCardReaderWriter::setCallback(IAudioCallback* callback, int id)
{
wxASSERT(callback != NULL);
m_callback = callback;
m_id = id;
}
bool CSoundCardReaderWriter::open()
{
PaError error = ::Pa_Initialize();
if (error != paNoError) {
wxLogError(wxT("Cannot initialise PortAudio"));
return false;
}
PaStreamParameters* pParamsIn = NULL;
PaStreamParameters* pParamsOut = NULL;
PaStreamParameters paramsIn;
PaStreamParameters paramsOut;
PaDeviceIndex inDev, outDev;
bool res = convertNameToDevices(inDev, outDev);
if (!res) {
wxLogError(wxT("Cannot convert name to device"));
return false;
}
if (inDev != -1) {
const PaDeviceInfo* inInfo = ::Pa_GetDeviceInfo(inDev);
if (inInfo == NULL) {
wxLogError(wxT("Cannot get device information for the input device"));
return false;
}
paramsIn.device = inDev;
paramsIn.channelCount = 1;
paramsIn.sampleFormat = paFloat32;
paramsIn.hostApiSpecificStreamInfo = NULL;
paramsIn.suggestedLatency = inInfo->defaultLowInputLatency;
pParamsIn = &paramsIn;
}
if (outDev != -1) {
const PaDeviceInfo* outInfo = ::Pa_GetDeviceInfo(outDev);
if (outInfo == NULL) {
wxLogError(wxT("Cannot get device information for the output device"));
return false;
}
paramsOut.device = outDev;
paramsOut.channelCount = 1;
paramsOut.sampleFormat = paFloat32;
paramsOut.hostApiSpecificStreamInfo = NULL;
paramsOut.suggestedLatency = outInfo->defaultLowOutputLatency;
pParamsOut = &paramsOut;
}
error = ::Pa_OpenStream(&m_stream, pParamsIn, pParamsOut, double(m_sampleRate), m_blockSize, paNoFlag, &scrwCallback, this);
if (error != paNoError) {
wxLogError(wxT("Cannot open the audios stream(s)"));
::Pa_Terminate();
return false;
}
error = ::Pa_StartStream(m_stream);
if (error != paNoError) {
wxLogError(wxT("Cannot start the audio stream(s)"));
::Pa_CloseStream(m_stream);
m_stream = NULL;
::Pa_Terminate();
return false;
}
return true;
}
void CSoundCardReaderWriter::close()
{
wxASSERT(m_stream != NULL);
::Pa_AbortStream(m_stream);
::Pa_CloseStream(m_stream);
::Pa_Terminate();
}
void CSoundCardReaderWriter::callback(const wxFloat32* input, wxFloat32* output, unsigned int nSamples)
{
if (m_callback != NULL) {
m_callback->readCallback(input, nSamples, m_id);
m_callback->writeCallback(output, nSamples, m_id);
}
}
bool CSoundCardReaderWriter::convertNameToDevices(PaDeviceIndex& inDev, PaDeviceIndex& outDev)
{
inDev = outDev = -1;
#if defined(__WINDOWS__)
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paDirectSound);
#elif defined(__APPLE__) && defined(__MACH__)
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paCoreAudio);
#else
PaHostApiIndex apiIndex = ::Pa_HostApiTypeIdToHostApiIndex(paALSA);
#endif
if (apiIndex == paHostApiNotFound)
return false;
PaDeviceIndex n = ::Pa_GetDeviceCount();
if (n <= 0)
return false;
for (PaDeviceIndex i = 0; i < n; i++) {
const PaDeviceInfo* device = ::Pa_GetDeviceInfo(i);
if (device->hostApi != apiIndex)
continue;
wxString name(device->name, wxConvLocal);
if (!m_readDevice.IsEmpty() && m_readDevice.IsSameAs(name) && device->maxInputChannels > 0)
inDev = i;
if (!m_writeDevice.IsEmpty() && m_writeDevice.IsSameAs(name) && device->maxOutputChannels > 0)
outDev = i;
}
if (inDev == -1 && outDev == -1)
return false;
return true;
}
#else
wxArrayString CSoundCardReaderWriter::m_readDevices;
wxArrayString CSoundCardReaderWriter::m_writeDevices;
CSoundCardReaderWriter::CSoundCardReaderWriter(const wxString& readDevice, const wxString& writeDevice, unsigned int sampleRate, unsigned int blockSize) :
m_readDevice(readDevice),
m_writeDevice(writeDevice),
m_sampleRate(sampleRate),
m_blockSize(blockSize),
m_callback(NULL),
m_id(-1),
m_reader(NULL),
m_writer(NULL)
{
wxASSERT(sampleRate > 0U);
wxASSERT(blockSize > 0U);
}
CSoundCardReaderWriter::~CSoundCardReaderWriter()
{
}
wxArrayString CSoundCardReaderWriter::getReadDevices()
{
snd_ctl_t *handle = NULL;
snd_pcm_t *pcm = NULL;
char NameString[256];
wxArrayString devices(m_readDevices);
snd_ctl_card_info_t* info;
snd_ctl_card_info_alloca(&info);
snd_pcm_info_t* pcminfo;
snd_pcm_info_alloca(&pcminfo);
snd_pcm_hw_params_t* pars;
snd_pcm_hw_params_alloca(&pars);
unsigned min, max;
int err;
snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE;
int card = -1;
while (::snd_card_next(&card) == 0 && card >= 0) {
char hwdev[80];
::sprintf(hwdev, "hw:%d", card);
if (::snd_ctl_open(&handle, hwdev, 0) < 0)
continue;
::snd_ctl_card_info(handle, info);
::snd_ctl_card_info_get_name(info);
int dev = -1;
while (::snd_ctl_pcm_next_device(handle, &dev) == 0 && dev >= 0) {
::snd_pcm_info_set_device(pcminfo, dev);
::snd_pcm_info_set_subdevice(pcminfo, 0);
::snd_pcm_info_set_stream(pcminfo, stream);
err = ::snd_ctl_pcm_info(handle, pcminfo);
if (err != -ENOENT) {
::sprintf(hwdev, "hw:%d,%d", card, dev);
if (::snd_pcm_open(&pcm, hwdev, stream, SND_PCM_NONBLOCK) < 0)
continue;
::snd_pcm_hw_params_any(pcm, pars);
::snd_pcm_hw_params_get_channels_min(pars, &min);
::snd_pcm_hw_params_get_channels_max(pars, &max);
::snd_pcm_hw_params_get_rate_min(pars, &min, NULL);
::snd_pcm_hw_params_get_rate_max(pars, &max, NULL);
::sprintf(NameString, "hw:%d,%d %s(%s)",
card, dev,
::snd_pcm_info_get_name(pcminfo),
snd_ctl_card_info_get_name(info));
wxString name(NameString, wxConvLocal);
devices.Add(name);
::snd_pcm_close(pcm);
pcm = NULL;
}
}
::snd_ctl_close(handle);
}
return devices;
}
wxArrayString CSoundCardReaderWriter::getWriteDevices()
{
snd_ctl_t *handle = NULL;
snd_pcm_t *pcm = NULL;
char NameString[256];
wxArrayString devices(m_writeDevices);
snd_ctl_card_info_t* info;
snd_ctl_card_info_alloca(&info);
snd_pcm_info_t* pcminfo;
snd_pcm_info_alloca(&pcminfo);
snd_pcm_hw_params_t* pars;
snd_pcm_hw_params_alloca(&pars);
unsigned min, max;
int err;
snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
int card = -1;
while (::snd_card_next(&card) == 0 && card >= 0) {
char hwdev[80];
::sprintf(hwdev, "hw:%d", card);
if (::snd_ctl_open(&handle, hwdev, 0) < 0)
continue;
::snd_ctl_card_info(handle, info);
::snd_ctl_card_info_get_name(info);
int dev = -1;
while (::snd_ctl_pcm_next_device(handle, &dev) == 0 && dev >= 0) {
::snd_pcm_info_set_device(pcminfo, dev);
::snd_pcm_info_set_subdevice(pcminfo, 0);
::snd_pcm_info_set_stream(pcminfo, stream);
err= ::snd_ctl_pcm_info(handle, pcminfo);
if (err != -ENOENT) {
::sprintf(hwdev, "hw:%d,%d", card, dev);
if (::snd_pcm_open(&pcm, hwdev, stream, SND_PCM_NONBLOCK) < 0)
continue;
::snd_pcm_hw_params_any(pcm, pars);
::snd_pcm_hw_params_get_channels_min(pars, &min);
::snd_pcm_hw_params_get_channels_max(pars, &max);
::snd_pcm_hw_params_get_rate_min(pars, &min, NULL);
::snd_pcm_hw_params_get_rate_max(pars, &max, NULL);
::sprintf(NameString, "hw:%d,%d %s(%s)",
card, dev,
::snd_pcm_info_get_name(pcminfo),
::snd_ctl_card_info_get_name(info));
wxString name(NameString, wxConvLocal);
devices.Add(name);
::snd_pcm_close(pcm);
pcm = NULL;
}
}
::snd_ctl_close(handle);
}
return devices;
}
void CSoundCardReaderWriter::setCallback(IAudioCallback* callback, int id)
{
wxASSERT(callback != NULL);
m_callback = callback;
m_id = id;
}
bool CSoundCardReaderWriter::open()
{
int err = 0;
char buf1[100];
char buf2[100];
char* ptr;
// Store the opened devices because ALSA won't enumerate them
m_readDevices.Add(m_readDevice);
m_writeDevices.Add(m_writeDevice);
::strcpy(buf1, (const char*)m_writeDevice.mb_str(wxConvUTF8));
::strcpy(buf2, (const char*)m_readDevice.mb_str(wxConvUTF8));
ptr = ::strchr(buf1, ' ');
if (ptr) *ptr = 0; // Get Device part of name
ptr = ::strchr(buf2, ' ');
if (ptr) *ptr = 0; // Get Device part of name
wxString writeDevice(buf1, wxConvLocal);
wxString readDevice(buf2, wxConvLocal);
snd_pcm_t* playHandle = NULL;
if ((err = ::snd_pcm_open(&playHandle, buf1, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot open playback audio device %s (%s)"), writeDevice.c_str(), error.c_str());
return false;
}
snd_pcm_hw_params_t* hw_params;
if ((err = ::snd_pcm_hw_params_malloc(&hw_params)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot allocate hardware parameter structure (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_any(playHandle, hw_params)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot initialize hardware parameter structure (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_set_access(playHandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set access type (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_set_format(playHandle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set sample format (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_set_rate(playHandle, hw_params, m_sampleRate, 0)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set sample rate (%s)"), error.c_str());
return false;
}
unsigned int playChannels = 1U;
if ((err = ::snd_pcm_hw_params_set_channels(playHandle, hw_params, 1)) < 0) {
playChannels = 2U;
if ((err = ::snd_pcm_hw_params_set_channels(playHandle, hw_params, 2)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot play set channel count (%s)"), error.c_str());
return false;
}
}
if ((err = ::snd_pcm_hw_params(playHandle, hw_params)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set parameters (%s)"), error.c_str());
return false;
}
::snd_pcm_hw_params_free(hw_params);
if ((err = ::snd_pcm_prepare(playHandle)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot prepare audio interface for use (%s)"), error.c_str());
return false;
}
// Open Capture
snd_pcm_t* recHandle = NULL;
if ((err = ::snd_pcm_open(&recHandle, buf2, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot open capture audio device %s (%s)"), readDevice.c_str(), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_malloc(&hw_params)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot allocate hardware parameter structure (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_any(recHandle, hw_params)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot initialize hardware parameter structure (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_set_access(recHandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set access type (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_set_format(recHandle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set sample format (%s)"), error.c_str());
return false;
}
if ((err = ::snd_pcm_hw_params_set_rate(recHandle, hw_params, m_sampleRate, 0)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set sample rate (%s)"), error.c_str());
return false;
}
unsigned int recChannels = 1U;
if ((err = ::snd_pcm_hw_params_set_channels(recHandle, hw_params, 1)) < 0) {
recChannels = 2U;
if ((err = ::snd_pcm_hw_params_set_channels (recHandle, hw_params, 2)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot rec set channel count (%s)"), error.c_str());
return false;
}
}
if ((err = ::snd_pcm_hw_params(recHandle, hw_params)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot set parameters (%s)"), error.c_str());
return false;
}
::snd_pcm_hw_params_free(hw_params);
if ((err = ::snd_pcm_prepare(recHandle)) < 0) {
wxString error(::snd_strerror(err), wxConvLocal);
wxLogError(wxT("Cannot prepare audio interface for use (%s)"), error.c_str());
return false;
}
short samples[256];
for (unsigned int i = 0U; i < 10U; ++i)
::snd_pcm_readi(recHandle, samples, 128);
wxLogMessage(wxT("Opened %s %s Rate %u"), writeDevice.c_str(), readDevice.c_str(), m_sampleRate);
m_reader = new CSoundCardReader(recHandle, m_blockSize, recChannels, m_callback, m_id);
m_writer = new CSoundCardWriter(playHandle, m_blockSize, playChannels, m_callback, m_id);
m_reader->Create();
m_reader->Run();
m_writer->Create();
m_writer->Run();
return true;
}
void CSoundCardReaderWriter::close()
{
m_reader->kill();
m_writer->kill();
m_reader->Wait();
m_writer->Wait();
}
bool CSoundCardReaderWriter::isWriterBusy() const
{
return m_writer->isBusy();
}
CSoundCardReader::CSoundCardReader(snd_pcm_t* handle, unsigned int blockSize, unsigned int channels, IAudioCallback* callback, int id) :
wxThread(wxTHREAD_JOINABLE),
m_handle(handle),
m_blockSize(blockSize),
m_channels(channels),
m_callback(callback),
m_id(id),
m_killed(false),
m_buffer(NULL),
m_samples(NULL)
{
wxASSERT(handle != NULL);
wxASSERT(blockSize > 0U);
wxASSERT(channels == 1U || channels == 2U);
wxASSERT(callback != NULL);
m_buffer = new wxFloat32[blockSize];
m_samples = new short[2U * blockSize];
}
CSoundCardReader::~CSoundCardReader()
{
delete[] m_buffer;
delete[] m_samples;
}
void* CSoundCardReader::Entry()
{
wxLogMessage(wxT("Starting ALSA reader thread"));
while (!m_killed) {
snd_pcm_sframes_t ret;
while ((ret = ::snd_pcm_readi(m_handle, m_samples, m_blockSize)) < 0) {
if (ret != -EPIPE) {
wxString error(::snd_strerror(ret), wxConvLocal);
wxLogWarning(wxT("snd_pcm_readi returned %d (%s)"), ret, error.c_str());
}
::snd_pcm_recover(m_handle, ret, 1);
}
if (m_channels == 1U) {
for (int n = 0; n < ret; n++)
m_buffer[n] = wxFloat32(m_samples[n]) / 32768.0F;
} else {
int i = 0;
for (int n = 0; n < (ret * 2); n += 2)
m_buffer[i++] = wxFloat32(m_samples[n + 1]) / 32768.0F;
}
m_callback->readCallback(m_buffer, (unsigned int)ret, m_id);
}
wxLogMessage(wxT("Stopping ALSA reader thread"));
::snd_pcm_close(m_handle);
return NULL;
}
void CSoundCardReader::kill()
{
m_killed = true;
}
CSoundCardWriter::CSoundCardWriter(snd_pcm_t* handle, unsigned int blockSize, unsigned int channels, IAudioCallback* callback, int id) :
wxThread(wxTHREAD_JOINABLE),
m_handle(handle),
m_blockSize(blockSize),
m_channels(channels),
m_callback(callback),
m_id(id),
m_killed(false),
m_buffer(NULL),
m_samples(NULL)
{
wxASSERT(handle != NULL);
wxASSERT(blockSize > 0U);
wxASSERT(channels == 1U || channels == 2U);
wxASSERT(callback != NULL);
m_buffer = new wxFloat32[2U * blockSize];
m_samples = new short[4U * blockSize];
}
CSoundCardWriter::~CSoundCardWriter()
{
delete[] m_buffer;
delete[] m_samples;
}
void* CSoundCardWriter::Entry()
{
wxLogMessage(wxT("Starting ALSA writer thread"));
while (!m_killed) {
int nSamples = 2U * m_blockSize;
m_callback->writeCallback(m_buffer, nSamples, m_id);
if (nSamples == 0U) {
Sleep(5UL);
} else {
if (m_channels == 1U) {
for (int n = 0U; n < nSamples; n++)
m_samples[n] = short(m_buffer[n] * 32767.0F);
} else {
int i = 0U;
for (int n = 0U; n < nSamples; n++) {
short sample = short(m_buffer[n] * 32767.0F);
m_samples[i++] = sample;
m_samples[i++] = sample; // Same value to both channels
}
}
int offset = 0U;
snd_pcm_sframes_t ret;
while ((ret = ::snd_pcm_writei(m_handle, m_samples + offset, nSamples - offset)) != (nSamples - offset)) {
if (ret < 0) {
if (ret != -EPIPE) {
wxString error(::snd_strerror(ret), wxConvLocal);
wxLogWarning(wxT("snd_pcm_writei returned %d (%s)"), ret, error.c_str());
}
::snd_pcm_recover(m_handle, ret, 1);
} else {
offset += ret;
}
}
}
}
wxLogMessage(wxT("Stopping ALSA writer thread"));
::snd_pcm_close(m_handle);
return NULL;
}
void CSoundCardWriter::kill()
{
m_killed = true;
}
bool CSoundCardWriter::isBusy() const
{
snd_pcm_state_t state = ::snd_pcm_state(m_handle);
return state == SND_PCM_STATE_RUNNING || state == SND_PCM_STATE_DRAINING;
}
#endif
Reference in new issue View Git Blame Copy Permalink

Powered by TurnKey Linux.