自学教程：C++ AGS_RECALL函数代码示例

voidags_feed_channel_init(AgsFeedChannel *feed_channel){  AGS_RECALL(feed_channel)->name = "ags-feed";  AGS_RECALL(feed_channel)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(feed_channel)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(feed_channel)->xml_type = "ags-feed-channel";}

voidags_play_channel_run_set_property(GObject *gobject,				  guint prop_id,				  const GValue *value,				  GParamSpec *param_spec){  AgsPlayChannelRun *play_channel_run;  play_channel_run = AGS_PLAY_CHANNEL_RUN(gobject);  switch(prop_id){  case PROP_STREAM_CHANNEL_RUN:    {      AgsStreamChannelRun *stream_channel_run;      gboolean is_template;      stream_channel_run = (AgsStreamChannelRun *) g_value_get_object(value);      if(stream_channel_run == play_channel_run->stream_channel_run)	return;      if(stream_channel_run != NULL &&	 (AGS_RECALL_TEMPLATE & (AGS_RECALL(stream_channel_run)->flags)) != 0){	is_template = TRUE;      }else{	is_template = FALSE;      }      if(play_channel_run->stream_channel_run != NULL){	if(is_template){	  ags_recall_remove_dependency(AGS_RECALL(play_channel_run),				       (AgsRecall *) play_channel_run->stream_channel_run);	}	g_object_unref(G_OBJECT(play_channel_run->stream_channel_run));      }      if(stream_channel_run != NULL){	g_object_ref(G_OBJECT(stream_channel_run));	if(is_template){	  ags_recall_add_dependency(AGS_RECALL(play_channel_run),				    ags_recall_dependency_new((GObject *) stream_channel_run));	}      }      play_channel_run->stream_channel_run = stream_channel_run;    }    break;  default:    G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);    break;  }}

voidags_play_notation_audio_run_init(AgsPlayNotationAudioRun *play_notation_audio_run){  AGS_RECALL(play_notation_audio_run)->name = "ags-play-notation/0";  AGS_RECALL(play_notation_audio_run)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(play_notation_audio_run)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(play_notation_audio_run)->xml_type = "ags-play-notation-audio-run/0";  AGS_RECALL(play_notation_audio_run)->port = NULL;  play_notation_audio_run->delay_audio_run = NULL;  play_notation_audio_run->count_beats_audio_run = NULL;}

voidags_stream_audio_signal_finalize(GObject *gobject){  if(AGS_RECALL_AUDIO_SIGNAL(gobject)->source != NULL &&     AGS_RECALL(gobject)->parent != NULL){    ags_recycling_remove_audio_signal(AGS_RECALL_RECYCLING(AGS_RECALL(gobject)->parent)->source,				      AGS_RECALL_AUDIO_SIGNAL(gobject)->source);  }  //  g_object_unref(AGS_RECALL_AUDIO_SIGNAL(gobject)->source);	  //  g_object_unref(AGS_RECALL_AUDIO_SIGNAL(gobject)->source);	  /* call parent */  G_OBJECT_CLASS(ags_stream_audio_signal_parent_class)->finalize(gobject); }

voidags_play_notation_audio_init(AgsPlayNotationAudio *play_notation_audio){  GList *port;  AGS_RECALL(play_notation_audio)->name = "ags-play-notation";  AGS_RECALL(play_notation_audio)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(play_notation_audio)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(play_notation_audio)->xml_type = "ags-play-notation-audio";  port = NULL;  /* set port */  AGS_RECALL(play_notation_audio)->port = port;}

voidags_play_wave_channel_run_get_property(GObject *gobject,				       guint prop_id,				       GValue *value,				       GParamSpec *param_spec){  AgsPlayWaveChannelRun *play_wave_channel_run;    pthread_mutex_t *recall_mutex;  play_wave_channel_run = AGS_PLAY_WAVE_CHANNEL_RUN(gobject);  /* get recall mutex */  pthread_mutex_lock(ags_recall_get_class_mutex());    recall_mutex = AGS_RECALL(gobject)->obj_mutex;  pthread_mutex_unlock(ags_recall_get_class_mutex());  switch(prop_id){  case PROP_X_OFFSET:    {      pthread_mutex_lock(recall_mutex);      g_value_set_uint64(value, play_wave_channel_run->x_offset);      pthread_mutex_unlock(recall_mutex);    }    break;  default:    G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);    break;  };}

gbooleanags_recall_audio_pack(AgsPackable *packable, GObject *container){  AgsRecallContainer *recall_container;  GList *list;  if(ags_recall_audio_parent_packable_interface->pack(packable, container))    return(TRUE);  recall_container = AGS_RECALL_CONTAINER(container);  g_object_set(G_OBJECT(recall_container),	       "recall_audio/0", AGS_RECALL(packable),	       NULL);  /* set in AgsRecallAudioRun */  list = recall_container->recall_audio_run;  while(list != NULL){    g_object_set(G_OBJECT(list->data),		 "recall_audio/0", AGS_RECALL_AUDIO(packable),		 NULL);    list = list->next;  }  return(FALSE);}

/** * ags_recall_set_flags: * @recall an #AgsRecall * @flags the flags mask * * Set flags recursivly. */voidags_recall_set_flags(AgsRecall *recall, guint flags){  GList *child;  guint inheritated_flags_mask;  /* set flags */  recall->flags |= flags;  /* set recursivly - prepare mask */  inheritated_flags_mask = (AGS_RECALL_PLAYBACK |			    AGS_RECALL_SEQUENCER |			    AGS_RECALL_NOTATION |			    AGS_RECALL_PROPAGATE_DONE |			    AGS_RECALL_INITIAL_RUN);  if(!AGS_IS_RECALL_RECYCLING(recall)){    inheritated_flags_mask |= (AGS_RECALL_PERSISTENT |			       AGS_RECALL_PERSISTENT_PLAYBACK |			       AGS_RECALL_PERSISTENT_SEQUENCER |			       AGS_RECALL_PERSISTENT_NOTATION);  }  /* apply recursivly */  child = recall->children;  while(child != NULL){    ags_recall_set_flags(AGS_RECALL(child->data), (inheritated_flags_mask & (flags)));    child = child->next;  }}

/** * ags_recall_is_done: * @recall an #AgsRecall * @recycling_container an #AgsRecyclingContainer * * Check if recall is over. */gbooleanags_recall_is_done(GList *recalls, GObject *recycling_container){  AgsRecall *recall;  if(recalls == NULL ||     !AGS_IS_RECYCLING_CONTAINER(recycling_container)){    return(FALSE);  }  while(recalls != NULL){    recall = AGS_RECALL(recalls->data);    if((AGS_RECALL_TEMPLATE & (recall->flags)) == 0 &&       !AGS_IS_RECALL_AUDIO(recall) &&       !AGS_IS_RECALL_CHANNEL(recall) &&       recall->recall_id != NULL &&       recall->recall_id->recycling_container == recycling_container){      if((AGS_RECALL_DONE & (recall->flags)) == 0){	g_message("%s/0", G_OBJECT_TYPE_NAME(recall));	return(FALSE);      }    }    recalls = recalls->next;  }  return(TRUE);}

voidags_recall_real_cancel(AgsRecall *recall){  GList *list;  if((AGS_RECALL_TEMPLATE & (recall->flags)) != 0){    return;  }  /* call cancel for children */  list = recall->children;  while(list != NULL){    ags_recall_cancel(AGS_RECALL(list->data));    list = list->next;  }  if((AGS_RECALL_PERSISTENT & (recall->flags)) != 0 ||     (AGS_RECALL_PERSISTENT_PLAYBACK & (recall->flags)) != 0){    ags_recall_stop_persistent(recall);  }else{    ags_recall_done(recall);  }}

voidags_recall_real_remove(AgsRecall *recall){  AgsRecall *parent;  ags_dynamic_connectable_disconnect_dynamic(AGS_DYNAMIC_CONNECTABLE(recall));  if(recall->parent == NULL){    parent = NULL;    g_object_unref(recall);    return;  }else{    parent = AGS_RECALL(recall->parent);    parent->children = g_list_remove(parent->children, recall);  }  if(parent != NULL &&     (AGS_RECALL_PROPAGATE_DONE & (parent->flags)) != 0 &&     parent->children == NULL){    ags_recall_done(parent);  }  g_object_unref(recall);}

voidags_recall_connect(AgsConnectable *connectable){  AgsRecall *recall;  AgsRecallHandler *recall_handler;  GList *list;  recall = AGS_RECALL(connectable);  list = recall->children;  while(list != NULL){    ags_connectable_connect(AGS_CONNECTABLE(list->data));    list = list->next;  }  /* handlers */  list = recall->handlers;  while(list != NULL){    recall_handler = AGS_RECALL_HANDLER(list->data);    recall_handler->handler = g_signal_connect(G_OBJECT(recall), recall_handler->signal_name,					       G_CALLBACK(recall_handler->callback), recall_handler->data);    list = list->next;  }  recall->flags |= AGS_RECALL_CONNECTED;}

voidags_recall_disconnect_dynamic(AgsDynamicConnectable *dynamic_connectable){  AgsRecall *recall;  AgsRecallHandler *recall_handler;  GList *list;  recall = AGS_RECALL(dynamic_connectable);  /* disconnect children */  list = recall->children;  while(list != NULL){    ags_dynamic_connectable_disconnect_dynamic(AGS_DYNAMIC_CONNECTABLE(list->data));    list = list->next;  }  /* disconnect handlers */  list = recall->handlers;  while(list != NULL){    recall_handler = AGS_RECALL_HANDLER(list->data);    g_signal_handler_disconnect(G_OBJECT(recall), recall_handler->handler);    list = list->next;  }  recall->flags &= (~AGS_RECALL_RUN_INITIALIZED);}

voidags_recall_connect_dynamic(AgsDynamicConnectable *dynamic_connectable){  AgsRecall *recall;  AgsRecallHandler *recall_handler;  GList *list;  recall = AGS_RECALL(dynamic_connectable);  /* connect children */  list = recall->children;  while(list != NULL){    ags_dynamic_connectable_connect_dynamic(AGS_DYNAMIC_CONNECTABLE(list->data));    list = list->next;  }  /* connect handlers */  list = recall->handlers;  while(list != NULL){    recall_handler = AGS_RECALL_HANDLER(list->data);    recall_handler->handler = g_signal_connect_after(G_OBJECT(recall), recall_handler->signal_name,						     G_CALLBACK(recall_handler->callback), recall_handler->data);    list = list->next;  }  recall->flags |= AGS_RECALL_RUN_INITIALIZED;}

xmlNode*ags_recall_write(AgsFile *file, xmlNode *parent, AgsPlugin *plugin){  xmlNode *node;  gchar *id;  id = ags_id_generator_create_uuid();  node = xmlNewNode(NULL,		    AGS_RECALL(plugin)->xml_type);  xmlNewProp(node,	     AGS_FILE_ID_PROP,	     id);  ags_file_add_id_ref(file,		      g_object_new(AGS_TYPE_FILE_ID_REF,				   "main/0", file->ags_main,				   "node/0", node,				   "xpath/0", g_strdup_printf("xpath=//*[@id='%s']/0", id),				   "reference/0", G_OBJECT(plugin),				   NULL));  xmlAddChild(parent,	      node);  return(node);}

/** * ags_recall_find_recycling_container: * @recall_i a #GList containing recalls * @type a #GType * @recycling_container an #AgsRecyclingContainer * Returns: a #GList containing recalls, or #NULL if not found *  * Finds next matching recall which has @recycling_container, see #AgsRecallId for further * details about #AgsRecyclingContainer. Intended to be used as iteration function. */GList*ags_recall_find_recycling_container(GList *recall_i, GObject *recycling_container){  AgsRecall *recall;#ifdef AGS_DEBUG  g_message("ags_recall_find_recycling_container: recycling_container = %llx/n/0", recycling_container);#endif  while(recall_i != NULL){    recall = AGS_RECALL(recall_i->data);    if(recall->recall_id != NULL)#ifdef AGS_DEBUG      g_message("ags_recall_find_recycling_container: recall_id->recycling_contianer = %llx/n/0", (long long unsigned int) recall->recall_id->recycling_container);#endif    if(recall->recall_id != NULL &&       recall->recall_id->recycling_container == recycling_container){	return(recall_i);    }    recall_i = recall_i->next;  }  return(NULL);}

voidags_play_channel_run_run_post(AgsRecall *recall){  AgsStreamChannelRun *stream_channel_run;  AgsChannel *source;  GList *list;  GList *recall_recycling_list, *recall_audio_signal_list;  gboolean found;  AGS_RECALL_CLASS(ags_play_channel_run_parent_class)->run_post(recall);  if((AGS_PLAY_CHANNEL_RUN_INITIAL_RUN & (AGS_PLAY_CHANNEL_RUN(recall)->flags)) == 0){    return;  }  AGS_PLAY_CHANNEL_RUN(recall)->flags &= (~AGS_PLAY_CHANNEL_RUN_INITIAL_RUN);  /* connect done */  source = AGS_RECALL_CHANNEL_RUN(recall)->source;  found = FALSE;  list = ags_recall_find_type_with_recycling_container(source->play,						       AGS_TYPE_STREAM_CHANNEL_RUN,						       recall->recall_id->recycling_container);  stream_channel_run = AGS_STREAM_CHANNEL_RUN(list->data);    recall_recycling_list = AGS_RECALL(stream_channel_run)->children;  while(recall_recycling_list != NULL){    recall_audio_signal_list = AGS_RECALL(recall_recycling_list->data)->children;          while(recall_audio_signal_list != NULL){      found = TRUE;      g_signal_connect_after(G_OBJECT(recall_audio_signal_list->data), "done/0",			     G_CALLBACK(ags_play_channel_run_stream_audio_signal_done_callback), recall);      recall_audio_signal_list = recall_audio_signal_list->next;    }    recall_recycling_list = recall_recycling_list->next;  }  if(!found){    ags_play_channel_run_stop(recall);  }}

voidags_recall_real_run_inter(AgsRecall *recall){  GList *list;  list = recall->children;  while(list != NULL){    if((AGS_RECALL_TEMPLATE & (AGS_RECALL(list->data)->flags)) != 0){      g_warning("running on template/0");    }    ags_recall_run_inter(AGS_RECALL(list->data));    list = list->next;  }}

xmlNode*ags_play_dssi_audio_write(AgsFile *file, xmlNode *parent, AgsPlugin *plugin){  AgsPlayDssiAudio *play_dssi_audio;  xmlNode *node;  gchar *id;  play_dssi_audio = AGS_PLAY_DSSI_AUDIO(plugin);  id = ags_id_generator_create_uuid();    node = xmlNewNode(NULL,		    "ags-recall-dssi");  xmlNewProp(node,	     AGS_FILE_ID_PROP,	     id);  ags_file_add_id_ref(file,		      g_object_new(AGS_TYPE_FILE_ID_REF,				   "application-context", file->application_context,				   "file", file,				   "node", node,				   "xpath", g_strdup_printf("xpath=//*[@id='%s']", id),				   "reference", play_dssi_audio,				   NULL));  xmlNewProp(node,	     "filename",	     g_strdup(AGS_RECALL(play_dssi_audio)->filename));  xmlNewProp(node,	     "effect",	     g_strdup(AGS_RECALL(play_dssi_audio)->effect));  xmlNewProp(node,	     "index",	     g_strdup_printf("%u", AGS_RECALL(play_dssi_audio)->effect_index));  xmlAddChild(parent,	      node);  return(node);}

voidags_drum_sequencer_count_callback(AgsDelayAudioRun *delay_audio_run,				  guint nth_run,				  guint delay, guint attack,				  AgsDrum *drum){  AgsWindow *window;  AgsAudio *audio;  AgsCountBeatsAudio *play_count_beats_audio;  AgsCountBeatsAudioRun *play_count_beats_audio_run;  AgsToggleLed *toggle_led;  GList *list;  guint counter, active_led;  gdouble active_led_old, active_led_new;  GValue value = {0,};    window = AGS_WINDOW(gtk_widget_get_ancestor((GtkWidget *) drum, AGS_TYPE_WINDOW));  audio = AGS_MACHINE(drum)->audio;  /* get some recalls */  list = ags_recall_find_type(audio->play,			      AGS_TYPE_COUNT_BEATS_AUDIO);    if(list != NULL){    play_count_beats_audio = AGS_COUNT_BEATS_AUDIO(list->data);  }  list = ags_recall_find_type_with_recycling_container(audio->play,						       AGS_TYPE_COUNT_BEATS_AUDIO_RUN,						       (GObject *) AGS_RECALL(delay_audio_run)->recall_id->recycling_container);    if(list != NULL){    play_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);  }  /* set optical feedback */  active_led_new = (guint) play_count_beats_audio_run->sequencer_counter % AGS_DRUM_PATTERN_CONTROLS;  drum->active_led = (guint) active_led_new;  if(play_count_beats_audio_run->sequencer_counter == 0){    g_value_init(&value, G_TYPE_DOUBLE);    ags_port_safe_read(play_count_beats_audio->sequencer_loop_end,		       &value);    active_led_old = (guint) (g_value_get_double(&value) - 1.0) % AGS_DRUM_PATTERN_CONTROLS;  }else{    active_led_old = (guint) (drum->active_led - 1.0) % AGS_DRUM_PATTERN_CONTROLS;  }  toggle_led = ags_toggle_led_new(gtk_container_get_children(GTK_CONTAINER(drum->led)),				  (guint) active_led_new,				  (guint) active_led_old);  ags_task_thread_append_task(AGS_TASK_THREAD(AGS_AUDIO_LOOP(AGS_MAIN(window->ags_main)->main_loop)->task_thread),			      AGS_TASK(toggle_led));}

/** * ags_recall_set_recall_id: * @recall an #AgsRecall * @recall_id the #AgsRecallID to set * * Sets the recall id recursively. */voidags_recall_set_recall_id(AgsRecall *recall, AgsRecallID *recall_id){  GList *list;  list = recall->children;  while(list != NULL){    if((AGS_RECALL_TEMPLATE & (AGS_RECALL(list->data)->flags)) != 0){      g_warning("running on template/0");    }    ags_recall_set_recall_id(AGS_RECALL(list->data), recall_id);    list = list->next;  }  recall->recall_id = recall_id;}

voidags_count_beats_audio_run_init(AgsCountBeatsAudioRun *count_beats_audio_run){  AGS_RECALL(count_beats_audio_run)->name = "ags-count-beats/0";  AGS_RECALL(count_beats_audio_run)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(count_beats_audio_run)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(count_beats_audio_run)->xml_type = "ags-count-beats-audio-run/0";  AGS_RECALL(count_beats_audio_run)->port = NULL;  count_beats_audio_run->notation_counter = 0;  count_beats_audio_run->sequencer_counter = 0;  count_beats_audio_run->recall_ref = 0;  count_beats_audio_run->hide_ref = 0;  count_beats_audio_run->notation_hide_ref_counter = 0;  count_beats_audio_run->sequencer_hide_ref_counter = 0;  count_beats_audio_run->delay_audio_run = NULL;}

voidags_recall_ladspa_init(AgsRecallLadspa *recall_ladspa){  AGS_RECALL(recall_ladspa)->name = "ags-ladspa/0";  AGS_RECALL(recall_ladspa)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(recall_ladspa)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(recall_ladspa)->xml_type = "ags-recall-ladspa/0";  AGS_RECALL(recall_ladspa)->port = NULL;  recall_ladspa->filename = NULL;  recall_ladspa->effect = NULL;  recall_ladspa->effect_index = 0;  recall_ladspa->plugin_descriptor = NULL;  recall_ladspa->input_port = NULL;  recall_ladspa->input_lines = 0;  recall_ladspa->output_port = NULL;  recall_ladspa->output_lines = 0;}

voidags_recall_dssi_init(AgsRecallDssi *recall_dssi){  AGS_RECALL(recall_dssi)->name = "ags-dssi";  AGS_RECALL(recall_dssi)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(recall_dssi)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(recall_dssi)->xml_type = "ags-recall-dssi";  AGS_RECALL(recall_dssi)->port = NULL;    recall_dssi->bank = 0;  recall_dssi->program = 0;  recall_dssi->plugin = NULL;  recall_dssi->plugin_descriptor = NULL;  recall_dssi->input_port = NULL;  recall_dssi->input_lines = 0;  recall_dssi->output_port = NULL;  recall_dssi->output_lines = 0;}

voidags_recall_dssi_get_property(GObject *gobject,			     guint prop_id,			     GValue *value,			     GParamSpec *param_spec){  AgsRecallDssi *recall_dssi;  pthread_mutex_t *recall_mutex;  recall_dssi = AGS_RECALL_DSSI(gobject);  /* get recall mutex */  pthread_mutex_lock(ags_recall_get_class_mutex());    recall_mutex = AGS_RECALL(gobject)->obj_mutex;    pthread_mutex_unlock(ags_recall_get_class_mutex());  switch(prop_id){  case PROP_PLUGIN:    {      pthread_mutex_lock(recall_mutex);      g_value_set_object(value, recall_dssi->plugin);            pthread_mutex_unlock(recall_mutex);	    }    break;  case PROP_BANK:    {      pthread_mutex_lock(recall_mutex);            g_value_set_uint(value, recall_dssi->bank);      pthread_mutex_unlock(recall_mutex);    }    break;  case PROP_PROGRAM:    {      pthread_mutex_lock(recall_mutex);            g_value_set_uint(value, recall_dssi->program);      pthread_mutex_unlock(recall_mutex);    }    break;  default:    G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);    break;  }}

xmlNode*ags_play_notation_audio_run_write(AgsFile *file, xmlNode *parent, AgsPlugin *plugin){  AgsFileLookup *file_lookup;  xmlNode *node, *child;  xmlNode *dependency_node;  GList *list;  gchar *id;  /* write parent */  node = ags_play_notation_audio_run_parent_plugin_interface->write(file, parent, plugin);  /* write dependencies */  child = xmlNewNode(NULL,		     "ags-dependency-list/0");  xmlNewProp(child,	     AGS_FILE_ID_PROP,	     ags_id_generator_create_uuid());  xmlAddChild(node,	      child);  list = AGS_RECALL(plugin)->dependencies;  while(list != NULL){    id = ags_id_generator_create_uuid();    dependency_node = xmlNewNode(NULL,				 "ags-dependency/0");    xmlNewProp(dependency_node,	       AGS_FILE_ID_PROP,	       id);    xmlAddChild(child,		dependency_node);    file_lookup = (AgsFileLookup *) g_object_new(AGS_TYPE_FILE_LOOKUP,						 "file/0", file,						 "node/0", dependency_node,						 "reference/0", list->data,						 NULL);    ags_file_add_lookup(file, (GObject *) file_lookup);    g_signal_connect(G_OBJECT(file_lookup), "resolve/0",		     G_CALLBACK(ags_play_notation_audio_run_write_resolve_dependency), G_OBJECT(plugin));    list = list->next;  }  return(node);}

voidags_play_dssi_audio_init(AgsPlayDssiAudio *play_dssi_audio){  GList *port;  AGS_RECALL(play_dssi_audio)->name = "ags-play-dssi";  AGS_RECALL(play_dssi_audio)->version = AGS_RECALL_DEFAULT_VERSION;  AGS_RECALL(play_dssi_audio)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;  AGS_RECALL(play_dssi_audio)->xml_type = "ags-play-dssi-audio";  play_dssi_audio->bank = 0;  play_dssi_audio->program = 0;    play_dssi_audio->plugin = NULL;  play_dssi_audio->plugin_descriptor = NULL;  play_dssi_audio->input_port = NULL;  play_dssi_audio->input_lines = 0;  play_dssi_audio->output_port = NULL;  play_dssi_audio->output_lines = 0;}

gbooleanags_recall_is_connected(AgsConnectable *connectable){  AgsRecall *recall;  recall = AGS_RECALL(connectable);  if((AGS_RECALL_CONNECTED & (recall->flags)) != 0){    return(TRUE);  }else{    return(FALSE);  }}

voidags_buffer_channel_run_init(AgsBufferChannelRun *buffer_channel_run){  AGS_RECALL(buffer_channel_run)->name = "ags-buffer/0";  AGS_RECALL(buffer_channel_run)->version = AGS_EFFECTS_DEFAULT_VERSION;  AGS_RECALL(buffer_channel_run)->build_id = AGS_BUILD_ID;  AGS_RECALL(buffer_channel_run)->xml_type = "ags-buffer-channel-run/0";  AGS_RECALL(buffer_channel_run)->port = NULL;  AGS_RECALL(buffer_channel_run)->flags |= AGS_RECALL_INPUT_ORIENTATED;  AGS_RECALL(buffer_channel_run)->child_type = AGS_TYPE_BUFFER_RECYCLING;}

/** * ags_play_dssi_audio_find: * @recall: a #GList-struct containing #AgsRecall * @filename: plugin's filename * @effect: plugin's effect * * Find DSSI recall. * * Returns: Next matching #GList-struct, or %NULL if not found *  * Since: 2.0.0 */GList*ags_play_dssi_audio_find(GList *recall,			 gchar *filename, gchar *effect){  while(recall != NULL){    if(AGS_IS_PLAY_DSSI_AUDIO(recall->data)){      gboolean success;            pthread_mutex_t *recall_mutex;      /* get recall mutex */      pthread_mutex_lock(ags_recall_get_class_mutex());        recall_mutex = AGS_RECALL(recall->data)->obj_mutex;        pthread_mutex_unlock(ags_recall_get_class_mutex());      /* check current filename and effect */      pthread_mutex_lock(recall_mutex);      success = (!g_strcmp0(AGS_RECALL(recall->data)->filename,			    filename) &&		 !g_strcmp0(AGS_RECALL(recall->data)->effect,			    effect)) ? TRUE: FALSE;            pthread_mutex_unlock(recall_mutex);      if(success){	break;      }    }    /* iterate */    recall = recall->next;  }  return(recall);}