gboolean
ags_recall_channel_pack(AgsPackable *packable, GObject *container)
{
AgsRecallContainer *recall_container;
AgsRecallChannel *recall_channel;
GList *list;
if(ags_recall_channel_parent_packable_interface->pack(packable, container))
return(TRUE);
recall_container = AGS_RECALL_CONTAINER(container);
recall_channel = AGS_RECALL_CHANNEL(packable);
g_object_set(container,
"recall_channel\0", recall_channel,
NULL);
/* set in AgsRecallChannelRun */
list = recall_container->recall_channel_run;
while((list = ags_recall_find_provider(list, G_OBJECT(recall_channel->source))) != NULL){
g_object_set(G_OBJECT(list->data),
"recall_channel\0", recall_channel,
NULL);
list = list->next;
}
return(FALSE);
}
void
ags_recall_channel_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsRecallChannel *recall_channel;
recall_channel = AGS_RECALL_CHANNEL(gobject);
switch(prop_id){
case PROP_DESTINATION:
{
AgsChannel *destination;
destination = (AgsChannel *) g_value_get_object(value);
if(recall_channel->destination == destination)
return;
if(recall_channel->destination != NULL)
g_object_unref(recall_channel->destination);
if(destination != NULL)
g_object_ref(destination);
recall_channel->destination = destination;
}
break;
case PROP_SOURCE:
{
AgsChannel *source;
source = (AgsChannel *) g_value_get_object(value);
if(recall_channel->source == source)
return;
if(recall_channel->source != NULL)
g_object_unref(recall_channel->source);
if(source != NULL)
g_object_ref(source);
recall_channel->source = source;
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
/**
* ags_recall_find_type:
* @recall_i a #GList containing recalls
* @provider a #GObject
* Returns: a #GList containing recalls, or #NULL if not found
*
* Finds next matching recall for type which has @provider. The @provider may be either an #AgsChannel
* or an #AgsAudio object. This function tries to find the corresponding #AgsRecallChannel and #AgsRecallAudio
* objects of a #AgsRecall to find. If these recalls contains the @provider, the function will return.
*/
GList*
ags_recall_find_provider(GList *recall_i, GObject *provider)
{
AgsRecall *recall;
while(recall_i != NULL){
recall = AGS_RECALL(recall_i->data);
if(AGS_IS_AUDIO(provider)){
if(AGS_IS_RECALL_AUDIO(recall)){
if(((GObject *) AGS_RECALL_AUDIO(recall)->audio) == provider)
return(recall_i);
}else if(AGS_IS_RECALL_AUDIO_RUN(recall)){
AgsRecallAudio *recall_audio;
recall_audio = AGS_RECALL_AUDIO_RUN(recall)->recall_audio;
if(recall_audio != NULL &&
((GObject *) recall_audio->audio) == provider){
return(recall_i);
}
}
}else if(AGS_IS_CHANNEL(provider)){
if(AGS_IS_RECALL_CHANNEL(recall)){
if(((GObject *) AGS_RECALL_CHANNEL(recall)->source) == provider)
return(recall_i);
}else if(AGS_IS_RECALL_CHANNEL_RUN(recall)){
if(((GObject *) AGS_RECALL_CHANNEL_RUN(recall)->source) == provider){
return(recall_i);
}
}
}else if(AGS_IS_RECYCLING(provider)){
if(AGS_IS_RECALL_RECYCLING(recall)){
if(((GObject *) AGS_RECALL_RECYCLING(recall)->source) == provider){
return(recall_i);
}
}
}else if(AGS_IS_AUDIO_SIGNAL(provider)){
if(AGS_IS_RECALL_AUDIO_SIGNAL(recall)){
if(((GObject *) AGS_RECALL_AUDIO_SIGNAL(recall)->source) == provider){
return(recall_i);
}
}
}
recall_i = recall_i->next;
}
return(NULL);
}
AgsRecall*
ags_recall_channel_duplicate(AgsRecall *recall,
AgsRecallID *recall_id,
guint *n_params, GParameter *parameter)
{
AgsRecallChannel *recall_channel, *copy;
recall_channel = AGS_RECALL_CHANNEL(recall);
parameter = ags_parameter_grow(G_OBJECT_TYPE(recall),
parameter, n_params,
"source\0", recall_channel->source,
"destination\0", recall_channel->destination,
NULL);
copy = AGS_RECALL_CHANNEL(AGS_RECALL_CLASS(ags_recall_channel_parent_class)->duplicate(recall,
recall_id,
n_params, parameter));
g_message("ags warning - ags_recall_channel_duplicate: you shouldn't do this %s\n\0", G_OBJECT_TYPE_NAME(recall));
return((AgsRecall *) copy);
}
gboolean
ags_recall_channel_unpack(AgsPackable *packable)
{
AgsRecall *recall;
AgsRecallContainer *recall_container;
GList *list;
recall = AGS_RECALL(packable);
if(recall == NULL)
return(TRUE);
recall_container = AGS_RECALL_CONTAINER(recall->container);
if(recall_container == NULL)
return(TRUE);
/* ref */
g_object_ref(recall);
g_object_ref(recall_container);
/* unset in AgsRecallChannelRun */
list = recall_container->recall_channel_run;
while((list = ags_recall_find_provider(list, G_OBJECT(AGS_RECALL_CHANNEL(packable)->source))) != NULL){
g_object_set(G_OBJECT(list->data),
"recall_channel\0", NULL,
NULL);
list = list->next;
}
/* call parent */
if(ags_recall_channel_parent_packable_interface->unpack(packable)){
g_object_unref(recall);
g_object_unref(recall_container);
return(TRUE);
}
/* remove from list */
recall_container->recall_channel = g_list_remove(recall_container->recall_channel,
recall);
/* unref */
g_object_unref(recall);
g_object_unref(recall_container);
return(FALSE);
}
GList*
ags_copy_pattern_channel_template_find_source_and_destination(GList *recall,
AgsChannel *destination,
AgsChannel *source)
{
AgsCopyPatternChannel *copy_pattern_channel;
while(recall != NULL){
recall = ags_recall_template_find_type(recall, AGS_TYPE_COPY_PATTERN_CHANNEL);
if(recall == NULL)
break;
copy_pattern_channel = AGS_COPY_PATTERN_CHANNEL(recall->data);
if(AGS_RECALL_CHANNEL(copy_pattern_channel)->destination == destination &&
AGS_RECALL_CHANNEL(copy_pattern_channel)->source == source)
break;
recall = recall->next;
}
return(recall);
}
void
ags_recall_channel_finalize(GObject *gobject)
{
AgsRecallChannel *recall_channel;
recall_channel = AGS_RECALL_CHANNEL(gobject);
if(recall_channel->source != NULL)
g_object_unref(recall_channel->source);
if(recall_channel->destination != NULL)
g_object_unref(G_OBJECT(recall_channel->destination));
G_OBJECT_CLASS(ags_recall_channel_parent_class)->finalize(gobject);
}
GList*
ags_recall_channel_find_channel(GList *recall_channel_i, AgsChannel *source)
{
AgsRecallChannel *recall_channel;
while(recall_channel_i != NULL){
recall_channel = AGS_RECALL_CHANNEL(recall_channel_i->data);
if(recall_channel->source == source)
return(recall_channel_i);
recall_channel_i = recall_channel_i->next;
}
return(NULL);
}
void
ags_recall_channel_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsRecallChannel *recall_channel;
recall_channel = AGS_RECALL_CHANNEL(gobject);
switch(prop_id){
case PROP_DESTINATION:
g_value_set_object(value, recall_channel->destination);
break;
case PROP_SOURCE:
g_value_set_object(value, recall_channel->source);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_stream_audio_signal_run_post(AgsRecall *recall)
{
AgsAudioSignal *source;
AgsStreamChannel *stream_channel;
AgsStreamChannelRun *stream_channel_run;
AgsStreamRecycling *stream_recycling;
AgsStreamAudioSignal *stream_audio_signal;
void (*parent_class_run_post)(AgsRecall *recall);
stream_audio_signal = (AgsStreamAudioSignal *) recall;
/* get parent class */
pthread_mutex_lock(ags_recall_get_class_mutex());
parent_class_run_post = AGS_RECALL_CLASS(ags_stream_audio_signal_parent_class)->run_post;
pthread_mutex_unlock(ags_recall_get_class_mutex());
g_object_get(stream_audio_signal,
"parent", &stream_recycling,
"source", &source,
NULL);
g_object_get(stream_recycling,
"parent", &stream_channel_run,
NULL);
g_object_get(stream_channel_run,
"recall-channel", &stream_channel,
NULL);
#ifdef AGS_DEBUG
g_message("stream[%d] %x %d: %d", AGS_RECALL_CHANNEL(stream_channel)->source->line, source, g_list_length(source->stream), g_list_length(source->stream_current));
#endif
if(source->stream_current != NULL){
if(source->stream_current->next == NULL){
AgsPort *port;
gboolean auto_sense;
GValue value = {0,};
g_object_get(stream_channel,
"auto-sense", &port,
NULL);
g_value_init(&value,
G_TYPE_BOOLEAN);
ags_port_safe_read(port,
&value);
auto_sense = g_value_get_boolean(&value);
g_value_unset(&value);
g_object_unref(port);
if(auto_sense){
void *buffer;
guint buffer_size;
guint format;
guint i;
gboolean add_stream;
buffer = source->stream_current->data;
g_object_get(source,
"buffer-size", &buffer_size,
"format", &format,
NULL);
add_stream = FALSE;
for(i = buffer_size - 1; i > buffer_size / 2 && !add_stream; i--){
switch(format){
case AGS_SOUNDCARD_SIGNED_8_BIT:
{
if(((gint8 *) buffer)[i] != 0){
add_stream = TRUE;
}
}
break;
case AGS_SOUNDCARD_SIGNED_16_BIT:
{
if(((gint16 *) buffer)[i] != 0){
add_stream = TRUE;
}
}
break;
case AGS_SOUNDCARD_SIGNED_24_BIT:
{
if(((gint32 *) buffer)[i] != 0){
add_stream = TRUE;
}
}
break;
case AGS_SOUNDCARD_SIGNED_32_BIT:
{
if(((gint32 *) buffer)[i] != 0){
add_stream = TRUE;
}
}
break;
case AGS_SOUNDCARD_SIGNED_64_BIT:
{
if(((gint64 *) buffer)[i] != 0){
add_stream = TRUE;
}
}
break;
case AGS_SOUNDCARD_FLOAT:
{
if(((gfloat *) buffer)[i] != 0.0){
add_stream = TRUE;
}
}
break;
case AGS_SOUNDCARD_DOUBLE:
{
if(((gdouble *) buffer)[i] != 0.0){
add_stream = TRUE;
}
}
break;
default:
g_critical("unsupported soundcard format");
}
}
if(add_stream){
ags_audio_signal_add_stream(source);
}
}
g_value_unset(&value);
}
source->stream_current = source->stream_current->next;
/* call parent */
parent_class_run_post(recall);
}else{
/* call parent */
parent_class_run_post(recall);
ags_recall_done(recall);
}
g_object_unref(stream_recycling);
g_object_unref(source);
g_object_unref(stream_channel_run);
g_object_unref(stream_channel);
}