static bool preload_sample(struct audio_service *service, struct play_feedback_data *pfd)
{
bool result = false;
struct stat st;
pa_sample_spec spec;
char *sample_path;
if (!pfd || !pfd->name)
return false;
if (g_slist_find(sample_list, pfd->name)) {
play_feedback_sample(pfd);
play_feedback_data_free(pfd);
return true;
}
sample_path = g_strdup_printf("%s/%s.pcm", SAMPLE_PATH, pfd->name);
if (stat(sample_path, &st) != 0)
goto cleanup;
pfd->sample_length = st.st_size;
spec.format = PA_SAMPLE_S16LE;
spec.rate = 44100;
spec.channels = 1;
pfd->fd = open(sample_path, O_RDONLY);
if (pfd->fd < 0)
goto cleanup;
pfd->sample_stream = pa_stream_new(service->context, pfd->name, &spec, NULL);
if (!pfd->sample_stream)
goto cleanup;
pa_stream_set_state_callback(pfd->sample_stream, preload_stream_state_cb, pfd);
pa_stream_set_write_callback(pfd->sample_stream, preload_stream_write_cb, pfd);
pa_stream_connect_upload(pfd->sample_stream, pfd->sample_length);
result = true;
cleanup:
g_free(sample_path);
return result;
}
void QSoundEffectPrivate::decoderReady()
{
if (m_waveDecoder->size() >= PA_SCACHE_ENTRY_SIZE_MAX) {
m_waveDecoder->deleteLater();
qWarning("QSoundEffect(pulseaudio): Attempting to load to large a sample");
return;
}
if (m_name.isNull())
m_name = QString(QLatin1String("QtPulseSample-%1-%2")).arg(::getpid()).arg(quintptr(this)).toUtf8();
pa_sample_spec spec = audioFormatToSampleSpec(m_waveDecoder->audioFormat());
daemon()->lock();
pa_stream *stream = pa_stream_new(daemon()->context(), m_name.constData(), &spec, 0);
pa_stream_set_state_callback(stream, stream_state_callback, this);
pa_stream_set_write_callback(stream, stream_write_callback, this);
pa_stream_connect_upload(stream, (size_t)m_waveDecoder->size());
m_pulseStream = stream;
daemon()->unlock();
}
bool CPulseAESound::Initialize()
{
/* we dont re-init the wav loader in PA as PA handles the samplerate */
if (!m_wavLoader.IsValid())
return false;
m_sampleSpec.format = PA_SAMPLE_FLOAT32NE;
m_sampleSpec.rate = m_wavLoader.GetSampleRate();
m_sampleSpec.channels = m_wavLoader.GetChannelLayout().Count();
if (!pa_sample_spec_valid(&m_sampleSpec))
{
CLog::Log(LOGERROR, "CPulseAESound::Initialize - Invalid sample spec");
return false;
}
struct pa_channel_map map;
map.channels = m_sampleSpec.channels;
switch (map.channels)
{
case 1:
map.map[0] = PA_CHANNEL_POSITION_MONO;
break;
case 2:
map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
break;
default:
CLog::Log(LOGERROR, "CPulseAESound::Initialize - We do not yet support multichannel sounds");
return false;
}
m_maxVolume = CAEFactory::GetEngine()->GetVolume();
m_volume = 1.0f;
pa_volume_t paVolume = pa_sw_volume_from_linear((double)(m_volume * m_maxVolume));
pa_cvolume_set(&m_chVolume, m_sampleSpec.channels, paVolume);
pa_threaded_mainloop_lock(m_mainLoop);
if ((m_stream = pa_stream_new(m_context, m_pulseName.c_str(), &m_sampleSpec, &map)) == NULL)
{
CLog::Log(LOGERROR, "CPulseAESound::Initialize - Could not create a stream");
pa_threaded_mainloop_unlock(m_mainLoop);
return false;
}
pa_stream_set_state_callback(m_stream, CPulseAESound::StreamStateCallback, this);
pa_stream_set_write_callback(m_stream, CPulseAESound::StreamWriteCallback, this);
if (pa_stream_connect_upload(m_stream, m_wavLoader.GetFrameCount() * pa_frame_size(&m_sampleSpec)) != 0)
{
CLog::Log(LOGERROR, "CPulseAESound::Initialize - Could not initialize the stream");
pa_stream_disconnect(m_stream);
m_stream = NULL;
pa_threaded_mainloop_unlock(m_mainLoop);
return false;
}
/* check if the stream failed */
if (pa_stream_get_state(m_stream) == PA_STREAM_FAILED)
{
CLog::Log(LOGERROR, "CPulseAESound::Initialize - Waited for the stream but it failed");
pa_stream_disconnect(m_stream);
m_stream = NULL;
pa_threaded_mainloop_unlock(m_mainLoop);
return false;
}
pa_threaded_mainloop_unlock(m_mainLoop);
return true;
}
void Sounds::cache(const QString& id) {
SoundFileInfo *info = m_files[id];
if (!info) {
return;
}
if (info->path().isEmpty()) {
return;
}
if (!m_ctx) {
return;
}
FileReader h(info->path());
pa_sample_spec *spec = h.sampleSpec();
if (!spec) {
qmlInfo(this) << "Failed to get a sample spec";
return;
}
if (!pa_sample_spec_valid(spec)) {
qmlInfo(this) << "Failed to get a valid sample spec";
return;
}
// First we set the file duration
info->setDuration(pa_bytes_to_usec(h.size(), spec));
pa_proplist *prop = pa_proplist_new();
pa_proplist_sets(prop, PA_PROP_MEDIA_ROLE, "event");
#ifdef SAILFISH
pa_proplist_sets(prop, PA_PROP_MEDIA_NAME, "camera-event");
#else
pa_proplist_sets(prop, PA_PROP_MEDIA_NAME, qPrintable(id));
#endif
pa_proplist_sets(prop, PA_PROP_EVENT_ID, qPrintable(id));
pa_proplist_sets(prop, PA_PROP_MEDIA_FILENAME, qPrintable(info->path()));
#ifdef SAILFISH
pa_proplist_sets(prop, PA_PROP_APPLICATION_PROCESS_BINARY, "ngfd");
pa_stream *stream = pa_stream_new_with_proplist(m_ctx, "camera-event",
spec, NULL, prop);
#else
pa_stream *stream = pa_stream_new_with_proplist(m_ctx, qPrintable(id),
spec, NULL, prop);
#endif
pa_proplist_free(prop);
if (!stream) {
qmlInfo(this) << "Failed to create a pulse audio stream";
return;
}
pa_stream_set_state_callback(stream, (pa_stream_notify_cb_t)streamStateCallback, m_loop);
pa_stream_set_write_callback(stream, (pa_stream_request_cb_t)streamRequestCallback, &h);
pa_threaded_mainloop_lock(m_loop);
if (pa_stream_connect_upload(stream, h.size()) < 0) {
pa_stream_unref(stream);
pa_threaded_mainloop_unlock(m_loop);
qmlInfo(this) << "Failed to connect pulse audio stream";
return;
}
while (true) {
bool out = false;
switch (pa_stream_get_state(stream)) {
case PA_STREAM_FAILED:
qmlInfo(this) << "Failed to connect our stream to pulse audio " << pa_strerror(pa_context_errno(m_ctx));
pa_stream_disconnect(stream);
pa_stream_unref(stream);
pa_threaded_mainloop_unlock(m_loop);
return;
case PA_STREAM_TERMINATED:
pa_threaded_mainloop_unlock(m_loop);
out = true;
break;
case PA_STREAM_READY:
case PA_STREAM_UNCONNECTED:
case PA_STREAM_CREATING:
pa_threaded_mainloop_wait(m_loop);
continue;
}
if (out) {
break;
}
}
pa_stream_unref(stream);
}
