void OpenALController::record() {
ALubyte *captureBufPtr;
qDebug() << "Starting capture NOW!";
m_samplesCaptured = 0;
captureBufPtr = m_captureBuffer;
this->setRecording(true);
alcCaptureStart(m_captureDev);
alcGetIntegerv(m_captureDev, ALC_CAPTURE_SAMPLES,
(ALCsizei) sizeof(ALubyte), &m_samplesAvailable);
while (m_samplesCaptured < FREQ * 5) {
if (0 < m_samplesAvailable && m_samplesAvailable <= FREQ) {
alcCaptureSamples(m_captureDev, captureBufPtr, m_samplesAvailable);
checkError("alcCaptureSamples");
m_samplesCaptured += m_samplesAvailable;
//qDebug()
// <<qPrintable(QString("Captured %1 samples (adding %2)\n").arg(m_samplesCaptured).arg(m_samplesAvailable));
// Advance the buffer (two bytes per sample * number of samples)
captureBufPtr += m_samplesAvailable * 2;
} else {
qDebug() << "No captured samples:" << m_samplesAvailable;
}
// Wait for a bit
//alutSleep(0.02);
printf(".");
fflush(stdout);
alcGetIntegerv(m_captureDev, ALC_CAPTURE_SAMPLES,
(ALCsizei) sizeof(ALubyte), &m_samplesAvailable);
}
qDebug() << "\nDone capturing.\n";
alcCaptureStop(m_captureDev);
this->setRecording(false);
}
void *encode_audio_thread(void *arg)
{
INFO("Started encode audio thread!");
av_session_t *_phone = arg;
_phone->running_encaud = 1;
int ret = 0;
int16_t frame[4096];
int frame_size = AUDIO_FRAME_SIZE;
ALint sample = 0;
alcCaptureStart((ALCdevice *)_phone->audio_capture_device);
while (_phone->running_encaud) {
alcGetIntegerv((ALCdevice *)_phone->audio_capture_device, ALC_CAPTURE_SAMPLES, (ALCsizei)sizeof(ALint), &sample);
if (sample >= frame_size) {
alcCaptureSamples((ALCdevice *)_phone->audio_capture_device, frame, frame_size);
ret = toxav_send_audio(_phone->av, frame, frame_size);
if (ret < 0) printf("Could not encode or send audio packet\n");
} else {
usleep(1000);
}
}
/* clean up codecs *
pthread_mutex_lock(&cs->ctrl_mutex);* /
alcCaptureStop((ALCdevice*)_phone->audio_capture_device);
alcCaptureCloseDevice((ALCdevice*)_phone->audio_capture_device);
/ *pthread_mutex_unlock(&cs->ctrl_mutex);*/
_phone->running_encaud = -1;
pthread_exit ( NULL );
}
bool OpenAL::initInput(const QString& deviceName)
{
if (!Settings::getInstance().getAudioInDevEnabled())
return false;
qDebug() << "Opening audio input" << deviceName;
assert(!alInDev);
// TODO: Try to actually detect if our audio source is stereo
int stereoFlag = AUDIO_CHANNELS == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
const uint32_t sampleRate = AUDIO_SAMPLE_RATE;
const uint16_t frameDuration = AUDIO_FRAME_DURATION;
const uint32_t chnls = AUDIO_CHANNELS;
const ALCsizei bufSize = (frameDuration * sampleRate * 4) / 1000 * chnls;
const QByteArray qDevName = deviceName.toUtf8();
const ALchar* tmpDevName = qDevName.isEmpty() ? nullptr : qDevName.constData();
alInDev = alcCaptureOpenDevice(tmpDevName, sampleRate, stereoFlag, bufSize);
// Restart the capture if necessary
if (!alInDev) {
qWarning() << "Failed to initialize audio input device:" << deviceName;
return false;
}
setInputGain(Settings::getInstance().getAudioInGainDecibel());
qDebug() << "Opened audio input" << deviceName;
alcCaptureStart(alInDev);
return true;
}
void Core::prepareCall(int friendId, int callId, ToxAv* toxav, bool videoEnabled)
{
qDebug() << QString("Core: preparing call %1").arg(callId);
calls[callId].callId = callId;
calls[callId].friendId = friendId;
calls[callId].muteMic = false;
// the following three lines are also now redundant from startCall, but are
// necessary there for outbound and here for inbound
calls[callId].codecSettings = av_DefaultSettings;
calls[callId].codecSettings.max_video_width = TOXAV_MAX_VIDEO_WIDTH;
calls[callId].codecSettings.max_video_height = TOXAV_MAX_VIDEO_HEIGHT;
calls[callId].videoEnabled = videoEnabled;
toxav_prepare_transmission(toxav, callId, av_jbufdc, av_VADd, videoEnabled);
// Audio
alGenSources(1, &calls[callId].alSource);
alcCaptureStart(alInDev);
// Go
calls[callId].active = true;
calls[callId].sendAudioTimer->setInterval(5);
calls[callId].sendAudioTimer->setSingleShot(true);
connect(calls[callId].sendAudioTimer, &QTimer::timeout, [=](){sendCallAudio(callId,toxav);});
calls[callId].sendAudioTimer->start();
calls[callId].sendVideoTimer->setInterval(50);
calls[callId].sendVideoTimer->setSingleShot(true);
if (calls[callId].videoEnabled)
{
calls[callId].sendVideoTimer->start();
Widget::getInstance()->getCamera()->suscribe();
}
}
static void alccapturestart(void *handle) {
if(handle == (void*)1) {
audio_init(handle);
return;
}
alcCaptureStart(handle);
}
AudioAnalyzer::AudioAnalyzer(int frequency_, int captureSize_) :
frequency(frequency_), captureSize(captureSize_), initialized(false)
{
ALenum errorCode=0;
inputDevice = alcCaptureOpenDevice(NULL, frequency, AL_FORMAT_MONO16, frequency/2);
if (inputDevice == NULL) {
Logger::Instance()->OutputString("Error: alcCaptureOpenDevice");
return;
}
errorCode = alcGetError(inputDevice);
if (errorCode != AL_NO_ERROR) {
Logger::Instance()->OutputString("Error: alcCaptureOpenDevice -- ?");
return;
}
alcCaptureStart(inputDevice); // Begin capturing
errorCode = alcGetError(inputDevice);
if (errorCode != AL_NO_ERROR) {
Logger::Instance()->OutputString("Error: alcCaptureStart");
alcCaptureCloseDevice(inputDevice);
return;
}
capturedBuffer = new short[captureSize];
ffted = new float[captureSize];
ar = new float[captureSize];
ai = new float[captureSize];
initialized = true;
Logger::Instance()->OutputString("OpenAL succeeded");
}
// Executed inside the worker-thread.
// It is not safe to access V8, or V8 data structures
// here, so everything we need for input and output
// should go on `this`.
void ALCaptureWorker::Execute(const ExecutionProgress& progress)
{
ALCint samplesIn = 0;
alcCaptureStart(device);
while(*this->capturing)
{
alcGetIntegerv(device, ALC_CAPTURE_SAMPLES, 1, &samplesIn);
if (samplesIn > CAPTURE_SIZE) {
int sampleSize = CAPTURE_SIZE * sizeof(short);
char* captured = (char*)malloc(sampleSize);
alcCaptureSamples(device, captured, CAPTURE_SIZE);
if (*this->capturing)
{
progress.Send(captured, sampleSize);
}
delete captured;
}
sleep_ms(1);
}
}
static gboolean
gst_openal_src_prepare (GstAudioSrc * audiosrc, GstAudioRingBufferSpec * spec)
{
GstOpenalSrc *openalsrc = GST_OPENAL_SRC (audiosrc);
gst_openal_src_parse_spec (openalsrc, spec);
if (openalsrc->format == AL_NONE) {
GST_ELEMENT_ERROR (openalsrc, RESOURCE, SETTINGS, (NULL),
("Unable to get type %d, format %d, and %d channels", spec->type,
GST_AUDIO_INFO_FORMAT (&spec->info),
GST_AUDIO_INFO_CHANNELS (&spec->info)));
return FALSE;
}
openalsrc->device =
alcCaptureOpenDevice (openalsrc->default_device, openalsrc->rate,
openalsrc->format, openalsrc->buffer_length);
if (!openalsrc->device) {
GST_ELEMENT_ERROR (openalsrc, RESOURCE, OPEN_READ,
("Could not open device."), GST_ALC_ERROR (openalsrc->device));
return FALSE;
}
openalsrc->default_device_name =
g_strdup (alcGetString (openalsrc->device, ALC_DEVICE_SPECIFIER));
alcCaptureStart (openalsrc->device);
return TRUE;
}
bool RecordingDevice::start(int samples, int sampleRate, int bitDepth, int channels)
{
ALenum format = Audio::getFormat(bitDepth, channels);
if (format == AL_NONE)
throw InvalidFormatException(channels, bitDepth);
if (samples <= 0)
throw love::Exception("Invalid number of samples.");
if (sampleRate <= 0)
throw love::Exception("Invalid sample rate.");
if (isRecording())
stop();
device = alcCaptureOpenDevice(name.c_str(), sampleRate, format, samples);
if (device == nullptr)
return false;
alcCaptureStart(device);
this->samples = samples;
this->sampleRate = sampleRate;
this->bitDepth = bitDepth;
this->channels = channels;
return true;
}
void* recAndSend(void * param){
ALshort alrecBuffer[SAMPLESIZE];
ALint alSample;
ALCdevice* device = alcOpenDevice(NULL);
ALCcontext* context = alcCreateContext(device, NULL);
alcMakeContextCurrent(context);
ALCdevice* alDevice = alcCaptureOpenDevice(NULL, SRATE, AL_FORMAT_MONO16, SAMPLESIZE);
alcGetError(alDevice);
alcCaptureStart(alDevice);
alcGetError(alDevice);
while (1){
alcGetIntegerv(alDevice, ALC_CAPTURE_SAMPLES, (ALCsizei)sizeof(ALint), &alSample);
alcGetError(alDevice);
if(alSample > SAMPLESIZE/2) {
alcCaptureSamples(alDevice, (ALCvoid *)alrecBuffer, alSample);
int n;
socklen_t addrlen = sizeof(senderinfo);
int i;
for(i=0; i<alSample; i++){
if(abs((int)alrecBuffer[i]) > (0.8*INT16_MAX) ) break;
}
if(i==alSample) continue;
if((n = sendto(sock, alrecBuffer, alSample*2, 0, (struct sockaddr *)&senderinfo, addrlen)) != alSample*2){
perror("sendto");
exit(1);
}
}
if(callFlag==OFF) break;
}
alcCaptureCloseDevice(alDevice);
alcCaptureStop(alDevice);
alcCloseDevice(device);
// fprintf(stderr, "close recAndSend\n");
}
bool SoundRecorder::setDevice(const std::string& name)
{
// Store the device name
if (name.empty())
m_deviceName = getDefaultDevice();
else
m_deviceName = name;
if (m_isCapturing)
{
// Stop the capturing thread
m_isCapturing = false;
m_thread.wait();
// Open the requested capture device for capturing 16 bits mono samples
captureDevice = alcCaptureOpenDevice(name.c_str(), m_sampleRate, AL_FORMAT_MONO16, m_sampleRate);
if (!captureDevice)
{
// Notify derived class
onStop();
err() << "Failed to open the audio capture device with the name: " << m_deviceName << std::endl;
return false;
}
// Start the capture
alcCaptureStart(captureDevice);
// Start the capture in a new thread, to avoid blocking the main thread
m_isCapturing = true;
m_thread.launch();
}
return true;
}
void Audio::openInput(const QString& inDevDescr)
{
auto* tmp = alInDev;
alInDev = nullptr;
if (tmp)
alcCaptureCloseDevice(tmp);
int stereoFlag = av_DefaultSettings.audio_channels==1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
if (inDevDescr.isEmpty())
alInDev = alcCaptureOpenDevice(nullptr,av_DefaultSettings.audio_sample_rate, stereoFlag,
(av_DefaultSettings.audio_frame_duration * av_DefaultSettings.audio_sample_rate * 4)
/ 1000 * av_DefaultSettings.audio_channels);
else
alInDev = alcCaptureOpenDevice(inDevDescr.toStdString().c_str(),av_DefaultSettings.audio_sample_rate, stereoFlag,
(av_DefaultSettings.audio_frame_duration * av_DefaultSettings.audio_sample_rate * 4)
/ 1000 * av_DefaultSettings.audio_channels);
if (!alInDev)
qWarning() << "Audio: Cannot open input audio device";
else
qDebug() << "Audio: Opening audio input "<<inDevDescr;
Core::getInstance()->resetCallSources(); // Force to regen each group call's sources
// Restart the capture if necessary
if (userCount.load() != 0 && alInDev)
alcCaptureStart(alInDev);
}
void OpenALController::recordToStreamBuffer(qint16 *samples, int frame_size,
int nb_channels) {
//qDebug() << "Starting capture NOW!";
Q_UNUSED(nb_channels);
int samplesCaptured = 0, samplesAvailable = 0;
qint16 * captureBufPtr;
captureBufPtr = samples;
//this->setRecording(true);
alcCaptureStart(m_captureDev);
alcGetIntegerv(m_captureDev, ALC_CAPTURE_SAMPLES,
(ALCsizei) sizeof(qint16), &samplesAvailable);
int samplesToCopy = frame_size - samplesCaptured;
while (samplesCaptured < frame_size) {
if (samplesAvailable > 0 && samplesToCopy > samplesAvailable) {
samplesToCopy = samplesAvailable;
}
alcCaptureSamples(m_captureDev, captureBufPtr, samplesToCopy);
checkError("alcCaptureSamples");
samplesCaptured += samplesToCopy;
///* Advance the buffer (two bytes per sample * number of samples) */
captureBufPtr += samplesToCopy;// * 2;
alcGetIntegerv(m_captureDev, ALC_CAPTURE_SAMPLES,
(ALCsizei) sizeof(ALubyte), &samplesAvailable);
}
//qDebug() << "oal:" << frame_size;;
//qDebug() << "\nDone capturing. samples captured:" << accum;
/*alcCaptureStop(m_captureDev); */
//this->setRecording(false);
}
/**
Open an input device, use before suscribing
*/
void Audio::openInput(const QString& inDevDescr)
{
QMutexLocker lock(&audioInLock);
if (alInDev) {
#if (!FIX_SND_PCM_PREPARE_BUG)
qDebug() << "stopping capture";
alcCaptureStop(alInDev);
#endif
alcCaptureCloseDevice(alInDev);
}
alInDev = nullptr;
/// TODO: Try to actually detect if our audio source is stereo
int stereoFlag = AUDIO_CHANNELS == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
const uint32_t sampleRate = AUDIO_SAMPLE_RATE;
const uint16_t frameDuration = AUDIO_FRAME_DURATION;
const uint32_t chnls = AUDIO_CHANNELS;
const ALCsizei bufSize = (frameDuration * sampleRate * 4) / 1000 * chnls;
if (inDevDescr.isEmpty())
alInDev = alcCaptureOpenDevice(nullptr, sampleRate, stereoFlag, bufSize);
else
alInDev = alcCaptureOpenDevice(inDevDescr.toStdString().c_str(),
sampleRate, stereoFlag, bufSize);
if (alInDev)
qDebug() << "Opening audio input "<<inDevDescr;
else
qWarning() << "Cannot open input audio device " + inDevDescr;
Core* core = Core::getInstance();
if (core)
core->getAv()->resetCallSources(); // Force to regen each group call's sources
// Restart the capture if necessary
if (alInDev)
{
alcCaptureStart(alInDev);
}
else
{
#if (FIX_SND_PCM_PREPARE_BUG)
alcCaptureStart(alInDev);
#endif
}
}
void AudioRecorder::startRecord()
{
initRecorder(m_filePath.toUtf8().data());
m_recordDevice = alcCaptureOpenDevice(NULL, 16000, AL_FORMAT_MONO16, 1024 * 8);
alcCaptureStart(m_recordDevice);
m_updateRecordTimer.start(20);
}
int main()
{
unsigned int sample_rate = 48000;
unsigned int samples_perframe = sample_rate/50;
_Bool filter = 1;
const char *in_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
const char *temp_d = in_device_list;
while (*temp_d) {
printf("%s\n", temp_d);
temp_d += strlen(temp_d) + 1;
}
ALCdevice *device_in = alcCaptureOpenDevice(in_device_list, sample_rate, AL_FORMAT_MONO16, samples_perframe);
if (!device_in) {
printf("open in dev failed\n");
return 0;
}
const char *out_device_list = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
ALCdevice *device_out = alcOpenDevice(out_device_list);
ALCcontext *context = alcCreateContext(device_out, NULL);
if(!alcMakeContextCurrent(context)) {
printf("alcMakeContextCurrent() failed\n");
alcCloseDevice(device_out);
return 0;
}
Filter_Audio *f_a = new_filter_audio(sample_rate);
ALuint source;
alGenSources(1, &source);
alcCaptureStart(device_in);
printf("Starting\n");
while (1) {
ALint samples;
alcGetIntegerv(device_in, ALC_CAPTURE_SAMPLES, sizeof(samples), &samples);
//printf("%u\n", samples);
if(samples >= samples_perframe) {
int16_t buf[samples_perframe];
alcCaptureSamples(device_in, buf, samples_perframe);
if (filter && filter_audio(f_a, buf, samples_perframe) == -1) {
printf("filter_audio fail\n");
return 0;
}
sourceplaybuffer(source, buf, samples_perframe, 1, sample_rate);
}
usleep(1000);
}
return 0;
}
/**
Open an input device, use before suscribing
*/
void Audio::openInput(const QString& inDevDescr)
{
QMutexLocker lock(&audioInLock);
if (alInDev) {
#if (!FIX_SND_PCM_PREPARE_BUG)
qDebug() << "stopping capture";
alcCaptureStop(alInDev);
#endif
alcCaptureCloseDevice(alInDev);
}
alInDev = nullptr;
int stereoFlag = av_DefaultSettings.audio_channels==1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
const uint32_t sampleRate = av_DefaultSettings.audio_sample_rate;
const uint16_t frameDuration = av_DefaultSettings.audio_frame_duration;
const uint32_t chnls = av_DefaultSettings.audio_channels;
const ALCsizei bufSize = (frameDuration * sampleRate * 4) / 1000 * chnls;
if (inDevDescr.isEmpty())
alInDev = alcCaptureOpenDevice(nullptr, sampleRate, stereoFlag, bufSize);
else
alInDev = alcCaptureOpenDevice(inDevDescr.toStdString().c_str(),
sampleRate, stereoFlag, bufSize);
if (alInDev)
qDebug() << "Opening audio input "<<inDevDescr;
else
qWarning() << "Cannot open input audio device " + inDevDescr;
Core* core = Core::getInstance();
if (core)
core->resetCallSources(); // Force to regen each group call's sources
// Restart the capture if necessary
if (alInDev)
{
alcCaptureStart(alInDev);
}
else
{
#if (FIX_SND_PCM_PREPARE_BUG)
alcCaptureStart(alInDev);
#endif
}
}
int CaptureStreamT::Read(unsigned char* Buffer, unsigned int Size)
{
const unsigned int MAX_WRITE_SAMPLES=Size/BytesPerSample(m_FORMAT);
// If this is the first read after initialization or a rewind, start capturing now.
// When capturing has been stopped before and is restarted here, GetNumCaptureSamples() should return 0,
// just as if it had been started for the first time. See Rewind() for more information.
if (!m_IsCapturing)
{
alcCaptureStart(m_CaptureDevice);
m_IsCapturing=true;
}
// std::cout << "\n" << __FUNCTION__ << "():\n" << " "; PrintDebug();
// If there are not enough "live" capture samples available, fill-in zeros until
// the buffer is half full. This gives the device the chance to capture more data.
if (GetNumCaptureSamples() < m_MAX_CAPTURE_BUFFER_SAMPLES/8)
{
m_ZeroSamples=m_MAX_CAPTURE_BUFFER_SAMPLES/2-GetNumCaptureSamples();
// std::cout << " + ... "; PrintDebug();
}
// If the capture buffer is too full, we have probably lost data already.
// In order to prevent this from happening over and over again, reduce it to half its size.
if (m_ZeroSamples+GetNumCaptureSamples() >= m_MAX_CAPTURE_BUFFER_SAMPLES)
{
m_ZeroSamples=0;
ReduceSamplesTo(m_MAX_CAPTURE_BUFFER_SAMPLES/2 + MAX_WRITE_SAMPLES);
// std::cout << " - ... "; PrintDebug();
}
// Write the leading zero samples.
unsigned int SamplesWritten=std::min(m_ZeroSamples, MAX_WRITE_SAMPLES);
memset(Buffer, 0, SamplesWritten*BytesPerSample(m_FORMAT));
m_ZeroSamples-=SamplesWritten;
// Write the samples with real, live, captured data.
if (GetNumCaptureSamples()>0 && SamplesWritten<MAX_WRITE_SAMPLES)
{
const unsigned int NumLive=std::min(GetNumCaptureSamples(), MAX_WRITE_SAMPLES-SamplesWritten);
alcCaptureSamples(m_CaptureDevice, &Buffer[SamplesWritten*BytesPerSample(m_FORMAT)], NumLive);
SamplesWritten+=NumLive;
}
// std::cout << " " << SamplesWritten << " samples written,\n" << " = "; PrintDebug();
return SamplesWritten*BytesPerSample(m_FORMAT);
}
void SoundController::setIsRecording(bool isit)
{
if (isRecording == isit) return;
isRecording = isit;
if (!captureDevice) return;
if (isRecording)
alcCaptureStart(captureDevice);
else
alcCaptureStop(captureDevice);
}
color_organ_t *color_organ_init(double sample_rate, size_t capturebuf_size) {
color_organ_t *c = malloc(sizeof(color_organ_t));
c->mic = alcCaptureOpenDevice(NULL, (ALCuint) sample_rate, AL_FORMAT_MONO16, (ALCsizei) capturebuf_size);
if (alGetError() != AL_NO_ERROR) {
return NULL;
}
c->capturebuf_size = capturebuf_size;
c->capture_buf = malloc(capturebuf_size * sizeof(int16_t));
alcCaptureStart(c->mic);
return c;
}
bool SoundRecorder::start(unsigned int sampleRate)
{
// Check if the device can do audio capture
if (!isAvailable())
{
err() << "Failed to start capture: your system cannot capture audio data (call SoundRecorder::isAvailable to check it)" << std::endl;
return false;
}
// Check that another capture is not already running
if (captureDevice)
{
err() << "Trying to start audio capture, but another capture is already running" << std::endl;
return false;
}
// Determine the recording format
ALCenum format = (m_channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
// Open the capture device for capturing 16 bits samples
captureDevice = alcCaptureOpenDevice(m_deviceName.c_str(), sampleRate, format, sampleRate);
if (!captureDevice)
{
err() << "Failed to open the audio capture device with the name: " << m_deviceName << std::endl;
return false;
}
// Clear the array of samples
m_samples.clear();
// Store the sample rate
m_sampleRate = sampleRate;
// Notify derived class
if (onStart())
{
// Start the capture
alcCaptureStart(captureDevice);
// Start the capture in a new thread, to avoid blocking the main thread
m_isCapturing = true;
m_thread.launch();
return true;
}
return false;
}
/**
@brief Subscribe to capture sound from the opened input device.
If the input device is not open, it will be opened before capturing.
*/
void Audio::subscribeInput()
{
qDebug() << "subscribing input" << inputSubscriptions;
if (!inputSubscriptions++)
{
openInput(Settings::getInstance().getInDev());
openOutput(Settings::getInstance().getOutDev());
#if (!FIX_SND_PCM_PREPARE_BUG)
if (alInDev)
{
qDebug() << "starting capture";
alcCaptureStart(alInDev);
}
#endif
}
}
static gboolean
gst_openal_src_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
{
GstOpenalSrc *osrc = GST_OPENAL_SRC (asrc);
ALenum format;
guint64 bufferSize;
switch (spec->width) {
case 8:
format = AL_FORMAT_STEREO8;
break;
case 16:
format = AL_FORMAT_STEREO16;
break;
default:
g_assert_not_reached ();
}
bufferSize =
spec->buffer_time * spec->rate * spec->bytes_per_sample / 1000000;
GST_INFO_OBJECT (osrc, "Open device : %s", osrc->deviceName);
osrc->deviceHandle =
alcCaptureOpenDevice (osrc->device, spec->rate, format, bufferSize);
if (!osrc->deviceHandle) {
GST_ELEMENT_ERROR (osrc,
RESOURCE,
FAILED,
("Can't open device \"%s\"", osrc->device),
("Can't open device \"%s\"", osrc->device)
);
return FALSE;
}
osrc->deviceName =
g_strdup (alcGetString (osrc->deviceHandle, ALC_DEVICE_SPECIFIER));
osrc->bytes_per_sample = spec->bytes_per_sample;
GST_INFO_OBJECT (osrc, "Start capture");
alcCaptureStart (osrc->deviceHandle);
return TRUE;
}
void Audio::suscribeInput()
{
if (!alInDev)
{
qWarning()<<"input device is closed";
return;
}
qDebug() << "suscribing input";
QMutexLocker lock(audioInLock);
if (!userCount++ && alInDev)
{
#if (!FIX_SND_PCM_PREPARE_BUG)
qDebug() << "starting capture";
alcCaptureStart(alInDev);
#endif
}
}
SoundController::SoundController(Controller *aController) : controller(aController)
{
device = alcOpenDevice(NULL);
if (!device) throw std::runtime_error("Could not open sound device.");
context = alcCreateContext(device, NULL);
if (!context) throw std::runtime_error("Could not create sound context.");
alcMakeContextCurrent(context);
alListenerf(AL_GAIN, 1.0f);
capturedNoiseLevel = 0;
// Sound capture
captureDevice = alcCaptureOpenDevice(NULL, 44000, AL_FORMAT_MONO8, 2000);
if (captureDevice) alcCaptureStart(captureDevice);
isRecording = true;
}
AUD_NAMESPACE_BEGIN
OpenALReader::OpenALReader(Specs specs, int buffersize) :
m_specs(specs),
m_position(0),
m_device(nullptr)
{
if((specs.channels != CHANNELS_MONO) && (specs.channels != CHANNELS_STEREO))
specs.channels = CHANNELS_MONO;
m_device = alcCaptureOpenDevice(nullptr, specs.rate,
specs.channels == CHANNELS_MONO ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
buffersize * specs.channels * 2);
if(!m_device)
AUD_THROW(DeviceException, "The capture device couldn't be opened with OpenAL.");
alcCaptureStart(m_device);
}
bool cAudioCapture::beginCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(!Capturing)
{
CaptureBuffer.clear();
if(CaptureDevice && Ready)
{
alcCaptureStart(CaptureDevice);
Capturing = true;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Started.");
signalEvent(ON_BEGINCAPTURE);
}
checkError();
return Capturing;
}
checkError();
return false;
}
int psm_record::start(int gap, int rate){
alGetError();
int channels = AL_MONO_SOFT;
int type = AL_SHORT_SOFT;
context_ = &rc_;
context_->gap = gap;
context_->channels = channels;
context_->type = type;
context_->rate = rate;
int SSIZE = rate * FramesToBytes(1, channels, type) * 1/*1000ms, samples bytes*/;
context_->format = GetFormat(channels, type, alIsBufferFormatSupportedSOFT);
ALCdevice *device = alcCaptureOpenDevice(NULL, context_->rate, context_->format, SSIZE);
if (alGetError() != AL_NO_ERROR) {
return -1;
}
alcCaptureStart(device);
context_->device = device;
return 0;
}
void SoundRecorder::start(unsigned int sampleRate)
{
// Check if the device can do audio capture
if (!isAvailable())
{
err() << "Failed to start capture : your system cannot capture audio data (call SoundRecorder::IsAvailable to check it)" << std::endl;
return;
}
// Check that another capture is not already running
if (captureDevice)
{
err() << "Trying to start audio capture, but another capture is already running" << std::endl;
return;
}
// Open the capture device for capturing 16 bits mono samples
captureDevice = alcCaptureOpenDevice(NULL, sampleRate, AL_FORMAT_MONO16, sampleRate);
if (!captureDevice)
{
err() << "Failed to open the audio capture device" << std::endl;
return;
}
// Clear the array of samples
m_samples.clear();
// Store the sample rate
m_sampleRate = sampleRate;
// Notify derived class
if (onStart())
{
// Start the capture
alcCaptureStart(captureDevice);
// Start the capture in a new thread, to avoid blocking the main thread
m_isCapturing = true;
m_thread.launch();
}
}
void plVoiceRecorder::SetMikeOpen(hsBool b)
{
ALCdevice *device = plgAudioSys::GetCaptureDevice();
if (fRecording && device)
{
if (b)
{
alcCaptureStart(device);
}
else
{
alcCaptureStop(device);
}
DrawTalkIcon(b);
fMikeOpen = b;
}
else
{
DrawDisabledIcon(b); // voice recording is unavailable or disabled
}
}
