/* GSequencer - Advanced GTK Sequencer
* Copyright (C) 2005-2023 Joël Krähemann
*
* This file is part of GSequencer.
*
* GSequencer 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 3 of the License, or
* (at your option) any later version.
*
* GSequencer 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 GSequencer. If not, see .
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
void ags_pulse_port_class_init(AgsPulsePortClass *pulse_port);
void ags_pulse_port_connectable_interface_init(AgsConnectableInterface *connectable);
void ags_pulse_port_init(AgsPulsePort *pulse_port);
void ags_pulse_port_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec);
void ags_pulse_port_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec);
void ags_pulse_port_dispose(GObject *gobject);
void ags_pulse_port_finalize(GObject *gobject);
AgsUUID* ags_pulse_port_get_uuid(AgsConnectable *connectable);
gboolean ags_pulse_port_has_resource(AgsConnectable *connectable);
gboolean ags_pulse_port_is_ready(AgsConnectable *connectable);
void ags_pulse_port_add_to_registry(AgsConnectable *connectable);
void ags_pulse_port_remove_from_registry(AgsConnectable *connectable);
xmlNode* ags_pulse_port_list_resource(AgsConnectable *connectable);
xmlNode* ags_pulse_port_xml_compose(AgsConnectable *connectable);
void ags_pulse_port_xml_parse(AgsConnectable *connectable,
xmlNode *node);
gboolean ags_pulse_port_is_connected(AgsConnectable *connectable);
void ags_pulse_port_connect(AgsConnectable *connectable);
void ags_pulse_port_disconnect(AgsConnectable *connectable);
#ifdef AGS_WITH_PULSE
void ags_pulse_port_cached_stream_request_callback(pa_stream *stream, size_t length, AgsPulsePort *pulse_port);
void ags_pulse_port_stream_request_callback(pa_stream *stream, size_t length, AgsPulsePort *pulse_port);
void ags_pulse_port_stream_underflow_callback(pa_stream *stream, AgsPulsePort *pulse_port);
#endif
/**
* SECTION:ags_pulse_port
* @short_description: pulseaudio resource.
* @title: AgsPulsePort
* @section_id:
* @include: ags/audio/pulse/ags_pulse_port.h
*
* The #AgsPulsePort represents either a pulseaudio sequencer or soundcard to communicate
* with.
*/
enum{
PROP_0,
PROP_PULSE_CLIENT,
PROP_PULSE_DEVOUT,
PROP_PULSE_DEVIN,
PROP_PORT_NAME,
};
static gpointer ags_pulse_port_parent_class = NULL;
GType
ags_pulse_port_get_type()
{
static gsize g_define_type_id__static = 0;
if(g_once_init_enter(&g_define_type_id__static)){
GType ags_type_pulse_port = 0;
static const GTypeInfo ags_pulse_port_info = {
sizeof(AgsPulsePortClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) ags_pulse_port_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(AgsPulsePort),
0, /* n_preallocs */
(GInstanceInitFunc) ags_pulse_port_init,
};
static const GInterfaceInfo ags_connectable_interface_info = {
(GInterfaceInitFunc) ags_pulse_port_connectable_interface_init,
NULL, /* interface_finalize */
NULL, /* interface_data */
};
ags_type_pulse_port = g_type_register_static(G_TYPE_OBJECT,
"AgsPulsePort",
&ags_pulse_port_info,
0);
g_type_add_interface_static(ags_type_pulse_port,
AGS_TYPE_CONNECTABLE,
&ags_connectable_interface_info);
g_once_init_leave(&g_define_type_id__static, ags_type_pulse_port);
}
return(g_define_type_id__static);
}
GType
ags_pulse_port_flags_get_type()
{
static gsize g_flags_type_id__static;
if(g_once_init_enter(&g_flags_type_id__static)){
static const GFlagsValue values[] = {
{ AGS_PULSE_PORT_REGISTERED, "AGS_PULSE_PORT_REGISTERED", "pulse-port-registered" },
{ AGS_PULSE_PORT_IS_AUDIO, "AGS_PULSE_PORT_IS_AUDIO", "pulse-port-is-audio" },
{ AGS_PULSE_PORT_IS_MIDI, "AGS_PULSE_PORT_IS_MIDI", "pulse-port-is-midi" },
{ AGS_PULSE_PORT_IS_OUTPUT, "AGS_PULSE_PORT_IS_OUTPUT", "pulse-port-is-output" },
{ AGS_PULSE_PORT_IS_INPUT, "AGS_PULSE_PORT_IS_INPUT", "pulse-port-is-input" },
{ 0, NULL, NULL }
};
GType g_flags_type_id = g_flags_register_static(g_intern_static_string("AgsPulsePortFlags"), values);
g_once_init_leave(&g_flags_type_id__static, g_flags_type_id);
}
return(g_flags_type_id__static);
}
void
ags_pulse_port_class_init(AgsPulsePortClass *pulse_port)
{
GObjectClass *gobject;
GParamSpec *param_spec;
ags_pulse_port_parent_class = g_type_class_peek_parent(pulse_port);
/* GObjectClass */
gobject = (GObjectClass *) pulse_port;
gobject->set_property = ags_pulse_port_set_property;
gobject->get_property = ags_pulse_port_get_property;
gobject->dispose = ags_pulse_port_dispose;
gobject->finalize = ags_pulse_port_finalize;
/* properties */
/**
* AgsPulsePort:pulse-client:
*
* The assigned #AgsPulseClient.
*
* Since: 3.0.0
*/
param_spec = g_param_spec_object("pulse-client",
i18n_pspec("assigned pulseaudio client"),
i18n_pspec("The assigned pulseaudio client"),
AGS_TYPE_PULSE_CLIENT,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PULSE_CLIENT,
param_spec);
/**
* AgsPulsePort:pulse-devout:
*
* The assigned #AgsPulseDevout.
*
* Since: 3.0.0
*/
param_spec = g_param_spec_object("pulse-devout",
i18n_pspec("assigned pulseaudio devout"),
i18n_pspec("The assigned pulseaudio devout"),
AGS_TYPE_PULSE_DEVOUT,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PULSE_DEVOUT,
param_spec);
/**
* AgsPulsePort:pulse-devin:
*
* The assigned #AgsPulseDevout.
*
* Since: 3.0.0
*/
param_spec = g_param_spec_object("pulse-devin",
i18n_pspec("assigned pulseaudio devin"),
i18n_pspec("The assigned pulseaudio devin"),
AGS_TYPE_PULSE_DEVIN,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PULSE_DEVIN,
param_spec);
/**
* AgsPulsePort:port-name:
*
* The pulse soundcard indentifier
*
* Since: 3.0.0
*/
param_spec = g_param_spec_string("port-name",
i18n_pspec("port name"),
i18n_pspec("The port name"),
NULL,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PORT_NAME,
param_spec);
}
void
ags_pulse_port_connectable_interface_init(AgsConnectableInterface *connectable)
{
connectable->get_uuid = ags_pulse_port_get_uuid;
connectable->has_resource = ags_pulse_port_has_resource;
connectable->is_ready = ags_pulse_port_is_ready;
connectable->add_to_registry = ags_pulse_port_add_to_registry;
connectable->remove_from_registry = ags_pulse_port_remove_from_registry;
connectable->list_resource = ags_pulse_port_list_resource;
connectable->xml_compose = ags_pulse_port_xml_compose;
connectable->xml_parse = ags_pulse_port_xml_parse;
connectable->is_connected = ags_pulse_port_is_connected;
connectable->connect = ags_pulse_port_connect;
connectable->disconnect = ags_pulse_port_disconnect;
connectable->connect_connection = NULL;
connectable->disconnect_connection = NULL;
}
void
ags_pulse_port_init(AgsPulsePort *pulse_port)
{
AgsConfig *config;
gchar *str;
guint word_size;
guint fixed_size;
guint i;
/* flags */
pulse_port->flags = 0;
pulse_port->connectable_flags = 0;
/* port mutex */
g_rec_mutex_init(&(pulse_port->obj_mutex));
/* parent */
pulse_port->pulse_client = NULL;
/* uuid */
pulse_port->uuid = ags_uuid_alloc();
ags_uuid_generate(pulse_port->uuid);
/* */
pulse_port->pulse_devout = NULL;
pulse_port->pulse_devin = NULL;
pulse_port->port_uuid = ags_id_generator_create_uuid();
pulse_port->port_name = NULL;
pulse_port->stream = NULL;
/* presets */
config = ags_config_get_instance();
pulse_port->pcm_channels = ags_soundcard_helper_config_get_pcm_channels(config);
pulse_port->samplerate = ags_soundcard_helper_config_get_samplerate(config);
pulse_port->buffer_size = ags_soundcard_helper_config_get_buffer_size(config);
pulse_port->format = ags_soundcard_helper_config_get_format(config);
#if 0
pulse_port->use_cache = TRUE;
pulse_port->cache_buffer_size = AGS_PULSE_PORT_DEFAULT_CACHE_BUFFER_SIZE;
#else
pulse_port->use_cache = ags_soundcard_helper_config_get_use_cache(config);
pulse_port->cache_buffer_size = ags_soundcard_helper_config_get_cache_buffer_size(config);
#endif
pulse_port->cache_mutex = (GRecMutex **) malloc(AGS_PULSE_PORT_DEFAULT_CACHE_COUNT * sizeof(GRecMutex *));
for(i = 0; i < AGS_PULSE_PORT_DEFAULT_CACHE_COUNT; i++){
pulse_port->cache_mutex[i] = (GRecMutex *) malloc(sizeof(GRecMutex));
g_rec_mutex_init(pulse_port->cache_mutex[i]);
}
pulse_port->current_cache = 0;
pulse_port->completed_cache = 0;
pulse_port->cache_offset = 0;
pulse_port->cache = (void **) malloc(AGS_PULSE_PORT_DEFAULT_CACHE_COUNT * sizeof(void *));
#ifdef AGS_WITH_PULSE
pulse_port->sample_spec = (pa_sample_spec *) malloc(sizeof(pa_sample_spec));
pulse_port->sample_spec->rate = pulse_port->samplerate;
pulse_port->sample_spec->channels = pulse_port->pcm_channels;
#else
pulse_port->sample_spec = NULL;
#endif
word_size = 0;
switch(pulse_port->format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
#ifdef AGS_WITH_PULSE
if(ags_endian_host_is_be()){
pulse_port->sample_spec->format = PA_SAMPLE_S16BE;
}else{
pulse_port->sample_spec->format = PA_SAMPLE_S16LE;
}
#endif
pulse_port->cache[0] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint16));
pulse_port->cache[1] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint16));
pulse_port->cache[2] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint16));
pulse_port->cache[3] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint16));
word_size = sizeof(gint16);
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
#ifdef AGS_WITH_PULSE
if(ags_endian_host_is_be()){
pulse_port->sample_spec->format = PA_SAMPLE_S24_32BE;
}else{
pulse_port->sample_spec->format = PA_SAMPLE_S24_32LE;
}
#endif
pulse_port->cache[0] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
word_size = sizeof(gint32);
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
#ifdef AGS_WITH_PULSE
if(ags_endian_host_is_be()){
pulse_port->sample_spec->format = PA_SAMPLE_S32BE;
}else{
pulse_port->sample_spec->format = PA_SAMPLE_S32LE;
}
#endif
pulse_port->cache[0] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) malloc(pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
word_size = sizeof(gint32);
}
break;
default:
g_warning("pulse devout/devin - unsupported format");
}
fixed_size = pulse_port->pcm_channels * pulse_port->cache_buffer_size * word_size;
memset(pulse_port->cache[0], 0, pulse_port->pcm_channels * pulse_port->cache_buffer_size * word_size);
memset(pulse_port->cache[1], 0, pulse_port->pcm_channels * pulse_port->cache_buffer_size * word_size);
memset(pulse_port->cache[2], 0, pulse_port->pcm_channels * pulse_port->cache_buffer_size * word_size);
memset(pulse_port->cache[3], 0, pulse_port->pcm_channels * pulse_port->cache_buffer_size * word_size);
#ifdef AGS_WITH_PULSE
pulse_port->buffer_attr = (pa_buffer_attr *) malloc(sizeof(pa_buffer_attr));
pulse_port->buffer_attr->fragsize = (uint32_t) -1;
pulse_port->buffer_attr->maxlength = (uint32_t) -1;
pulse_port->buffer_attr->minreq = (uint32_t) fixed_size;
pulse_port->buffer_attr->prebuf = (uint32_t) 0;
pulse_port->buffer_attr->tlength = (uint32_t) fixed_size;
#else
pulse_port->buffer_attr = NULL;
#endif
pulse_port->empty_buffer = ags_stream_alloc(8 * pulse_port->pcm_channels * pulse_port->buffer_size,
AGS_SOUNDCARD_DEFAULT_FORMAT);
ags_atomic_int_set(&(pulse_port->is_empty),
TRUE);
ags_atomic_int_set(&(pulse_port->underflow),
0);
ags_atomic_int_set(&(pulse_port->restart),
FALSE);
pulse_port->nth_empty_buffer = 0;
ags_atomic_int_set(&(pulse_port->queued),
0);
pulse_port->audio_buffer_util = ags_audio_buffer_util_alloc();
}
void
ags_pulse_port_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsPulsePort *pulse_port;
GRecMutex *pulse_port_mutex;
pulse_port = AGS_PULSE_PORT(gobject);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
switch(prop_id){
case PROP_PULSE_CLIENT:
{
AgsPulseClient *pulse_client;
pulse_client = (AgsPulseClient *) g_value_get_object(value);
g_rec_mutex_lock(pulse_port_mutex);
if(pulse_port->pulse_client == (GObject *) pulse_client){
g_rec_mutex_unlock(pulse_port_mutex);
return;
}
if(pulse_port->pulse_client != NULL){
g_object_unref(pulse_port->pulse_client);
}
if(pulse_client != NULL){
g_object_ref(pulse_client);
}
pulse_port->pulse_client = (GObject *) pulse_client;
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
case PROP_PULSE_DEVOUT:
{
AgsPulseDevout *pulse_devout;
pulse_devout = (AgsPulseDevout *) g_value_get_object(value);
g_rec_mutex_lock(pulse_port_mutex);
if(pulse_port->pulse_devout == (GObject *) pulse_devout){
g_rec_mutex_unlock(pulse_port_mutex);
return;
}
if(pulse_port->pulse_devout != NULL){
g_object_unref(pulse_port->pulse_devout);
}
if(pulse_devout != NULL){
g_object_ref(pulse_devout);
}
pulse_port->pulse_devout = (GObject *) pulse_devout;
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
case PROP_PULSE_DEVIN:
{
AgsPulseDevin *pulse_devin;
pulse_devin = (AgsPulseDevin *) g_value_get_object(value);
g_rec_mutex_lock(pulse_port_mutex);
if(pulse_port->pulse_devin == (GObject *) pulse_devin){
g_rec_mutex_unlock(pulse_port_mutex);
return;
}
if(pulse_port->pulse_devin != NULL){
g_object_unref(pulse_port->pulse_devin);
}
if(pulse_devin != NULL){
g_object_ref(pulse_devin);
}
pulse_port->pulse_devin = (GObject *) pulse_devin;
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
case PROP_PORT_NAME:
{
gchar *port_name;
port_name = g_value_get_string(value);
g_rec_mutex_lock(pulse_port_mutex);
if(pulse_port->port_name == port_name ||
!g_ascii_strcasecmp(pulse_port->port_name,
port_name)){
g_rec_mutex_unlock(pulse_port_mutex);
return;
}
if(pulse_port->port_name != NULL){
g_free(pulse_port->port_name);
}
pulse_port->port_name = port_name;
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_pulse_port_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsPulsePort *pulse_port;
GRecMutex *pulse_port_mutex;
pulse_port = AGS_PULSE_PORT(gobject);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
switch(prop_id){
case PROP_PULSE_CLIENT:
{
g_rec_mutex_lock(pulse_port_mutex);
g_value_set_object(value, pulse_port->pulse_client);
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
case PROP_PULSE_DEVOUT:
{
g_rec_mutex_lock(pulse_port_mutex);
g_value_set_object(value, pulse_port->pulse_devout);
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
case PROP_PULSE_DEVIN:
{
g_rec_mutex_lock(pulse_port_mutex);
g_value_set_object(value, pulse_port->pulse_devin);
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
case PROP_PORT_NAME:
{
g_rec_mutex_lock(pulse_port_mutex);
g_value_set_string(value, pulse_port->port_name);
g_rec_mutex_unlock(pulse_port_mutex);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_pulse_port_dispose(GObject *gobject)
{
AgsPulsePort *pulse_port;
pulse_port = AGS_PULSE_PORT(gobject);
/* pulse client */
if(pulse_port->pulse_client != NULL){
g_object_unref(pulse_port->pulse_client);
pulse_port->pulse_client = NULL;
}
/* pulse devout */
if(pulse_port->pulse_devout != NULL){
g_object_unref(pulse_port->pulse_devout);
pulse_port->pulse_devout = NULL;
}
/* pulse devin */
if(pulse_port->pulse_devin != NULL){
g_object_unref(pulse_port->pulse_devin);
pulse_port->pulse_devin = NULL;
}
/* call parent */
G_OBJECT_CLASS(ags_pulse_port_parent_class)->dispose(gobject);
}
void
ags_pulse_port_finalize(GObject *gobject)
{
AgsPulsePort *pulse_port;
pulse_port = AGS_PULSE_PORT(gobject);
/* pulse client */
if(pulse_port->pulse_client != NULL){
g_object_unref(pulse_port->pulse_client);
}
/* pulse devout */
if(pulse_port->pulse_devout != NULL){
g_object_unref(pulse_port->pulse_devout);
}
/* pulse devin */
if(pulse_port->pulse_devin != NULL){
g_object_unref(pulse_port->pulse_devin);
}
/* name */
g_free(pulse_port->port_name);
if(pulse_port->sample_spec != NULL){
free(pulse_port->sample_spec);
}
if(pulse_port->buffer_attr != NULL){
free(pulse_port->buffer_attr);
}
ags_audio_buffer_util_set_source(pulse_port->audio_buffer_util,
NULL);
ags_audio_buffer_util_set_destination(pulse_port->audio_buffer_util,
NULL);
ags_audio_buffer_util_free(pulse_port->audio_buffer_util);
/* call parent */
G_OBJECT_CLASS(ags_pulse_port_parent_class)->finalize(gobject);
}
AgsUUID*
ags_pulse_port_get_uuid(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
AgsUUID *ptr;
GRecMutex *pulse_port_mutex;
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port signal mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* get UUID */
g_rec_mutex_lock(pulse_port_mutex);
ptr = pulse_port->uuid;
g_rec_mutex_unlock(pulse_port_mutex);
return(ptr);
}
gboolean
ags_pulse_port_has_resource(AgsConnectable *connectable)
{
return(FALSE);
}
gboolean
ags_pulse_port_is_ready(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
gboolean is_ready;
GRecMutex *pulse_port_mutex;
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* check is ready */
g_rec_mutex_lock(pulse_port_mutex);
is_ready = ((AGS_CONNECTABLE_ADDED_TO_REGISTRY & (pulse_port->connectable_flags)) != 0) ? TRUE: FALSE;
g_rec_mutex_unlock(pulse_port_mutex);
return(is_ready);
}
void
ags_pulse_port_add_to_registry(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
GRecMutex *pulse_port_mutex;
if(ags_connectable_is_ready(connectable)){
return;
}
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->connectable_flags |= AGS_CONNECTABLE_ADDED_TO_REGISTRY;
g_rec_mutex_unlock(pulse_port_mutex);
}
void
ags_pulse_port_remove_from_registry(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
GRecMutex *pulse_port_mutex;
if(!ags_connectable_is_ready(connectable)){
return;
}
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->connectable_flags &= (~AGS_CONNECTABLE_ADDED_TO_REGISTRY);
g_rec_mutex_unlock(pulse_port_mutex);
}
xmlNode*
ags_pulse_port_list_resource(AgsConnectable *connectable)
{
xmlNode *node;
node = NULL;
//TODO:JK: implement me
return(node);
}
xmlNode*
ags_pulse_port_xml_compose(AgsConnectable *connectable)
{
xmlNode *node;
node = NULL;
//TODO:JK: implement me
return(node);
}
void
ags_pulse_port_xml_parse(AgsConnectable *connectable,
xmlNode *node)
{
//TODO:JK: implement me
}
gboolean
ags_pulse_port_is_connected(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
gboolean is_connected;
GRecMutex *pulse_port_mutex;
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* check is connected */
g_rec_mutex_lock(pulse_port_mutex);
is_connected = ((AGS_CONNECTABLE_CONNECTED & (pulse_port->connectable_flags)) != 0) ? TRUE: FALSE;
g_rec_mutex_unlock(pulse_port_mutex);
return(is_connected);
}
void
ags_pulse_port_connect(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
GRecMutex *pulse_port_mutex;
if(ags_connectable_is_connected(connectable)){
return;
}
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->connectable_flags |= AGS_CONNECTABLE_CONNECTED;
g_rec_mutex_unlock(pulse_port_mutex);
}
void
ags_pulse_port_disconnect(AgsConnectable *connectable)
{
AgsPulsePort *pulse_port;
GRecMutex *pulse_port_mutex;
if(!ags_connectable_is_connected(connectable)){
return;
}
pulse_port = AGS_PULSE_PORT(connectable);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->connectable_flags &= (~AGS_CONNECTABLE_CONNECTED);
g_rec_mutex_unlock(pulse_port_mutex);
}
/**
* ags_pulse_port_test_flags:
* @pulse_port: the #AgsPulsePort
* @flags: the flags
*
* Test @flags to be set on @pulse_port.
*
* Returns: %TRUE if flags are set, else %FALSE
*
* Since: 3.0.0
*/
gboolean
ags_pulse_port_test_flags(AgsPulsePort *pulse_port, guint flags)
{
gboolean retval;
GRecMutex *pulse_port_mutex;
if(!AGS_IS_PULSE_PORT(pulse_port)){
return(FALSE);
}
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* test */
g_rec_mutex_lock(pulse_port_mutex);
retval = (flags & (pulse_port->flags)) ? TRUE: FALSE;
g_rec_mutex_unlock(pulse_port_mutex);
return(retval);
}
/**
* ags_pulse_port_set_flags:
* @pulse_port: the #AgsPulsePort
* @flags: see #AgsPulsePortFlags-enum
*
* Enable a feature of @pulse_port.
*
* Since: 3.0.0
*/
void
ags_pulse_port_set_flags(AgsPulsePort *pulse_port, guint flags)
{
GRecMutex *pulse_port_mutex;
if(!AGS_IS_PULSE_PORT(pulse_port)){
return;
}
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
//TODO:JK: add more?
/* set flags */
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->flags |= flags;
g_rec_mutex_unlock(pulse_port_mutex);
}
/**
* ags_pulse_port_unset_flags:
* @pulse_port: the #AgsPulsePort
* @flags: see #AgsPulsePortFlags-enum
*
* Disable a feature of @pulse_port.
*
* Since: 3.0.0
*/
void
ags_pulse_port_unset_flags(AgsPulsePort *pulse_port, guint flags)
{
GRecMutex *pulse_port_mutex;
if(!AGS_IS_PULSE_PORT(pulse_port)){
return;
}
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
//TODO:JK: add more?
/* unset flags */
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->flags &= (~flags);
g_rec_mutex_unlock(pulse_port_mutex);
}
/**
* ags_pulse_port_find:
* @pulse_port: (element-type AgsAudio.PulsePort) (transfer none): the #GList-struct containig #AgsPulsePort
* @port_name: the port name to find
*
* Finds next match of @port_name in @pulse_port.
*
* Returns: (element-type AgsAudio.PulsePort) (transfer none): the next matching #GList-struct or %NULL
*
* Since: 3.0.0
*/
GList*
ags_pulse_port_find(GList *pulse_port,
gchar *port_name)
{
gboolean success;
GRecMutex *pulse_port_mutex;
while(pulse_port != NULL){
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port->data);
/* check port name */
g_rec_mutex_lock(pulse_port_mutex);
success = (!g_ascii_strcasecmp(AGS_PULSE_PORT(pulse_port->data)->port_name,
port_name)) ? TRUE: FALSE;
g_rec_mutex_unlock(pulse_port_mutex);
if(success){
return(pulse_port);
}
}
return(NULL);
}
/**
* ags_pulse_port_register:
* @pulse_port: the #AgsPulsePort
* @port_name: the name as string
* @is_audio: if %TRUE interpreted as audio port
* @is_midi: if %TRUE interpreted as midi port
* @is_output: if %TRUE port is acting as output, otherwise as input
*
* Register a new pulseaudio port and read uuid. Creates a new AgsSequencer or AgsSoundcard
* object.
*
* Since: 3.0.0
*/
void
ags_pulse_port_register(AgsPulsePort *pulse_port,
gchar *port_name,
gboolean is_audio, gboolean is_midi,
gboolean is_output)
{
AgsPulseServer *pulse_server;
AgsPulseClient *pulse_client;
#ifdef AGS_WITH_PULSE
pa_context *context;
pa_stream *stream;
pa_sample_spec *sample_spec;
pa_buffer_attr *buffer_attr;
#else
gpointer context;
gpointer stream;
gpointer sample_spec;
gpointer buffer_attr;
#endif
GList *list;
int r;
gboolean use_cache;
GRecMutex *pulse_client_mutex;
GRecMutex *pulse_port_mutex;
if(!AGS_IS_PULSE_PORT(pulse_port) ||
port_name == NULL){
return;
}
g_object_get(pulse_port,
"pulse-client", &pulse_client,
NULL);
if(pulse_client == NULL){
g_warning("ags_pulse_port.c - no assigned AgsPulseClient");
return;
}
if(ags_pulse_port_test_flags(pulse_port, AGS_PULSE_PORT_REGISTERED)){
g_object_unref(pulse_client);
return;
}
/* get pulse server and application context */
g_object_get(pulse_client,
"pulse-server", &pulse_server,
NULL);
if(pulse_server == NULL){
g_object_unref(pulse_client);
return;
}
/* get pulse client mutex */
pulse_client_mutex = AGS_PULSE_CLIENT_GET_OBJ_MUTEX(pulse_client);
/* get context */
g_rec_mutex_lock(pulse_client_mutex);
context = pulse_client->context;
g_rec_mutex_unlock(pulse_client_mutex);
if(context == NULL){
g_object_unref(pulse_client);
g_object_unref(pulse_server);
return;
}
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* get port name */
//FIXME:JK: memory leak?
g_rec_mutex_lock(pulse_port_mutex);
sample_spec = pulse_port->sample_spec;
buffer_attr = pulse_port->buffer_attr;
port_name = g_strdup(pulse_port->port_name);
use_cache = pulse_port->use_cache;
g_rec_mutex_unlock(pulse_port_mutex);
/* create sequencer or soundcard */
if(is_output){
ags_pulse_port_set_flags(pulse_port, AGS_PULSE_PORT_IS_OUTPUT);
}
#ifdef AGS_WITH_PULSE
stream = pa_stream_new(context, "Playback", sample_spec, NULL);
#else
stream = NULL;
#endif
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->stream = stream;
g_rec_mutex_unlock(pulse_port_mutex);
if(stream == NULL){
return;
}
#ifdef AGS_WITH_PULSE
if(is_audio){
ags_pulse_port_set_flags(pulse_port, AGS_PULSE_PORT_IS_AUDIO);
if(use_cache){
pa_stream_set_write_callback(stream,
(pa_stream_request_cb_t) ags_pulse_port_cached_stream_request_callback,
pulse_port);
}else{
pa_stream_set_write_callback(stream,
(pa_stream_request_cb_t) ags_pulse_port_stream_request_callback,
pulse_port);
}
pa_stream_set_underflow_callback(stream,
(pa_stream_notify_cb_t) ags_pulse_port_stream_underflow_callback,
pulse_port);
r = pa_stream_connect_playback(stream, NULL, buffer_attr,
(PA_STREAM_INTERPOLATE_TIMING |
PA_STREAM_ADJUST_LATENCY |
PA_STREAM_AUTO_TIMING_UPDATE),
NULL,
NULL);
if(r < 0){
// Old pulse audio servers don't like the ADJUST_LATENCY flag, so retry without that
r = pa_stream_connect_playback(stream, NULL, buffer_attr,
(PA_STREAM_INTERPOLATE_TIMING |
PA_STREAM_AUTO_TIMING_UPDATE),
NULL,
NULL);
}
if(r < 0){
return;
}
}else if(is_midi){
ags_pulse_port_set_flags(pulse_port, AGS_PULSE_PORT_IS_MIDI);
//NOTE:JK: not implemented
}
if(stream != NULL){
ags_pulse_port_set_flags(pulse_port, AGS_PULSE_PORT_REGISTERED);
}
#endif
g_object_unref(pulse_client);
g_object_unref(pulse_server);
}
void
ags_pulse_port_unregister(AgsPulsePort *pulse_port)
{
#ifdef AGS_WITH_PULSE
pa_stream *stream;
#else
gpointer stream;
#endif
GRecMutex *pulse_port_mutex;
if(!AGS_IS_PULSE_PORT(pulse_port)){
return;
}
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* get port */
g_rec_mutex_lock(pulse_port_mutex);
stream = pulse_port->stream;
g_rec_mutex_unlock(pulse_port_mutex);
#ifdef AGS_WITH_PULSE
if(stream != NULL){
pa_stream_disconnect(stream);
/* unset port and flags */
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->stream = NULL;
g_rec_mutex_unlock(pulse_port_mutex);
ags_pulse_port_unset_flags(pulse_port, AGS_PULSE_PORT_REGISTERED);
}
#endif
}
#ifdef AGS_WITH_PULSE
void
ags_pulse_port_cached_stream_request_callback(pa_stream *stream, size_t length, AgsPulsePort *pulse_port)
{
AgsPulseDevout *pulse_devout;
AgsPulseDevin *pulse_devin;
AgsAudioLoop *audio_loop;
AgsApplicationContext *application_context;
GObject *soundcard;
guint current_cache;
guint next_cache, completed_cache;
guint played_cache;
guint word_size;
size_t frame_size;
GRecMutex *pulse_port_mutex;
GRecMutex *device_mutex;
GRecMutex *cache_mutex;
if(pulse_port == NULL){
return;
}
application_context = ags_application_context_get_instance();
audio_loop = (AgsAudioLoop *) ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
ags_thread_unset_flags((AgsThread *) audio_loop, AGS_THREAD_TIME_ACCOUNTING);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* */
g_rec_mutex_lock(pulse_port_mutex);
pulse_devout = (AgsPulseDevout *) pulse_port->pulse_devout;
pulse_devin = (AgsPulseDevin *) pulse_port->pulse_devin;
current_cache = pulse_port->current_cache;
word_size = 0;
switch(pulse_port->format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
word_size = sizeof(gint16);
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
word_size = sizeof(gint32);
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
word_size = sizeof(gint32);
}
break;
}
frame_size = pulse_port->sample_spec->channels * pulse_port->cache_buffer_size * word_size;
g_rec_mutex_unlock(pulse_port_mutex);
soundcard = NULL;
if(pulse_devout != NULL){
soundcard = (GObject *) pulse_devout;
}else if(pulse_devin != NULL){
soundcard = (GObject *) pulse_devin;
}
/* get device mutex */
if(AGS_IS_PULSE_DEVOUT(soundcard)){
device_mutex = AGS_PULSE_DEVOUT_GET_OBJ_MUTEX(soundcard);
}else if(AGS_IS_PULSE_DEVIN(soundcard)){
device_mutex = AGS_PULSE_DEVIN_GET_OBJ_MUTEX(soundcard);
}else{
g_object_unref(audio_loop);
return;
}
if(ags_soundcard_is_playing(AGS_SOUNDCARD(soundcard))){
if(current_cache == 3){
next_cache = 0;
}else{
next_cache = current_cache + 1;
}
}else{
next_cache = 0;
}
/* wait until cache ready */
g_rec_mutex_lock(pulse_port_mutex);
completed_cache = pulse_port->completed_cache;
g_rec_mutex_unlock(pulse_port_mutex);
if(AGS_IS_PULSE_DEVOUT(soundcard)){
size_t n_bytes;
struct timespec idle_time = {
0,
0,
};
if(ags_soundcard_is_playing(AGS_SOUNDCARD(soundcard))){
idle_time.tv_nsec = ags_pulse_port_get_latency(pulse_port) / 8;
while(next_cache == completed_cache &&
ags_soundcard_is_playing(AGS_SOUNDCARD(soundcard))){
ags_time_nanosleep(&idle_time);
g_rec_mutex_lock(pulse_port_mutex);
completed_cache = pulse_port->completed_cache;
g_rec_mutex_unlock(pulse_port_mutex);
}
if(current_cache == 0){
played_cache = 3;
}else{
played_cache = current_cache - 1;
}
}else{
played_cache = 0;
}
cache_mutex = pulse_port->cache_mutex[played_cache];
g_rec_mutex_lock(cache_mutex);
n_bytes = 0;
pa_stream_begin_write(stream,
&(pulse_port->cache[played_cache]),
&n_bytes);
pa_stream_write(stream,
pulse_port->cache[played_cache],
frame_size,
NULL,
0,
PA_SEEK_RELATIVE);
g_rec_mutex_unlock(cache_mutex);
}else{
if(current_cache == 3){
played_cache = 0;
}else{
played_cache = current_cache + 1;
}
cache_mutex = pulse_port->cache_mutex[played_cache];
g_rec_mutex_lock(cache_mutex);
pa_stream_peek(stream,
(const void **) &(pulse_port->cache[played_cache]),
&frame_size);
g_rec_mutex_unlock(cache_mutex);
}
/* seek current cache */
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->current_cache = next_cache;
g_rec_mutex_unlock(pulse_port_mutex);
/* unref */
g_object_unref(audio_loop);
}
void
ags_pulse_port_stream_request_callback(pa_stream *stream, size_t length, AgsPulsePort *pulse_port)
{
AgsPulseDevout *pulse_devout;
AgsPulseDevin *pulse_devin;
AgsAudioLoop *audio_loop;
AgsApplicationContext *application_context;
GObject *soundcard;
guint word_size;
size_t count;
guint nth_buffer;
guint nth_empty_buffer, next_nth_empty_buffer;
size_t n_bytes;
gint remaining;
guint i;
gboolean no_event;
gboolean empty_run;
GRecMutex *pulse_port_mutex;
GRecMutex *device_mutex;
GMutex *callback_mutex;
GMutex *callback_finish_mutex;
if(pulse_port == NULL){
return;
}
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
if(ags_atomic_int_get(&(pulse_port->queued)) > 0){
g_warning("drop pulseaudio callback");
return;
}else{
ags_atomic_int_increment(&(pulse_port->queued));
}
/*
* process audio
*/
/* */
application_context = ags_application_context_get_instance();
audio_loop = (AgsAudioLoop *) ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
ags_thread_unset_flags((AgsThread *) audio_loop, AGS_THREAD_TIME_ACCOUNTING);
/* */
g_rec_mutex_lock(pulse_port_mutex);
pulse_devout = (AgsPulseDevout *) pulse_port->pulse_devout;
pulse_devin = (AgsPulseDevin *) pulse_port->pulse_devin;
soundcard = NULL;
if(pulse_devout != NULL){
soundcard = (GObject *) pulse_devout;
}else if(pulse_devin != NULL){
soundcard = (GObject *) pulse_devin;
}
stream = pulse_port->stream;
nth_empty_buffer = pulse_port->nth_empty_buffer;
if(nth_empty_buffer >= 7){
next_nth_empty_buffer = 0;
}else{
next_nth_empty_buffer = nth_empty_buffer + 1;
}
g_rec_mutex_unlock(pulse_port_mutex);
/* get device mutex */
if(AGS_IS_PULSE_DEVOUT(soundcard)){
device_mutex = AGS_PULSE_DEVOUT_GET_OBJ_MUTEX(soundcard);
}else if(AGS_IS_PULSE_DEVIN(soundcard)){
device_mutex = AGS_PULSE_DEVIN_GET_OBJ_MUTEX(soundcard);
}else{
g_object_unref(audio_loop);
return;
}
/* */
g_rec_mutex_lock(device_mutex);
empty_run = FALSE;
if((pulse_devout == NULL ||
!ags_soundcard_is_playing(AGS_SOUNDCARD(pulse_devout))) &&
(pulse_devin == NULL ||
!ags_soundcard_is_recording(AGS_SOUNDCARD(pulse_devin)))){
empty_run = TRUE;
}
g_rec_mutex_unlock(device_mutex);
/* check buffer flag */
g_rec_mutex_lock(pulse_port_mutex);
word_size = 0;
switch(pulse_port->format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
word_size = sizeof(gint16);
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
word_size = sizeof(gint32);
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
word_size = sizeof(gint32);
}
break;
}
count = pulse_port->sample_spec->channels * pulse_port->buffer_size * word_size;
g_rec_mutex_unlock(pulse_port_mutex);
remaining = length;
if(empty_run){
void *empty_buffer;
void *next_empty_buffer;
n_bytes = 0;
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
pa_stream_begin_write(stream, &empty_buffer, &n_bytes);
// remaining = n_bytes;
remaining = length;
/* iterate */
for(i = 0; remaining > 0; i++){
g_rec_mutex_lock(pulse_port_mutex);
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
next_empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[next_nth_empty_buffer * count]);
nth_empty_buffer = next_nth_empty_buffer;
if(nth_empty_buffer >= 7){
next_nth_empty_buffer = 0;
}else{
next_nth_empty_buffer = nth_empty_buffer + 1;
}
pulse_port->nth_empty_buffer = nth_empty_buffer;
pa_stream_write(stream, empty_buffer, count, NULL, 0, PA_SEEK_RELATIVE);
g_rec_mutex_unlock(pulse_port_mutex);
memset(next_empty_buffer, 0, count * sizeof(unsigned char));
remaining -= count;
}
ags_atomic_int_set(&(pulse_port->is_empty),
TRUE);
}
g_rec_mutex_lock(device_mutex);
/* wait callback */
nth_buffer = 0;
no_event = TRUE;
if(pulse_devout != NULL){
if((AGS_PULSE_DEVOUT_PASS_THROUGH & (ags_atomic_int_get(&(pulse_devout->sync_flags)))) == 0){
callback_mutex = &(pulse_devout->callback_mutex);
g_rec_mutex_unlock(device_mutex);
/* give back computing time until ready */
g_mutex_lock(callback_mutex);
if((AGS_PULSE_DEVOUT_CALLBACK_DONE & (ags_atomic_int_get(&(pulse_devout->sync_flags)))) == 0){
gint64 timeout;
guint latency;
timeout = 0;
ags_atomic_int_or(&(pulse_devout->sync_flags),
AGS_PULSE_DEVOUT_CALLBACK_WAIT);
g_rec_mutex_lock(pulse_port_mutex);
latency = ags_pulse_port_get_latency(pulse_port);
g_rec_mutex_unlock(pulse_port_mutex);
latency /= 8;
timeout += latency;
while((AGS_PULSE_DEVOUT_CALLBACK_DONE & (ags_atomic_int_get(&(pulse_devout->sync_flags)))) == 0 &&
(AGS_PULSE_DEVOUT_CALLBACK_WAIT & (ags_atomic_int_get(&(pulse_devout->sync_flags)))) != 0){
void *empty_buffer;
void *next_empty_buffer;
g_cond_wait_until(&(pulse_devout->callback_cond),
callback_mutex,
timeout);
g_mutex_unlock(callback_mutex);
if(ags_atomic_int_get(&(pulse_port->underflow)) > 0){
n_bytes = 0;
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
#if 0
pa_stream_begin_write(stream, &empty_buffer, &n_bytes);
#endif
remaining = length;
}
/* feed */
for(i = 0; ags_atomic_int_get(&(pulse_port->underflow)) > 0 || remaining > 0; i++){
g_rec_mutex_lock(pulse_port_mutex);
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
next_empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[next_nth_empty_buffer * count]);
nth_empty_buffer = next_nth_empty_buffer;
if(nth_empty_buffer >= 7){
next_nth_empty_buffer = 0;
}else{
next_nth_empty_buffer = nth_empty_buffer + 1;
}
pulse_port->nth_empty_buffer = nth_empty_buffer;
#if 0
pa_stream_write(stream, empty_buffer, count, NULL, 0, PA_SEEK_RELATIVE);
#endif
g_rec_mutex_unlock(pulse_port_mutex);
memset(next_empty_buffer, 0, count * sizeof(unsigned char));
if(ags_atomic_int_get(&(pulse_port->underflow)) > 0){
ags_atomic_int_decrement(&(pulse_port->underflow));
}
remaining -= count;
}
g_rec_mutex_lock(pulse_port_mutex);
latency = ags_pulse_port_get_latency(pulse_port);
g_rec_mutex_unlock(pulse_port_mutex);
latency /= 8;
timeout = g_get_monotonic_time() + latency;
g_mutex_lock(callback_mutex);
}
}
ags_atomic_int_and(&(pulse_devout->sync_flags),
(~(AGS_PULSE_DEVOUT_CALLBACK_WAIT |
AGS_PULSE_DEVOUT_CALLBACK_DONE)));
g_mutex_unlock(callback_mutex);
no_event = FALSE;
g_rec_mutex_lock(device_mutex);
}
/* get buffer */
if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_0){
nth_buffer = 7;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_1){
nth_buffer = 0;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_2){
nth_buffer = 1;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_3){
nth_buffer = 2;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_4){
nth_buffer = 3;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_5){
nth_buffer = 4;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_6){
nth_buffer = 5;
}else if(pulse_devout->app_buffer_mode == AGS_PULSE_DEVOUT_APP_BUFFER_7){
nth_buffer = 6;
}else{
empty_run = TRUE;
}
}else if(pulse_devin != NULL){
if((AGS_PULSE_DEVIN_PASS_THROUGH & (ags_atomic_int_get(&(pulse_devin->sync_flags)))) == 0){
callback_mutex = &(pulse_devin->callback_mutex);
g_rec_mutex_unlock(device_mutex);
/* give back computing time until ready */
g_mutex_lock(callback_mutex);
if((AGS_PULSE_DEVIN_CALLBACK_DONE & (ags_atomic_int_get(&(pulse_devin->sync_flags)))) == 0){
ags_atomic_int_or(&(pulse_devin->sync_flags),
AGS_PULSE_DEVIN_CALLBACK_WAIT);
while((AGS_PULSE_DEVIN_CALLBACK_DONE & (ags_atomic_int_get(&(pulse_devin->sync_flags)))) == 0 &&
(AGS_PULSE_DEVIN_CALLBACK_WAIT & (ags_atomic_int_get(&(pulse_devin->sync_flags)))) != 0){
g_cond_wait(&(pulse_devin->callback_cond),
callback_mutex);
}
ags_atomic_int_and(&(pulse_devin->sync_flags),
(~(AGS_PULSE_DEVIN_CALLBACK_WAIT |
AGS_PULSE_DEVIN_CALLBACK_DONE)));
g_mutex_unlock(callback_mutex);
no_event = FALSE;
g_rec_mutex_lock(device_mutex);
}
}
/* get buffer */
if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_0){
nth_buffer = 7;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_1){
nth_buffer = 0;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_2){
nth_buffer = 1;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_3){
nth_buffer = 2;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_4){
nth_buffer = 3;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_5){
nth_buffer = 4;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_6){
nth_buffer = 5;
}else if(pulse_devin->app_buffer_mode == AGS_PULSE_DEVIN_APP_BUFFER_7){
nth_buffer = 6;
}else{
empty_run = TRUE;
}
}
switch(pulse_port->format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
word_size = sizeof(gint16);
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
word_size = sizeof(gint32);
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
word_size = sizeof(gint32);
}
break;
default:
empty_run = TRUE;
}
/* write */
count = pulse_devout->pcm_channels * pulse_devout->buffer_size * word_size;
if(pulse_devout != NULL){
if(!empty_run){
n_bytes = 0;
pa_stream_begin_write(stream, &(pulse_devout->app_buffer[nth_buffer]), &n_bytes);
// g_message("%d", ags_synth_util_get_xcross_count_s16(pulse_devout->app_buffer[nth_buffer],
// pulse_devout->pcm_channels * pulse_devout->buffer_size));
ags_soundcard_lock_buffer(AGS_SOUNDCARD(pulse_devout), pulse_devout->app_buffer[nth_buffer]);
pa_stream_write(stream,
pulse_devout->app_buffer[nth_buffer],
count,
NULL,
0,
PA_SEEK_RELATIVE);
ags_soundcard_unlock_buffer(AGS_SOUNDCARD(pulse_devout), pulse_devout->app_buffer[nth_buffer]);
ags_atomic_int_set(&(pulse_port->is_empty),
FALSE);
}
/* signal finish */
if(!no_event){
callback_finish_mutex = &(pulse_devout->callback_finish_mutex);
g_mutex_lock(callback_finish_mutex);
ags_atomic_int_or(&(pulse_devout->sync_flags),
AGS_PULSE_DEVOUT_CALLBACK_FINISH_DONE);
if((AGS_PULSE_DEVOUT_CALLBACK_FINISH_WAIT & (ags_atomic_int_get(&(pulse_devout->sync_flags)))) != 0){
g_cond_signal(&(pulse_devout->callback_finish_cond));
}
g_mutex_unlock(callback_finish_mutex);
}
g_rec_mutex_unlock(device_mutex);
if(empty_run){
void *empty_buffer;
void *next_empty_buffer;
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
n_bytes = 0;
pa_stream_begin_write(stream, &empty_buffer, &n_bytes);
remaining = length;
for(i = 0; remaining > 0; i++){
/* feed */
g_rec_mutex_lock(pulse_port_mutex);
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
next_empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[next_nth_empty_buffer * count]);
nth_empty_buffer = next_nth_empty_buffer;
if(nth_empty_buffer >= 7){
next_nth_empty_buffer = 0;
}else{
next_nth_empty_buffer = nth_empty_buffer + 1;
}
pulse_port->nth_empty_buffer = nth_empty_buffer;
pa_stream_write(stream, empty_buffer, count, NULL, 0, PA_SEEK_RELATIVE);
g_rec_mutex_unlock(pulse_port_mutex);
memset(next_empty_buffer, 0, count * sizeof(unsigned char));
remaining -= count;
}
}
}else if(pulse_devin != NULL){
if(!empty_run){
pa_stream_peek(stream,
(const void **) &(pulse_devin->app_buffer[nth_buffer]),
&count);
ags_atomic_int_set(&(pulse_port->is_empty),
FALSE);
}
/* signal finish */
if(!no_event){
callback_finish_mutex = &(pulse_devin->callback_finish_mutex);
g_mutex_lock(callback_finish_mutex);
ags_atomic_int_or(&(pulse_devin->sync_flags),
AGS_PULSE_DEVIN_CALLBACK_FINISH_DONE);
if((AGS_PULSE_DEVIN_CALLBACK_FINISH_WAIT & (ags_atomic_int_get(&(pulse_devin->sync_flags)))) != 0){
g_cond_signal(&(pulse_devin->callback_finish_cond));
}
g_mutex_unlock(callback_finish_mutex);
}
g_rec_mutex_unlock(device_mutex);
if(empty_run){
void *empty_buffer;
void *next_empty_buffer;
remaining = pa_stream_readable_size(stream);
for(i = 0; remaining > 0; i++){
/* feed */
g_rec_mutex_lock(pulse_port_mutex);
empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[nth_empty_buffer * count]);
next_empty_buffer = &(((unsigned char *) pulse_port->empty_buffer)[next_nth_empty_buffer * count]);
nth_empty_buffer = next_nth_empty_buffer;
if(nth_empty_buffer >= 7){
next_nth_empty_buffer = 0;
}else{
next_nth_empty_buffer = nth_empty_buffer + 1;
}
pulse_port->nth_empty_buffer = nth_empty_buffer;
pa_stream_peek(stream,
(const void **) &empty_buffer,
&count);
g_rec_mutex_unlock(pulse_port_mutex);
memset(next_empty_buffer, 0, count * sizeof(unsigned char));
remaining -= count;
}
}
}
ags_atomic_int_decrement(&(pulse_port->queued));
/* unref */
g_object_unref(audio_loop);
}
void
ags_pulse_port_stream_underflow_callback(pa_stream *stream, AgsPulsePort *pulse_port)
{
AgsAudioLoop *audio_loop;
AgsApplicationContext *application_context;
guint time_spent;
GRecMutex *audio_loop_mutex;
application_context = ags_application_context_get_instance();
audio_loop = (AgsAudioLoop *) ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
/* get audio loop mutex */
audio_loop_mutex = AGS_THREAD_GET_OBJ_MUTEX(audio_loop);
/* increase time spent */
ags_atomic_int_add(&(pulse_port->underflow),
1);
/* unref */
g_object_unref(audio_loop);
}
#endif
guint
ags_pulse_port_get_fixed_size(AgsPulsePort *pulse_port)
{
AgsPulseDevout *pulse_devout;
guint pcm_channels;
guint buffer_size;
AgsSoundcardFormat format;
guint word_size;
guint fixed_size;
GRecMutex *pulse_port_mutex;
GRecMutex *pulse_devout_mutex;
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* get pulse devout */
g_rec_mutex_lock(pulse_port_mutex);
pulse_devout = (AgsPulseDevout *) pulse_port->pulse_devout;
if(pulse_port->use_cache){
buffer_size = pulse_port->cache_buffer_size;
}else{
buffer_size = pulse_port->buffer_size;
}
g_rec_mutex_unlock(pulse_port_mutex);
/* get pulse devout mutex */
pulse_devout_mutex = AGS_PULSE_DEVOUT_GET_OBJ_MUTEX(pulse_devout);
/* */
g_rec_mutex_lock(pulse_devout_mutex);
pcm_channels = pulse_devout->pcm_channels;
format = pulse_devout->format;
g_rec_mutex_unlock(pulse_devout_mutex);
switch(format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
word_size = sizeof(gint16);
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
word_size = sizeof(gint32);
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
word_size = sizeof(gint32);
}
break;
default:
g_warning("pulse devout - unsupported format");
return(0);
}
fixed_size = pcm_channels * buffer_size * word_size;
return(fixed_size);
}
void
ags_pulse_port_set_samplerate(AgsPulsePort *pulse_port,
guint samplerate)
{
guint fixed_size;
GRecMutex *pulse_port_mutex;
fixed_size = ags_pulse_port_get_fixed_size(pulse_port);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* lock pulse port */
g_rec_mutex_lock(pulse_port_mutex);
#ifdef AGS_WITH_PULSE
pulse_port->sample_spec->rate = samplerate;
pulse_port->buffer_attr->fragsize = -1;
pulse_port->buffer_attr->maxlength = -1;
pulse_port->buffer_attr->minreq = fixed_size;
pulse_port->buffer_attr->tlength = fixed_size;
#endif
g_rec_mutex_unlock(pulse_port_mutex);
}
void
ags_pulse_port_set_buffer_size(AgsPulsePort *pulse_port,
guint buffer_size)
{
guint fixed_size;
GRecMutex *pulse_port_mutex;
fixed_size = ags_pulse_port_get_fixed_size(pulse_port);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* lock pulse port */
g_rec_mutex_lock(pulse_port_mutex);
#ifdef AGS_WITH_PULSE
pulse_port->buffer_attr->fragsize = -1;
pulse_port->buffer_attr->maxlength = -1;
pulse_port->buffer_attr->minreq = fixed_size;
pulse_port->buffer_attr->tlength = fixed_size;
#endif
pulse_port->buffer_size = buffer_size;
if(pulse_port->empty_buffer != NULL){
free(pulse_port->empty_buffer);
}
pulse_port->empty_buffer = ags_stream_alloc(pulse_port->pcm_channels * buffer_size,
pulse_port->format);
g_rec_mutex_unlock(pulse_port_mutex);
}
void
ags_pulse_port_set_pcm_channels(AgsPulsePort *pulse_port,
guint pcm_channels)
{
guint fixed_size;
GRecMutex *pulse_port_mutex;
fixed_size = ags_pulse_port_get_fixed_size(pulse_port);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* lock pulse port */
g_rec_mutex_lock(pulse_port_mutex);
pulse_port->pcm_channels = pcm_channels;
#ifdef AGS_WITH_PULSE
pulse_port->sample_spec->channels = pcm_channels;
pulse_port->buffer_attr->fragsize = -1;
pulse_port->buffer_attr->maxlength = -1;
pulse_port->buffer_attr->minreq = fixed_size;
pulse_port->buffer_attr->tlength = fixed_size;
#endif
if(pulse_port->empty_buffer != NULL){
free(pulse_port->empty_buffer);
}
pulse_port->empty_buffer = ags_stream_alloc(pcm_channels * pulse_port->buffer_size,
pulse_port->format);
g_rec_mutex_unlock(pulse_port_mutex);
}
void
ags_pulse_port_set_format(AgsPulsePort *pulse_port,
AgsSoundcardFormat format)
{
guint fixed_size;
GRecMutex *pulse_port_mutex;
fixed_size = ags_pulse_port_get_fixed_size(pulse_port);
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* lock pulse port */
g_rec_mutex_lock(pulse_port_mutex);
#ifdef AGS_WITH_PULSE
switch(format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
if(ags_endian_host_is_be()){
pulse_port->sample_spec->format = PA_SAMPLE_S16BE;
}else{
pulse_port->sample_spec->format = PA_SAMPLE_S16LE;
}
pulse_port->cache[0] = (void *) realloc(pulse_port->cache[0],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) realloc(pulse_port->cache[1],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) realloc(pulse_port->cache[2],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) realloc(pulse_port->cache[3],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
if(ags_endian_host_is_be()){
pulse_port->sample_spec->format = PA_SAMPLE_S24_32BE;
}else{
pulse_port->sample_spec->format = PA_SAMPLE_S24_32LE;
}
pulse_port->cache[0] = (void *) realloc(pulse_port->cache[0],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) realloc(pulse_port->cache[1],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) realloc(pulse_port->cache[2],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) realloc(pulse_port->cache[3],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
if(ags_endian_host_is_be()){
pulse_port->sample_spec->format = PA_SAMPLE_S32BE;
}else{
pulse_port->sample_spec->format = PA_SAMPLE_S32LE;
}
pulse_port->cache[0] = (void *) realloc(pulse_port->cache[0],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) realloc(pulse_port->cache[1],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) realloc(pulse_port->cache[2],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) realloc(pulse_port->cache[3],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
}
break;
default:
g_warning("pulse devout - unsupported format");
}
pulse_port->buffer_attr->fragsize = -1;
pulse_port->buffer_attr->maxlength = -1;
pulse_port->buffer_attr->minreq = fixed_size;
pulse_port->buffer_attr->tlength = fixed_size;
#endif
pulse_port->format = format;
if(pulse_port->empty_buffer != NULL){
free(pulse_port->empty_buffer);
}
pulse_port->empty_buffer = ags_stream_alloc(pulse_port->pcm_channels * pulse_port->buffer_size,
format);
g_rec_mutex_unlock(pulse_port_mutex);
}
void
ags_pulse_port_set_cache_buffer_size(AgsPulsePort *pulse_port,
guint cache_buffer_size)
{
GRecMutex *pulse_port_mutex;
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* lock pulse port */
g_rec_mutex_lock(pulse_port_mutex);
switch(pulse_port->format){
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
pulse_port->cache[0] = (void *) realloc(pulse_port->cache[0],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) realloc(pulse_port->cache[1],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) realloc(pulse_port->cache[2],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) realloc(pulse_port->cache[3],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
pulse_port->cache[0] = (void *) realloc(pulse_port->cache[0],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) realloc(pulse_port->cache[1],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) realloc(pulse_port->cache[2],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) realloc(pulse_port->cache[3],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
pulse_port->cache[0] = (void *) realloc(pulse_port->cache[0],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[1] = (void *) realloc(pulse_port->cache[1],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[2] = (void *) realloc(pulse_port->cache[2],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
pulse_port->cache[3] = (void *) realloc(pulse_port->cache[3],
pulse_port->pcm_channels * pulse_port->cache_buffer_size * sizeof(gint32));
}
break;
default:
g_warning("pulse devout - unsupported format");
}
g_rec_mutex_unlock(pulse_port_mutex);
}
/**
* ags_pulse_port_get_latency:
* @pulse_port: the #AgsPulsePort
*
* Gets latency.
*
* Since: 3.0.0
*/
guint
ags_pulse_port_get_latency(AgsPulsePort *pulse_port)
{
guint latency;
GRecMutex *pulse_port_mutex;
/* get pulse port mutex */
pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(pulse_port);
/* lock pulse port */
g_rec_mutex_lock(pulse_port_mutex);
latency = 0;
#ifdef AGS_WITH_PULSE
if(pulse_port->use_cache){
latency = (guint) floor((gdouble) G_TIME_SPAN_SECOND / (gdouble) pulse_port->sample_spec->rate * (gdouble) pulse_port->cache_buffer_size);
}else{
latency = (guint) floor((gdouble) G_TIME_SPAN_SECOND / (gdouble) pulse_port->sample_spec->rate * (gdouble) pulse_port->buffer_size);
}
#endif
g_rec_mutex_unlock(pulse_port_mutex);
return(latency);
}
/**
* ags_pulse_port_new:
* @pulse_client: the #AgsPulseClient assigned to
*
* Create a new instance of #AgsPulsePort.
*
* Returns: the new #AgsPulsePort
*
* Since: 3.0.0
*/
AgsPulsePort*
ags_pulse_port_new(GObject *pulse_client)
{
AgsPulsePort *pulse_port;
pulse_port = (AgsPulsePort *) g_object_new(AGS_TYPE_PULSE_PORT,
"pulse-client", pulse_client,
NULL);
return(pulse_port);
}