All Classes Functions Properties
volumepeakdetector.cpp
/*
* Copyright (C) 2012, 2013 Canonical, Ltd.
*
* 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; version 3.
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#include "volumepeakdetector.h"
static void stream_read_callback(pa_stream * /*s*/, size_t /*length*/, void *userdata) {
PulseAudioVolumePeakDetector *peakDetector = static_cast<PulseAudioVolumePeakDetector *>(userdata);
peakDetector->processData();
}
static void context_state_callback(pa_context *c, void *userdata) {
PulseAudioVolumePeakDetector *peakDetector = static_cast<PulseAudioVolumePeakDetector *>(userdata);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY:
peakDetector->startStream();
break;
case PA_CONTEXT_TERMINATED:
case PA_CONTEXT_FAILED:
default:
peakDetector->quit();
}
}
PulseAudioVolumePeakDetector::PulseAudioVolumePeakDetector()
: m_accumulatedValue(0)
, m_nAccumulatedValues(0)
, m_accumulatedValuesLimit(1)
, m_context(NULL)
, m_mainloop_api(NULL)
, m_stream(NULL)
{
}
void PulseAudioVolumePeakDetector::start()
{
pa_mainloop *mainloop = NULL;
/* Set up a new main loop */
mainloop = pa_mainloop_new();
if (!mainloop)
return;
m_mainloop_api = pa_mainloop_get_api(mainloop);
/* Create a new connection context */
m_context = pa_context_new(m_mainloop_api, NULL);
if (!m_context) {
goto quit;
}
pa_context_set_state_callback(m_context, context_state_callback, this);
/* Connect the context */
if (pa_context_connect(m_context, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) {
goto quit;
}
/* Run the main loop */
if (pa_mainloop_run(mainloop, NULL) < 0) {
goto quit;
}
quit:
if (m_stream)
pa_stream_unref(m_stream);
if (m_context)
pa_context_unref(m_context);
if (mainloop) {
pa_signal_done();
pa_mainloop_free(mainloop);
}
QThread::currentThread()->quit();
}
int PulseAudioVolumePeakDetector::nAccumulatedValuesLimit() const
{
return m_accumulatedValuesLimit;
}
void PulseAudioVolumePeakDetector::setNAccumulatedValuesLimit(int limit)
{
m_accumulatedValuesLimit = limit;
}
// FIXME 16000 is hardcoded because julius needs it
// and the hardware/driver/pulse something gets confused
// if we use different rates
// We would be happier with a much smaller value like 100
static uint voice_needed_rate = 16000;
void PulseAudioVolumePeakDetector::startStream()
{
pa_buffer_attr buffer_attr;
pa_proplist *proplist = pa_proplist_new();
// FIXME 16000 is hardcoded because julius needs it
// and the hardware/driver/pulse something gets confused
// if we use different rates
// We would be happier with a much smaller value like 100
pa_sample_spec sample_spec;
sample_spec.format = PA_SAMPLE_FLOAT32;
sample_spec.rate = 16000;
sample_spec.channels = 1;
pa_channel_map channel_map;
pa_channel_map_init_extend(&channel_map, sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
pa_proplist_sets(proplist, PA_PROP_MEDIA_NAME, "HUD Peak Detector");
m_stream = pa_stream_new_with_proplist(m_context, NULL, &sample_spec, &channel_map, proplist);
if (!m_stream) {
pa_proplist_free(proplist);
quit();
return;
}
pa_proplist_free(proplist);
pa_stream_set_read_callback(m_stream, stream_read_callback, this);
memset(&buffer_attr, 0, sizeof(buffer_attr));
buffer_attr.maxlength = (uint32_t) -1;
buffer_attr.fragsize = sizeof(float);
if (pa_stream_connect_record(m_stream, NULL, &buffer_attr, (pa_stream_flags_t)(PA_STREAM_PEAK_DETECT | PA_STREAM_ADJUST_LATENCY)) < 0) {
quit();
}
}
void PulseAudioVolumePeakDetector::processData()
{
while (pa_stream_readable_size(m_stream) > 0) {
const void *data;
size_t length;
if (pa_stream_peek(m_stream, &data, &length) < 0) {
quit();
return;
}
const float *values = (float*)data;
for (size_t i = 0; i < length / sizeof(float); ++i) {
float value = values[i];
if (value < 0) value = 0;
if (value > 1) value = 1;
m_nAccumulatedValues++;
m_accumulatedValue += value;
if (m_nAccumulatedValues == m_accumulatedValuesLimit) {
Q_EMIT newPeak(m_accumulatedValue / m_nAccumulatedValues);
m_nAccumulatedValues = 0;
m_accumulatedValue = 0;
}
}
pa_stream_drop(m_stream);
}
}
void PulseAudioVolumePeakDetector::quit()
{
m_mainloop_api->quit(m_mainloop_api, 0);
}
/* VolumePeakDetector */
VolumePeakDetector::VolumePeakDetector()
{
QObject::connect(&m_thread, SIGNAL(started()), &m_volumeDetector, SLOT(start()));
QObject::connect(&m_volumeDetector, SIGNAL(newPeak(float)), this, SIGNAL(newPeak(float)));
m_volumeDetector.moveToThread(&m_thread);
}
bool VolumePeakDetector::enabled() const
{
return m_thread.isRunning();
}
int VolumePeakDetector::desiredInterval() const
{
return m_volumeDetector.nAccumulatedValuesLimit() * 1000 / voice_needed_rate;
}
void VolumePeakDetector::setDesiredInterval(int interval)
{
m_volumeDetector.setNAccumulatedValuesLimit(voice_needed_rate * interval / 1000);
}
void VolumePeakDetector::setEnabled(int enabled)
{
if (enabled) {
if (!m_thread.isRunning()) {
m_thread.start();
}
} else {
if (m_thread.isRunning()) {
m_volumeDetector.quit();
}
}
}