2008-07-02 23:03:08 +02:00
|
|
|
/* public domain */
|
2019-05-23 16:35:07 +02:00
|
|
|
|
2016-01-18 18:33:52 +01:00
|
|
|
#include "qemu/osdep.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2008-07-02 23:03:08 +02:00
|
|
|
#include "audio.h"
|
2019-03-08 23:34:21 +01:00
|
|
|
#include "qapi/opts-visitor.h"
|
2008-07-02 23:03:08 +02:00
|
|
|
|
2012-04-17 14:32:41 +02:00
|
|
|
#include <pulse/pulseaudio.h>
|
2008-07-02 23:03:08 +02:00
|
|
|
|
|
|
|
#define AUDIO_CAP "pulseaudio"
|
|
|
|
#include "audio_int.h"
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
typedef struct PAConnection {
|
|
|
|
char *server;
|
|
|
|
int refcount;
|
|
|
|
QTAILQ_ENTRY(PAConnection) list;
|
|
|
|
|
2015-06-03 23:03:49 +02:00
|
|
|
pa_threaded_mainloop *mainloop;
|
|
|
|
pa_context *context;
|
2019-08-19 01:06:50 +02:00
|
|
|
} PAConnection;
|
|
|
|
|
|
|
|
static QTAILQ_HEAD(PAConnectionHead, PAConnection) pa_conns =
|
|
|
|
QTAILQ_HEAD_INITIALIZER(pa_conns);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
Audiodev *dev;
|
|
|
|
PAConnection *conn;
|
2015-06-03 23:03:49 +02:00
|
|
|
} paaudio;
|
|
|
|
|
2008-07-02 23:03:08 +02:00
|
|
|
typedef struct {
|
|
|
|
HWVoiceOut hw;
|
2012-04-17 14:32:41 +02:00
|
|
|
pa_stream *stream;
|
2015-06-03 23:03:49 +02:00
|
|
|
paaudio *g;
|
2008-07-02 23:03:08 +02:00
|
|
|
} PAVoiceOut;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
HWVoiceIn hw;
|
2012-04-17 14:32:41 +02:00
|
|
|
pa_stream *stream;
|
|
|
|
const void *read_data;
|
2019-09-19 23:24:15 +02:00
|
|
|
size_t read_length;
|
2015-06-03 23:03:49 +02:00
|
|
|
paaudio *g;
|
2008-07-02 23:03:08 +02:00
|
|
|
} PAVoiceIn;
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
static void qpa_conn_fini(PAConnection *c);
|
2015-06-03 23:03:53 +02:00
|
|
|
|
2008-07-02 23:03:08 +02:00
|
|
|
static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start (ap, fmt);
|
|
|
|
AUD_vlog (AUDIO_CAP, fmt, ap);
|
|
|
|
va_end (ap);
|
|
|
|
|
|
|
|
AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));
|
|
|
|
}
|
|
|
|
|
2012-05-03 22:41:28 +02:00
|
|
|
#ifndef PA_CONTEXT_IS_GOOD
|
|
|
|
static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
|
|
|
|
{
|
|
|
|
return
|
|
|
|
x == PA_CONTEXT_CONNECTING ||
|
|
|
|
x == PA_CONTEXT_AUTHORIZING ||
|
|
|
|
x == PA_CONTEXT_SETTING_NAME ||
|
|
|
|
x == PA_CONTEXT_READY;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef PA_STREAM_IS_GOOD
|
|
|
|
static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
|
|
|
|
{
|
|
|
|
return
|
|
|
|
x == PA_STREAM_CREATING ||
|
|
|
|
x == PA_STREAM_READY;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
#define CHECK_SUCCESS_GOTO(c, expression, label, msg) \
|
2012-04-17 14:32:41 +02:00
|
|
|
do { \
|
|
|
|
if (!(expression)) { \
|
2019-09-19 23:24:15 +02:00
|
|
|
qpa_logerr(pa_context_errno((c)->context), msg); \
|
2012-04-17 14:32:41 +02:00
|
|
|
goto label; \
|
|
|
|
} \
|
maint: Fix macros with broken 'do/while(0); ' usage
The point of writing a macro embedded in a 'do { ... } while (0)'
loop (particularly if the macro has multiple statements or would
otherwise end with an 'if' statement) is so that the macro can be
used as a drop-in statement with the caller supplying the
trailing ';'. Although our coding style frowns on brace-less 'if':
if (cond)
statement;
else
something else;
that is the classic case where failure to use do/while(0) wrapping
would cause the 'else' to pair with any embedded 'if' in the macro
rather than the intended outer 'if'. But conversely, if the macro
includes an embedded ';', then the same brace-less coding style
would now have two statements, making the 'else' a syntax error
rather than pairing with the outer 'if'. Thus, even though our
coding style with required braces is not impacted, ending a macro
with ';' makes our code harder to port to projects that use
brace-less styles.
The change should have no semantic impact. I was not able to
fully compile-test all of the changes (as some of them are
examples of the ugly bit-rotting debug print statements that are
completely elided by default, and I didn't want to recompile
with the necessary -D witnesses - cleaning those up is left as a
bite-sized task for another day); I did, however, audit that for
all files touched, all callers of the changed macros DID supply
a trailing ';' at the callsite, and did not appear to be used
as part of a brace-less conditional.
Found mechanically via: $ git grep -B1 'while (0);' | grep -A1 \\\\
Signed-off-by: Eric Blake <eblake@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20171201232433.25193-7-eblake@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-12-02 00:24:32 +01:00
|
|
|
} while (0)
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
#define CHECK_DEAD_GOTO(c, stream, label, msg) \
|
2012-04-17 14:32:41 +02:00
|
|
|
do { \
|
|
|
|
if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \
|
|
|
|
!(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \
|
|
|
|
if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \
|
|
|
|
((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \
|
2019-09-19 23:24:15 +02:00
|
|
|
qpa_logerr(pa_context_errno((c)->context), msg); \
|
2012-04-17 14:32:41 +02:00
|
|
|
} else { \
|
2019-09-19 23:24:15 +02:00
|
|
|
qpa_logerr(PA_ERR_BADSTATE, msg); \
|
2012-04-17 14:32:41 +02:00
|
|
|
} \
|
|
|
|
goto label; \
|
|
|
|
} \
|
maint: Fix macros with broken 'do/while(0); ' usage
The point of writing a macro embedded in a 'do { ... } while (0)'
loop (particularly if the macro has multiple statements or would
otherwise end with an 'if' statement) is so that the macro can be
used as a drop-in statement with the caller supplying the
trailing ';'. Although our coding style frowns on brace-less 'if':
if (cond)
statement;
else
something else;
that is the classic case where failure to use do/while(0) wrapping
would cause the 'else' to pair with any embedded 'if' in the macro
rather than the intended outer 'if'. But conversely, if the macro
includes an embedded ';', then the same brace-less coding style
would now have two statements, making the 'else' a syntax error
rather than pairing with the outer 'if'. Thus, even though our
coding style with required braces is not impacted, ending a macro
with ';' makes our code harder to port to projects that use
brace-less styles.
The change should have no semantic impact. I was not able to
fully compile-test all of the changes (as some of them are
examples of the ugly bit-rotting debug print statements that are
completely elided by default, and I didn't want to recompile
with the necessary -D witnesses - cleaning those up is left as a
bite-sized task for another day); I did, however, audit that for
all files touched, all callers of the changed macros DID supply
a trailing ';' at the callsite, and did not appear to be used
as part of a brace-less conditional.
Found mechanically via: $ git grep -B1 'while (0);' | grep -A1 \\\\
Signed-off-by: Eric Blake <eblake@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20171201232433.25193-7-eblake@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-12-02 00:24:32 +01:00
|
|
|
} while (0)
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-10-13 21:58:00 +02:00
|
|
|
static void *qpa_get_buffer_in(HWVoiceIn *hw, size_t *size)
|
|
|
|
{
|
|
|
|
PAVoiceIn *p = (PAVoiceIn *) hw;
|
|
|
|
PAConnection *c = p->g->conn;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
|
|
|
|
"pa_threaded_mainloop_lock failed\n");
|
|
|
|
|
|
|
|
if (!p->read_length) {
|
|
|
|
r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
|
|
|
|
"pa_stream_peek failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
*size = MIN(p->read_length, *size);
|
|
|
|
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
return (void *) p->read_data;
|
|
|
|
|
|
|
|
unlock_and_fail:
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
*size = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qpa_put_buffer_in(HWVoiceIn *hw, void *buf, size_t size)
|
|
|
|
{
|
|
|
|
PAVoiceIn *p = (PAVoiceIn *) hw;
|
|
|
|
PAConnection *c = p->g->conn;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
CHECK_DEAD_GOTO(c, p->stream, unlock,
|
|
|
|
"pa_threaded_mainloop_lock failed\n");
|
|
|
|
|
|
|
|
assert(buf == p->read_data && size <= p->read_length);
|
|
|
|
|
|
|
|
p->read_data += size;
|
|
|
|
p->read_length -= size;
|
|
|
|
|
|
|
|
if (size && !p->read_length) {
|
|
|
|
r = pa_stream_drop(p->stream);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r == 0, unlock, "pa_stream_drop failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
}
|
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
static size_t qpa_read(HWVoiceIn *hw, void *data, size_t length)
|
2012-04-17 14:32:41 +02:00
|
|
|
{
|
2019-09-19 23:24:15 +02:00
|
|
|
PAVoiceIn *p = (PAVoiceIn *) hw;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = p->g->conn;
|
2020-01-04 10:11:21 +01:00
|
|
|
size_t total = 0;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
|
|
|
|
"pa_threaded_mainloop_lock failed\n");
|
paaudio: wait until the recording stream is ready
Don't call pa_stream_peek before the recording stream is ready.
Information to reproduce the problem.
Start and stop Audacity in the guest several times because the
problem is racy.
libvirt log file:
-audiodev pa,id=audio0,server=localhost,out.latency=30000,
out.mixing-engine=off,in.mixing-engine=off \
-sandbox on,obsolete=deny,elevateprivileges=deny,spawn=deny,
resourcecontrol=deny \
-msg timestamp=on
: Domain id=4 is tainted: custom-argv
char device redirected to /dev/pts/1 (label charserial0)
audio: Device pcspk: audiodev default parameter is deprecated,
please specify audiodev=audio0
audio: Device hda: audiodev default parameter is deprecated,
please specify audiodev=audio0
pulseaudio: pa_stream_peek failed
pulseaudio: Reason: Bad state
pulseaudio: pa_stream_peek failed
pulseaudio: Reason: Bad state
Signed-off-by: Volker Rümelin <vr_qemu@t-online.de>
Message-id: 20200104091122.13971-5-vr_qemu@t-online.de
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2020-01-04 10:11:22 +01:00
|
|
|
if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
|
|
|
|
/* wait for stream to become ready */
|
|
|
|
goto unlock;
|
|
|
|
}
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2020-01-04 10:11:21 +01:00
|
|
|
while (total < length) {
|
|
|
|
size_t l;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!p->read_length) {
|
|
|
|
r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
|
|
|
|
"pa_stream_peek failed\n");
|
|
|
|
if (!p->read_length) {
|
|
|
|
/* buffer is empty */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
l = MIN(p->read_length, length - total);
|
|
|
|
memcpy((char *)data + total, p->read_data, l);
|
|
|
|
|
|
|
|
p->read_data += l;
|
|
|
|
p->read_length -= l;
|
|
|
|
total += l;
|
|
|
|
|
|
|
|
if (!p->read_length) {
|
|
|
|
r = pa_stream_drop(p->stream);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
|
|
|
|
"pa_stream_drop failed\n");
|
|
|
|
}
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
paaudio: wait until the recording stream is ready
Don't call pa_stream_peek before the recording stream is ready.
Information to reproduce the problem.
Start and stop Audacity in the guest several times because the
problem is racy.
libvirt log file:
-audiodev pa,id=audio0,server=localhost,out.latency=30000,
out.mixing-engine=off,in.mixing-engine=off \
-sandbox on,obsolete=deny,elevateprivileges=deny,spawn=deny,
resourcecontrol=deny \
-msg timestamp=on
: Domain id=4 is tainted: custom-argv
char device redirected to /dev/pts/1 (label charserial0)
audio: Device pcspk: audiodev default parameter is deprecated,
please specify audiodev=audio0
audio: Device hda: audiodev default parameter is deprecated,
please specify audiodev=audio0
pulseaudio: pa_stream_peek failed
pulseaudio: Reason: Bad state
pulseaudio: pa_stream_peek failed
pulseaudio: Reason: Bad state
Signed-off-by: Volker Rümelin <vr_qemu@t-online.de>
Message-id: 20200104091122.13971-5-vr_qemu@t-online.de
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2020-01-04 10:11:22 +01:00
|
|
|
unlock:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2020-01-04 10:11:21 +01:00
|
|
|
return total;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
unlock_and_fail:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2019-09-19 23:24:15 +02:00
|
|
|
return 0;
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2019-10-13 21:58:00 +02:00
|
|
|
static void *qpa_get_buffer_out(HWVoiceOut *hw, size_t *size)
|
|
|
|
{
|
|
|
|
PAVoiceOut *p = (PAVoiceOut *) hw;
|
|
|
|
PAConnection *c = p->g->conn;
|
|
|
|
void *ret;
|
2021-01-10 11:02:29 +01:00
|
|
|
size_t l;
|
2019-10-13 21:58:00 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
|
|
|
|
"pa_threaded_mainloop_lock failed\n");
|
2021-01-10 11:02:31 +01:00
|
|
|
if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
|
|
|
|
/* wait for stream to become ready */
|
|
|
|
l = 0;
|
|
|
|
ret = NULL;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2019-10-13 21:58:00 +02:00
|
|
|
|
2021-01-10 11:02:29 +01:00
|
|
|
l = pa_stream_writable_size(p->stream);
|
|
|
|
CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
|
|
|
|
"pa_stream_writable_size failed\n");
|
|
|
|
|
2019-10-13 21:58:00 +02:00
|
|
|
*size = -1;
|
|
|
|
r = pa_stream_begin_write(p->stream, &ret, size);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail,
|
|
|
|
"pa_stream_begin_write failed\n");
|
|
|
|
|
2021-01-10 11:02:31 +01:00
|
|
|
unlock:
|
2019-10-13 21:58:00 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2021-01-10 11:02:29 +01:00
|
|
|
if (*size > l) {
|
|
|
|
*size = l;
|
|
|
|
}
|
2019-10-13 21:58:00 +02:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
unlock_and_fail:
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
*size = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-01-10 11:02:29 +01:00
|
|
|
static size_t qpa_put_buffer_out(HWVoiceOut *hw, void *data, size_t length)
|
|
|
|
{
|
|
|
|
PAVoiceOut *p = (PAVoiceOut *)hw;
|
|
|
|
PAConnection *c = p->g->conn;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
|
|
|
|
"pa_threaded_mainloop_lock failed\n");
|
|
|
|
|
|
|
|
r = pa_stream_write(p->stream, data, length, NULL, 0LL, PA_SEEK_RELATIVE);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
|
|
|
|
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
return length;
|
|
|
|
|
|
|
|
unlock_and_fail:
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
static size_t qpa_write(HWVoiceOut *hw, void *data, size_t length)
|
2012-04-17 14:32:41 +02:00
|
|
|
{
|
2019-09-19 23:24:15 +02:00
|
|
|
PAVoiceOut *p = (PAVoiceOut *) hw;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = p->g->conn;
|
2019-09-19 23:24:15 +02:00
|
|
|
size_t l;
|
|
|
|
int r;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
|
|
|
|
"pa_threaded_mainloop_lock failed\n");
|
2021-01-10 11:02:30 +01:00
|
|
|
if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
|
|
|
|
/* wait for stream to become ready */
|
|
|
|
l = 0;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
l = pa_stream_writable_size(p->stream);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
|
|
|
|
"pa_stream_writable_size failed\n");
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
if (l > length) {
|
|
|
|
l = length;
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2019-09-19 23:24:15 +02:00
|
|
|
r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
|
|
|
|
CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
|
|
|
|
|
2021-01-10 11:02:30 +01:00
|
|
|
unlock:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2019-09-19 23:24:15 +02:00
|
|
|
return l;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
unlock_and_fail:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2019-09-19 23:24:15 +02:00
|
|
|
return 0;
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
|
2019-03-08 23:34:13 +01:00
|
|
|
static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
|
|
|
int format;
|
|
|
|
|
|
|
|
switch (afmt) {
|
2019-03-08 23:34:13 +01:00
|
|
|
case AUDIO_FORMAT_S8:
|
|
|
|
case AUDIO_FORMAT_U8:
|
2008-07-02 23:03:08 +02:00
|
|
|
format = PA_SAMPLE_U8;
|
|
|
|
break;
|
2019-03-08 23:34:13 +01:00
|
|
|
case AUDIO_FORMAT_S16:
|
|
|
|
case AUDIO_FORMAT_U16:
|
2008-07-02 23:03:08 +02:00
|
|
|
format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
|
|
|
|
break;
|
2019-03-08 23:34:13 +01:00
|
|
|
case AUDIO_FORMAT_S32:
|
|
|
|
case AUDIO_FORMAT_U32:
|
2008-07-02 23:03:08 +02:00
|
|
|
format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
|
|
|
|
break;
|
2020-02-02 20:38:07 +01:00
|
|
|
case AUDIO_FORMAT_F32:
|
|
|
|
format = endianness ? PA_SAMPLE_FLOAT32BE : PA_SAMPLE_FLOAT32LE;
|
|
|
|
break;
|
2008-07-02 23:03:08 +02:00
|
|
|
default:
|
|
|
|
dolog ("Internal logic error: Bad audio format %d\n", afmt);
|
|
|
|
format = PA_SAMPLE_U8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return format;
|
|
|
|
}
|
|
|
|
|
2019-03-08 23:34:13 +01:00
|
|
|
static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
|
|
|
switch (fmt) {
|
|
|
|
case PA_SAMPLE_U8:
|
2019-03-08 23:34:13 +01:00
|
|
|
return AUDIO_FORMAT_U8;
|
2008-07-02 23:03:08 +02:00
|
|
|
case PA_SAMPLE_S16BE:
|
|
|
|
*endianness = 1;
|
2019-03-08 23:34:13 +01:00
|
|
|
return AUDIO_FORMAT_S16;
|
2008-07-02 23:03:08 +02:00
|
|
|
case PA_SAMPLE_S16LE:
|
|
|
|
*endianness = 0;
|
2019-03-08 23:34:13 +01:00
|
|
|
return AUDIO_FORMAT_S16;
|
2008-07-02 23:03:08 +02:00
|
|
|
case PA_SAMPLE_S32BE:
|
|
|
|
*endianness = 1;
|
2019-03-08 23:34:13 +01:00
|
|
|
return AUDIO_FORMAT_S32;
|
2008-07-02 23:03:08 +02:00
|
|
|
case PA_SAMPLE_S32LE:
|
|
|
|
*endianness = 0;
|
2019-03-08 23:34:13 +01:00
|
|
|
return AUDIO_FORMAT_S32;
|
2020-02-02 20:38:07 +01:00
|
|
|
case PA_SAMPLE_FLOAT32BE:
|
|
|
|
*endianness = 1;
|
|
|
|
return AUDIO_FORMAT_F32;
|
|
|
|
case PA_SAMPLE_FLOAT32LE:
|
|
|
|
*endianness = 0;
|
|
|
|
return AUDIO_FORMAT_F32;
|
2008-07-02 23:03:08 +02:00
|
|
|
default:
|
|
|
|
dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
|
2019-03-08 23:34:13 +01:00
|
|
|
return AUDIO_FORMAT_U8;
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-17 14:32:41 +02:00
|
|
|
static void context_state_cb (pa_context *c, void *userdata)
|
|
|
|
{
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *conn = userdata;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
switch (pa_context_get_state(c)) {
|
|
|
|
case PA_CONTEXT_READY:
|
|
|
|
case PA_CONTEXT_TERMINATED:
|
|
|
|
case PA_CONTEXT_FAILED:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_signal(conn->mainloop, 0);
|
2012-04-17 14:32:41 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PA_CONTEXT_UNCONNECTED:
|
|
|
|
case PA_CONTEXT_CONNECTING:
|
|
|
|
case PA_CONTEXT_AUTHORIZING:
|
|
|
|
case PA_CONTEXT_SETTING_NAME:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stream_state_cb (pa_stream *s, void * userdata)
|
|
|
|
{
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = userdata;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
switch (pa_stream_get_state (s)) {
|
|
|
|
|
|
|
|
case PA_STREAM_READY:
|
|
|
|
case PA_STREAM_FAILED:
|
|
|
|
case PA_STREAM_TERMINATED:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_signal(c->mainloop, 0);
|
2012-04-17 14:32:41 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PA_STREAM_UNCONNECTED:
|
|
|
|
case PA_STREAM_CREATING:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static pa_stream *qpa_simple_new (
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c,
|
2012-04-17 14:32:41 +02:00
|
|
|
const char *name,
|
|
|
|
pa_stream_direction_t dir,
|
|
|
|
const char *dev,
|
|
|
|
const pa_sample_spec *ss,
|
|
|
|
const pa_buffer_attr *attr,
|
|
|
|
int *rerror)
|
|
|
|
{
|
|
|
|
int r;
|
2019-10-13 21:58:07 +02:00
|
|
|
pa_stream *stream = NULL;
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_stream_flags_t flags;
|
2019-10-13 21:58:07 +02:00
|
|
|
pa_channel_map map;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-10-13 21:58:07 +02:00
|
|
|
pa_channel_map_init(&map);
|
|
|
|
map.channels = ss->channels;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: This currently expects the only frontend supporting more than 2
|
|
|
|
* channels is the usb-audio. We will need some means to set channel
|
|
|
|
* order when a new frontend gains multi-channel support.
|
|
|
|
*/
|
|
|
|
switch (ss->channels) {
|
|
|
|
case 1:
|
|
|
|
map.map[0] = PA_CHANNEL_POSITION_MONO;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
map.map[0] = PA_CHANNEL_POSITION_LEFT;
|
|
|
|
map.map[1] = PA_CHANNEL_POSITION_RIGHT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
|
|
|
map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
|
|
|
|
map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
|
|
|
|
map.map[2] = PA_CHANNEL_POSITION_CENTER;
|
|
|
|
map.map[3] = PA_CHANNEL_POSITION_LFE;
|
|
|
|
map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
|
|
|
|
map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
|
|
|
|
map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
|
|
|
|
map.map[2] = PA_CHANNEL_POSITION_CENTER;
|
|
|
|
map.map[3] = PA_CHANNEL_POSITION_LFE;
|
|
|
|
map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
|
|
|
|
map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
|
|
|
|
map.map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
|
|
|
|
map.map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
|
2019-10-23 10:24:20 +02:00
|
|
|
break;
|
2019-10-13 21:58:07 +02:00
|
|
|
|
|
|
|
default:
|
|
|
|
dolog("Internal error: unsupported channel count %d\n", ss->channels);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
stream = pa_stream_new(c->context, name, ss, &map);
|
2012-04-17 14:32:41 +02:00
|
|
|
if (!stream) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_stream_set_state_callback(stream, stream_state_cb, c);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2021-05-17 21:46:02 +02:00
|
|
|
flags = PA_STREAM_EARLY_REQUESTS;
|
2019-08-19 01:06:50 +02:00
|
|
|
|
2019-08-19 01:06:52 +02:00
|
|
|
if (dev) {
|
|
|
|
/* don't move the stream if the user specified a sink/source */
|
|
|
|
flags |= PA_STREAM_DONT_MOVE;
|
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
if (dir == PA_STREAM_PLAYBACK) {
|
|
|
|
r = pa_stream_connect_playback(stream, dev, attr, flags, NULL, NULL);
|
2012-04-17 14:32:41 +02:00
|
|
|
} else {
|
2019-08-19 01:06:50 +02:00
|
|
|
r = pa_stream_connect_record(stream, dev, attr, flags);
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (r < 0) {
|
2021-01-15 02:24:30 +01:00
|
|
|
goto fail;
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
return stream;
|
|
|
|
|
|
|
|
fail:
|
2019-08-19 01:06:50 +02:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
if (stream) {
|
|
|
|
pa_stream_unref (stream);
|
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
*rerror = pa_context_errno(c->context);
|
2012-04-17 14:32:41 +02:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:03:47 +02:00
|
|
|
static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as,
|
|
|
|
void *drv_opaque)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
|
|
|
int error;
|
2015-06-03 23:03:49 +02:00
|
|
|
pa_sample_spec ss;
|
|
|
|
pa_buffer_attr ba;
|
2008-12-03 23:48:44 +01:00
|
|
|
struct audsettings obt_as = *as;
|
2008-07-02 23:03:08 +02:00
|
|
|
PAVoiceOut *pa = (PAVoiceOut *) hw;
|
2015-06-03 23:03:49 +02:00
|
|
|
paaudio *g = pa->g = drv_opaque;
|
2019-03-08 23:34:21 +01:00
|
|
|
AudiodevPaOptions *popts = &g->dev->u.pa;
|
|
|
|
AudiodevPaPerDirectionOptions *ppdo = popts->out;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = g->conn;
|
2008-07-02 23:03:08 +02:00
|
|
|
|
|
|
|
ss.format = audfmt_to_pa (as->fmt, as->endianness);
|
|
|
|
ss.channels = as->nchannels;
|
|
|
|
ss.rate = as->freq;
|
|
|
|
|
2019-03-15 09:46:52 +01:00
|
|
|
ba.tlength = pa_usec_to_bytes(ppdo->latency, &ss);
|
2021-01-10 11:02:34 +01:00
|
|
|
ba.minreq = pa_usec_to_bytes(MIN(ppdo->latency >> 2,
|
|
|
|
(g->dev->timer_period >> 2) * 3), &ss);
|
2011-01-24 22:07:45 +01:00
|
|
|
ba.maxlength = -1;
|
|
|
|
ba.prebuf = -1;
|
|
|
|
|
2008-07-02 23:03:08 +02:00
|
|
|
obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
|
|
|
|
|
2012-04-17 14:32:41 +02:00
|
|
|
pa->stream = qpa_simple_new (
|
2019-08-19 01:06:50 +02:00
|
|
|
c,
|
2019-09-11 01:26:20 +02:00
|
|
|
ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
|
2008-07-02 23:03:08 +02:00
|
|
|
PA_STREAM_PLAYBACK,
|
2019-03-08 23:34:21 +01:00
|
|
|
ppdo->has_name ? ppdo->name : NULL,
|
2008-07-02 23:03:08 +02:00
|
|
|
&ss,
|
2011-01-24 22:07:45 +01:00
|
|
|
&ba, /* buffering attributes */
|
2008-07-02 23:03:08 +02:00
|
|
|
&error
|
|
|
|
);
|
2012-04-17 14:32:41 +02:00
|
|
|
if (!pa->stream) {
|
2008-07-02 23:03:08 +02:00
|
|
|
qpa_logerr (error, "pa_simple_new for playback failed\n");
|
|
|
|
goto fail1;
|
|
|
|
}
|
|
|
|
|
|
|
|
audio_pcm_init_info (&hw->info, &obt_as);
|
2021-01-10 11:02:33 +01:00
|
|
|
/*
|
|
|
|
* This is wrong. hw->samples counts in frames. hw->samples will be
|
|
|
|
* number of channels times larger than expected.
|
|
|
|
*/
|
2020-01-23 08:49:37 +01:00
|
|
|
hw->samples = audio_buffer_samples(
|
2021-01-10 11:02:32 +01:00
|
|
|
qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
|
2008-07-02 23:03:08 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail1:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:03:47 +02:00
|
|
|
static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
|
|
|
int error;
|
2015-06-03 23:03:49 +02:00
|
|
|
pa_sample_spec ss;
|
2019-03-15 09:46:53 +01:00
|
|
|
pa_buffer_attr ba;
|
2008-12-03 23:48:44 +01:00
|
|
|
struct audsettings obt_as = *as;
|
2008-07-02 23:03:08 +02:00
|
|
|
PAVoiceIn *pa = (PAVoiceIn *) hw;
|
2015-06-03 23:03:49 +02:00
|
|
|
paaudio *g = pa->g = drv_opaque;
|
2019-03-08 23:34:21 +01:00
|
|
|
AudiodevPaOptions *popts = &g->dev->u.pa;
|
|
|
|
AudiodevPaPerDirectionOptions *ppdo = popts->in;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = g->conn;
|
2008-07-02 23:03:08 +02:00
|
|
|
|
|
|
|
ss.format = audfmt_to_pa (as->fmt, as->endianness);
|
|
|
|
ss.channels = as->nchannels;
|
|
|
|
ss.rate = as->freq;
|
|
|
|
|
2021-01-10 11:02:35 +01:00
|
|
|
ba.fragsize = pa_usec_to_bytes((g->dev->timer_period >> 1) * 3, &ss);
|
|
|
|
ba.maxlength = pa_usec_to_bytes(
|
|
|
|
MAX(ppdo->latency, g->dev->timer_period * 3), &ss);
|
2019-03-15 09:46:53 +01:00
|
|
|
ba.minreq = -1;
|
|
|
|
ba.prebuf = -1;
|
|
|
|
|
2008-07-02 23:03:08 +02:00
|
|
|
obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
|
|
|
|
|
2012-04-17 14:32:41 +02:00
|
|
|
pa->stream = qpa_simple_new (
|
2019-08-19 01:06:50 +02:00
|
|
|
c,
|
2019-09-11 01:26:20 +02:00
|
|
|
ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
|
2008-07-02 23:03:08 +02:00
|
|
|
PA_STREAM_RECORD,
|
2019-03-08 23:34:21 +01:00
|
|
|
ppdo->has_name ? ppdo->name : NULL,
|
2008-07-02 23:03:08 +02:00
|
|
|
&ss,
|
2019-03-15 09:46:53 +01:00
|
|
|
&ba, /* buffering attributes */
|
2008-07-02 23:03:08 +02:00
|
|
|
&error
|
|
|
|
);
|
2012-04-17 14:32:41 +02:00
|
|
|
if (!pa->stream) {
|
2008-07-02 23:03:08 +02:00
|
|
|
qpa_logerr (error, "pa_simple_new for capture failed\n");
|
|
|
|
goto fail1;
|
|
|
|
}
|
|
|
|
|
|
|
|
audio_pcm_init_info (&hw->info, &obt_as);
|
2021-01-10 11:02:33 +01:00
|
|
|
/*
|
|
|
|
* This is wrong. hw->samples counts in frames. hw->samples will be
|
|
|
|
* number of channels times larger than expected.
|
|
|
|
*/
|
2020-01-23 08:49:37 +01:00
|
|
|
hw->samples = audio_buffer_samples(
|
2021-01-10 11:02:32 +01:00
|
|
|
qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
|
2008-07-02 23:03:08 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail1:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:53 +02:00
|
|
|
static void qpa_simple_disconnect(PAConnection *c, pa_stream *stream)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* wait until actually connects. workaround pa bug #247
|
|
|
|
* https://gitlab.freedesktop.org/pulseaudio/pulseaudio/issues/247
|
|
|
|
*/
|
|
|
|
while (pa_stream_get_state(stream) == PA_STREAM_CREATING) {
|
|
|
|
pa_threaded_mainloop_wait(c->mainloop);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = pa_stream_disconnect(stream);
|
|
|
|
if (err != 0) {
|
|
|
|
dolog("Failed to disconnect! err=%d\n", err);
|
|
|
|
}
|
|
|
|
pa_stream_unref(stream);
|
|
|
|
}
|
|
|
|
|
2008-07-02 23:03:08 +02:00
|
|
|
static void qpa_fini_out (HWVoiceOut *hw)
|
|
|
|
{
|
|
|
|
PAVoiceOut *pa = (PAVoiceOut *) hw;
|
|
|
|
|
2012-04-17 14:32:41 +02:00
|
|
|
if (pa->stream) {
|
2020-01-04 10:11:20 +01:00
|
|
|
PAConnection *c = pa->g->conn;
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
qpa_simple_disconnect(c, pa->stream);
|
2012-04-17 14:32:41 +02:00
|
|
|
pa->stream = NULL;
|
2020-01-04 10:11:20 +01:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qpa_fini_in (HWVoiceIn *hw)
|
|
|
|
{
|
|
|
|
PAVoiceIn *pa = (PAVoiceIn *) hw;
|
|
|
|
|
2012-04-17 14:32:41 +02:00
|
|
|
if (pa->stream) {
|
2020-01-04 10:11:20 +01:00
|
|
|
PAConnection *c = pa->g->conn;
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
if (pa->read_length) {
|
|
|
|
int r = pa_stream_drop(pa->stream);
|
|
|
|
if (r) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"pa_stream_drop failed\n");
|
|
|
|
}
|
|
|
|
pa->read_length = 0;
|
|
|
|
}
|
|
|
|
qpa_simple_disconnect(c, pa->stream);
|
2012-04-17 14:32:41 +02:00
|
|
|
pa->stream = NULL;
|
2020-01-04 10:11:20 +01:00
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-13 21:58:01 +02:00
|
|
|
static void qpa_volume_out(HWVoiceOut *hw, Volume *vol)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
2012-04-17 14:32:43 +02:00
|
|
|
PAVoiceOut *pa = (PAVoiceOut *) hw;
|
|
|
|
pa_operation *op;
|
|
|
|
pa_cvolume v;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = pa->g->conn;
|
2019-10-13 21:58:01 +02:00
|
|
|
int i;
|
2012-04-17 14:32:43 +02:00
|
|
|
|
2012-05-03 22:41:28 +02:00
|
|
|
#ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */
|
|
|
|
pa_cvolume_init (&v); /* function is present in 0.9.13+ */
|
|
|
|
#endif
|
2012-04-17 14:32:43 +02:00
|
|
|
|
2019-10-13 21:58:01 +02:00
|
|
|
v.channels = vol->channels;
|
|
|
|
for (i = 0; i < vol->channels; ++i) {
|
|
|
|
v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
|
|
|
|
}
|
2019-09-19 23:24:22 +02:00
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
op = pa_context_set_sink_input_volume(c->context,
|
|
|
|
pa_stream_get_index(pa->stream),
|
|
|
|
&v, NULL, NULL);
|
|
|
|
if (!op) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"set_sink_input_volume() failed\n");
|
|
|
|
} else {
|
|
|
|
pa_operation_unref(op);
|
2012-04-17 14:32:43 +02:00
|
|
|
}
|
2019-09-19 23:24:22 +02:00
|
|
|
|
|
|
|
op = pa_context_set_sink_input_mute(c->context,
|
|
|
|
pa_stream_get_index(pa->stream),
|
|
|
|
vol->mute, NULL, NULL);
|
|
|
|
if (!op) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"set_sink_input_mute() failed\n");
|
|
|
|
} else {
|
|
|
|
pa_operation_unref(op);
|
|
|
|
}
|
|
|
|
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
|
2019-10-13 21:58:01 +02:00
|
|
|
static void qpa_volume_in(HWVoiceIn *hw, Volume *vol)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
2012-04-17 14:32:43 +02:00
|
|
|
PAVoiceIn *pa = (PAVoiceIn *) hw;
|
|
|
|
pa_operation *op;
|
|
|
|
pa_cvolume v;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = pa->g->conn;
|
2019-10-13 21:58:01 +02:00
|
|
|
int i;
|
2012-04-17 14:32:43 +02:00
|
|
|
|
2012-05-03 22:41:28 +02:00
|
|
|
#ifdef PA_CHECK_VERSION
|
2012-04-17 14:32:43 +02:00
|
|
|
pa_cvolume_init (&v);
|
2012-05-03 22:41:28 +02:00
|
|
|
#endif
|
2012-04-17 14:32:43 +02:00
|
|
|
|
2019-10-13 21:58:01 +02:00
|
|
|
v.channels = vol->channels;
|
|
|
|
for (i = 0; i < vol->channels; ++i) {
|
|
|
|
v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
|
|
|
|
}
|
2019-09-19 23:24:22 +02:00
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
op = pa_context_set_source_output_volume(c->context,
|
|
|
|
pa_stream_get_index(pa->stream),
|
|
|
|
&v, NULL, NULL);
|
|
|
|
if (!op) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"set_source_output_volume() failed\n");
|
|
|
|
} else {
|
|
|
|
pa_operation_unref(op);
|
2012-04-17 14:32:43 +02:00
|
|
|
}
|
2019-09-19 23:24:22 +02:00
|
|
|
|
|
|
|
op = pa_context_set_source_output_mute(c->context,
|
|
|
|
pa_stream_get_index(pa->stream),
|
|
|
|
vol->mute, NULL, NULL);
|
|
|
|
if (!op) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"set_source_output_mute() failed\n");
|
|
|
|
} else {
|
|
|
|
pa_operation_unref(op);
|
|
|
|
}
|
|
|
|
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
|
2019-03-15 09:46:51 +01:00
|
|
|
static int qpa_validate_per_direction_opts(Audiodev *dev,
|
|
|
|
AudiodevPaPerDirectionOptions *pdo)
|
|
|
|
{
|
2019-03-15 09:46:52 +01:00
|
|
|
if (!pdo->has_latency) {
|
|
|
|
pdo->has_latency = true;
|
|
|
|
pdo->latency = 15000;
|
|
|
|
}
|
2019-03-15 09:46:51 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
/* common */
|
|
|
|
static void *qpa_conn_init(const char *server)
|
|
|
|
{
|
|
|
|
PAConnection *c = g_malloc0(sizeof(PAConnection));
|
|
|
|
QTAILQ_INSERT_TAIL(&pa_conns, c, list);
|
|
|
|
|
|
|
|
c->mainloop = pa_threaded_mainloop_new();
|
|
|
|
if (!c->mainloop) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop),
|
2021-05-17 21:46:03 +02:00
|
|
|
audio_application_name());
|
2019-08-19 01:06:50 +02:00
|
|
|
if (!c->context) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
pa_context_set_state_callback(c->context, context_state_cb, c);
|
|
|
|
|
|
|
|
if (pa_context_connect(c->context, server, 0, NULL) < 0) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"pa_context_connect() failed\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
pa_threaded_mainloop_lock(c->mainloop);
|
|
|
|
|
|
|
|
if (pa_threaded_mainloop_start(c->mainloop) < 0) {
|
|
|
|
goto unlock_and_fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
pa_context_state_t state;
|
|
|
|
|
|
|
|
state = pa_context_get_state(c->context);
|
|
|
|
|
|
|
|
if (state == PA_CONTEXT_READY) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!PA_CONTEXT_IS_GOOD(state)) {
|
|
|
|
qpa_logerr(pa_context_errno(c->context),
|
|
|
|
"Wrong context state\n");
|
|
|
|
goto unlock_and_fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait until the context is ready */
|
|
|
|
pa_threaded_mainloop_wait(c->mainloop);
|
|
|
|
}
|
|
|
|
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
return c;
|
|
|
|
|
|
|
|
unlock_and_fail:
|
|
|
|
pa_threaded_mainloop_unlock(c->mainloop);
|
|
|
|
fail:
|
|
|
|
AUD_log (AUDIO_CAP, "Failed to initialize PA context");
|
|
|
|
qpa_conn_fini(c);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-03-08 23:34:15 +01:00
|
|
|
static void *qpa_audio_init(Audiodev *dev)
|
2008-07-02 23:03:08 +02:00
|
|
|
{
|
2019-03-08 23:34:21 +01:00
|
|
|
paaudio *g;
|
|
|
|
AudiodevPaOptions *popts = &dev->u.pa;
|
|
|
|
const char *server;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c;
|
|
|
|
|
|
|
|
assert(dev->driver == AUDIODEV_DRIVER_PA);
|
2019-03-08 23:34:21 +01:00
|
|
|
|
|
|
|
if (!popts->has_server) {
|
2019-01-24 12:20:53 +01:00
|
|
|
char pidfile[64];
|
|
|
|
char *runtime;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
runtime = getenv("XDG_RUNTIME_DIR");
|
|
|
|
if (!runtime) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
snprintf(pidfile, sizeof(pidfile), "%s/pulse/pid", runtime);
|
|
|
|
if (stat(pidfile, &st) != 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-15 09:46:51 +01:00
|
|
|
if (!qpa_validate_per_direction_opts(dev, popts->in)) {
|
2019-08-19 01:06:50 +02:00
|
|
|
return NULL;
|
2019-03-15 09:46:51 +01:00
|
|
|
}
|
|
|
|
if (!qpa_validate_per_direction_opts(dev, popts->out)) {
|
2019-08-19 01:06:50 +02:00
|
|
|
return NULL;
|
2019-03-15 09:46:51 +01:00
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
g = g_malloc0(sizeof(paaudio));
|
|
|
|
server = popts->has_server ? popts->server : NULL;
|
|
|
|
|
2019-03-08 23:34:21 +01:00
|
|
|
g->dev = dev;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
QTAILQ_FOREACH(c, &pa_conns, list) {
|
|
|
|
if (server == NULL || c->server == NULL ?
|
|
|
|
server == c->server :
|
|
|
|
strcmp(server, c->server) == 0) {
|
|
|
|
g->conn = c;
|
|
|
|
break;
|
|
|
|
}
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
2019-08-19 01:06:50 +02:00
|
|
|
if (!g->conn) {
|
|
|
|
g->conn = qpa_conn_init(server);
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
2019-08-19 01:06:50 +02:00
|
|
|
if (!g->conn) {
|
|
|
|
g_free(g);
|
|
|
|
return NULL;
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
++g->conn->refcount;
|
|
|
|
return g;
|
|
|
|
}
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
static void qpa_conn_fini(PAConnection *c)
|
|
|
|
{
|
|
|
|
if (c->mainloop) {
|
|
|
|
pa_threaded_mainloop_stop(c->mainloop);
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
if (c->context) {
|
|
|
|
pa_context_disconnect(c->context);
|
|
|
|
pa_context_unref(c->context);
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
if (c->mainloop) {
|
|
|
|
pa_threaded_mainloop_free(c->mainloop);
|
|
|
|
}
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
QTAILQ_REMOVE(&pa_conns, c, list);
|
|
|
|
g_free(c);
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qpa_audio_fini (void *opaque)
|
|
|
|
{
|
2012-04-17 14:32:41 +02:00
|
|
|
paaudio *g = opaque;
|
2019-08-19 01:06:50 +02:00
|
|
|
PAConnection *c = g->conn;
|
2012-04-17 14:32:41 +02:00
|
|
|
|
2019-08-19 01:06:50 +02:00
|
|
|
if (--c->refcount == 0) {
|
|
|
|
qpa_conn_fini(c);
|
2012-04-17 14:32:41 +02:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:03:49 +02:00
|
|
|
g_free(g);
|
2008-07-02 23:03:08 +02:00
|
|
|
}
|
|
|
|
|
2008-10-06 20:08:30 +02:00
|
|
|
static struct audio_pcm_ops qpa_pcm_ops = {
|
2009-08-11 02:31:15 +02:00
|
|
|
.init_out = qpa_init_out,
|
|
|
|
.fini_out = qpa_fini_out,
|
2019-09-19 23:24:15 +02:00
|
|
|
.write = qpa_write,
|
2019-10-13 21:58:00 +02:00
|
|
|
.get_buffer_out = qpa_get_buffer_out,
|
2021-01-10 11:02:29 +01:00
|
|
|
.put_buffer_out = qpa_put_buffer_out,
|
2019-09-19 23:24:22 +02:00
|
|
|
.volume_out = qpa_volume_out,
|
2009-08-11 02:31:15 +02:00
|
|
|
|
|
|
|
.init_in = qpa_init_in,
|
|
|
|
.fini_in = qpa_fini_in,
|
2019-09-19 23:24:15 +02:00
|
|
|
.read = qpa_read,
|
2019-10-13 21:58:00 +02:00
|
|
|
.get_buffer_in = qpa_get_buffer_in,
|
|
|
|
.put_buffer_in = qpa_put_buffer_in,
|
2019-09-19 23:24:22 +02:00
|
|
|
.volume_in = qpa_volume_in
|
2008-07-02 23:03:08 +02:00
|
|
|
};
|
|
|
|
|
2018-03-06 08:40:47 +01:00
|
|
|
static struct audio_driver pa_audio_driver = {
|
2009-08-11 02:31:14 +02:00
|
|
|
.name = "pa",
|
|
|
|
.descr = "http://www.pulseaudio.org/",
|
|
|
|
.init = qpa_audio_init,
|
|
|
|
.fini = qpa_audio_fini,
|
|
|
|
.pcm_ops = &qpa_pcm_ops,
|
2009-10-13 16:08:55 +02:00
|
|
|
.can_be_default = 1,
|
2009-08-11 02:31:14 +02:00
|
|
|
.max_voices_out = INT_MAX,
|
|
|
|
.max_voices_in = INT_MAX,
|
|
|
|
.voice_size_out = sizeof (PAVoiceOut),
|
2012-04-17 14:32:43 +02:00
|
|
|
.voice_size_in = sizeof (PAVoiceIn),
|
2008-07-02 23:03:08 +02:00
|
|
|
};
|
2018-03-06 08:40:47 +01:00
|
|
|
|
|
|
|
static void register_audio_pa(void)
|
|
|
|
{
|
|
|
|
audio_driver_register(&pa_audio_driver);
|
|
|
|
}
|
|
|
|
type_init(register_audio_pa);
|