/** * ags_output_find_last_input_recycling: * @output: an #AgsOutput * * Retrieve last input recycling. * * Returns: the last #AgsRecycling of #AgsAudio * * Since: 0.4 */ AgsRecycling* ags_output_find_last_input_recycling(AgsOutput *output) { AgsAudio *audio; AgsChannel *input; if(output == NULL) return(NULL); audio = AGS_AUDIO(AGS_CHANNEL(output)->audio); if((AGS_AUDIO_ASYNC & (audio->flags)) != 0){ input = ags_channel_nth(audio->input, AGS_CHANNEL(output)->audio_channel); input = ags_channel_last_with_recycling(input); }else{ input = ags_channel_nth(audio->input, AGS_CHANNEL(output)->line); } if(input != NULL){ return(input->last_recycling); }else{ return(NULL); } }
/** * ags_recall_ladspa_new: * @source: the source * @filename: the LADSPA plugin filename * @effect: effect's name * @effect_index: effect's index * * Creates a #AgsRecallLadspa * * Returns: a new #AgsRecallLadspa * * Since: 0.4.2 */ AgsRecallLadspa* ags_recall_ladspa_new(AgsChannel *source, gchar *filename, gchar *effect, unsigned long effect_index) { GObject *soundcard; AgsRecallLadspa *recall_ladspa; if(source != NULL){ soundcard = AGS_AUDIO(source->audio)->soundcard; }else{ soundcard = NULL; } recall_ladspa = (AgsRecallLadspa *) g_object_new(AGS_TYPE_RECALL_LADSPA, "soundcard\0", soundcard, "source\0", source, "filename\0", filename, "effect\0", effect, "index\0", effect_index, NULL); return(recall_ladspa); }
void ags_link_editor_reset(AgsApplicable *applicable) { AgsLinkEditor *link_editor; GtkTreeModel *model; GtkTreeIter iter; link_editor = AGS_LINK_EDITOR(applicable); model = gtk_combo_box_get_model(link_editor->combo); if(gtk_tree_model_get_iter_first(model, &iter)){ AgsMachine *machine, *link; AgsLineEditor *line_editor; AgsChannel *channel; gint i; gboolean found; line_editor = AGS_LINE_EDITOR(gtk_widget_get_ancestor(GTK_WIDGET(link_editor), AGS_TYPE_LINE_EDITOR)); channel = line_editor->channel; if(channel->link != NULL) machine = AGS_MACHINE(AGS_AUDIO(channel->link->audio)->machine_widget); else machine = NULL; i = 0; found = FALSE; do{ gtk_tree_model_get(model, &iter, 1, &link, -1); if(machine == link){ found = TRUE; break; } i++; }while(gtk_tree_model_iter_next(model, &iter)); if(found){ gtk_combo_box_set_active(link_editor->combo, i); if(channel->link == NULL) gtk_spin_button_set_value(link_editor->spin_button, 0); else gtk_spin_button_set_value(link_editor->spin_button, channel->link->line); }else gtk_combo_box_set_active(link_editor->combo, -1); } }
int ags_pad_mute_clicked_callback(GtkWidget *widget, AgsPad *pad) { AgsMachine *machine; GtkContainer *container; AgsTaskThread *task_thread; AgsChannel *current; AgsSetMuted *set_muted; GList *list, *tasks; task_thread = AGS_TASK_THREAD(AGS_AUDIO_LOOP(AGS_MAIN(AGS_DEVOUT(AGS_AUDIO(pad->channel->audio)->devout)->ags_main)->main_loop)->task_thread); current = pad->channel; tasks = NULL; if(gtk_toggle_button_get_active(pad->mute)){ if(gtk_toggle_button_get_active(pad->solo)) gtk_toggle_button_set_active(pad->solo, FALSE); /* mute */ while(current != pad->channel->next_pad){ set_muted = ags_set_muted_new(G_OBJECT(current), TRUE); tasks = g_list_prepend(tasks, set_muted); current = current->next; } }else{ machine = (AgsMachine *) gtk_widget_get_ancestor((GtkWidget *) pad, AGS_TYPE_MACHINE); if((AGS_MACHINE_SOLO & (machine->flags)) != 0){ container = (GtkContainer *) (AGS_IS_OUTPUT(pad->channel) ? machine->output: machine->input); list = gtk_container_get_children(container); while(!gtk_toggle_button_get_active(AGS_PAD(list->data)->solo)) list = list->next; gtk_toggle_button_set_active(AGS_PAD(list->data)->solo, FALSE); machine->flags &= ~(AGS_MACHINE_SOLO); } /* unmute */ while(current != pad->channel->next_pad){ set_muted = ags_set_muted_new(G_OBJECT(current), FALSE); tasks = g_list_prepend(tasks, set_muted); current = current->next; } } ags_task_thread_append_tasks(task_thread, tasks); return(0); }
void ags_drum_output_line_add_default_recall(AgsDrumOutputLine *drum_output_line) { AgsDrum *drum; AgsLine *line; AgsAudio *audio; AgsChannel *output; AgsDelayAudio *recall_delay_audio; AgsCountBeatsAudioRun *recall_count_beats_audio_run; GList *list; printf("ags_drum_output_line_map_recall\n\0"); line = AGS_LINE(drum_output_line); line->flags |= AGS_LINE_MAPPED_RECALL; output = AGS_LINE(drum_output_line)->channel; audio = AGS_AUDIO(output->audio); drum = AGS_DRUM(audio->machine); /* get some recalls */ list = ags_recall_find_type(audio->play, AGS_TYPE_DELAY_AUDIO); if(list != NULL){ recall_delay_audio = AGS_DELAY_AUDIO(list->data); }else{ recall_delay_audio = NULL; } list = ags_recall_find_type(audio->play, AGS_TYPE_COUNT_BEATS_AUDIO_RUN); if(list != NULL){ recall_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data); }else{ recall_count_beats_audio_run = NULL; } /* ags-stream */ ags_recall_factory_create(audio, NULL, NULL, "ags-stream\0", output->audio_channel, output->audio_channel + 1, output->pad, output->pad + 1, (AGS_RECALL_FACTORY_OUTPUT | AGS_RECALL_FACTORY_PLAY | AGS_RECALL_FACTORY_RECALL | AGS_RECALL_FACTORY_ADD), 0); }
void ags_mixer_set_pads(AgsAudio *audio, GType type, guint pads, guint pads_old, gpointer data) { AgsMixer *mixer; AgsChannel *channel; GList *list, *list_next; guint i, j; mixer = (AgsMixer *) audio->machine; if(type == AGS_TYPE_INPUT){ AgsMixerInputPad *mixer_input_pad; if(pads_old < pads){ channel = ags_channel_nth(audio->input, pads_old * audio->audio_channels); for(i = pads_old; i < pads; i++){ mixer_input_pad = ags_mixer_input_pad_new(channel); gtk_box_pack_start((GtkBox *) mixer->input_pad, (GtkWidget *) mixer_input_pad, FALSE, FALSE, 0); ags_pad_resize_lines((AgsPad *) mixer_input_pad, AGS_TYPE_MIXER_INPUT_LINE, AGS_AUDIO(channel->audio)->audio_channels, 0); if(GTK_WIDGET_VISIBLE((GtkWidget *) mixer)){ ags_connectable_connect(AGS_CONNECTABLE(mixer_input_pad)); ags_pad_find_port(AGS_PAD(mixer_input_pad)); gtk_widget_show_all((GtkWidget *) mixer_input_pad); } channel = channel->next_pad; } }else{ /* destroy AgsPad's */ list = gtk_container_get_children((GtkContainer *) mixer->input_pad); list = g_list_nth(list, pads); while(list != NULL){ list_next = list->next; gtk_widget_destroy((GtkWidget *) list->data); list = list_next; } } } }
void ags_apply_tact_launch(AgsTask *task) { AgsApplyTact *apply_tact; apply_tact = AGS_APPLY_TACT(task); if(AGS_IS_APPLICATION_CONTEXT(apply_tact->scope)){ AgsApplicationContext *application_context; application_context = (AgsApplicationContext *) apply_tact->scope; ags_apply_tact_application_context(apply_tact, application_context); }else if(AGS_IS_SOUNDCARD(apply_tact->scope)){ GObject *soundcard; soundcard = apply_tact->scope; ags_apply_tact_soundcard(apply_tact, soundcard); }else if(AGS_IS_SEQUENCER(apply_tact->scope)){ GObject *sequencer; sequencer = apply_tact->scope; ags_apply_tact_sequencer(apply_tact, sequencer); }else if(AGS_IS_AUDIO(apply_tact->scope)){ AgsAudio *audio; audio = AGS_AUDIO(apply_tact->scope); ags_apply_tact_audio(apply_tact, audio); }else if(AGS_IS_CHANNEL(apply_tact->scope)){ AgsChannel *channel; channel = AGS_CHANNEL(apply_tact->scope); ags_apply_tact_channel(apply_tact, channel); }else if(AGS_IS_RECALL(apply_tact->scope)){ AgsRecall *recall; recall = AGS_RECALL(apply_tact->scope); ags_apply_tact_recall(apply_tact, recall); }else{ g_warning("AgsApplyTact: Not supported scope"); } }
void ags_set_samplerate_devout(AgsSetSamplerate *set_samplerate, AgsDevout *devout) { GList *list; g_object_set(G_OBJECT(devout), "frequency\0", (guint) set_samplerate->samplerate, NULL); /* AgsAudio */ list = devout->audio; while(list != NULL){ ags_set_samplerate_audio(set_samplerate, AGS_AUDIO(list->data)); list = list->next; } }
void ags_set_buffer_size_devout(AgsSetBufferSize *set_buffer_size, AgsDevout *devout) { GList *list; /* */ g_object_set(G_OBJECT(devout), "buffer_size\0", set_buffer_size->buffer_size, NULL); /* AgsAudio */ list = devout->audio; while(list != NULL){ ags_set_buffer_size_audio(set_buffer_size, AGS_AUDIO(list->data)); list = list->next; } }
void ags_set_samplerate_launch(AgsTask *task) { AgsSetSamplerate *set_samplerate; GObject *gobject; set_samplerate = AGS_SET_SAMPLERATE(task); gobject = set_samplerate->gobject; if(AGS_IS_DEVOUT(gobject)){ ags_set_samplerate_devout(set_samplerate, AGS_DEVOUT(gobject)); }else if(AGS_IS_AUDIO(gobject)){ ags_set_samplerate_audio(set_samplerate, AGS_AUDIO(gobject)); }else if(AGS_IS_CHANNEL(gobject)){ ags_set_samplerate_channel(set_samplerate, AGS_CHANNEL(gobject)); }else if(AGS_IS_RECYCLING(gobject)){ ags_set_samplerate_recycling(set_samplerate, AGS_RECYCLING(gobject)); }else if(AGS_IS_AUDIO_SIGNAL(gobject)){ ags_set_samplerate_audio_signal(set_samplerate, AGS_AUDIO_SIGNAL(gobject)); } }
void ags_set_buffer_size_launch(AgsTask *task) { AgsSetBufferSize *set_buffer_size; GObject *gobject; set_buffer_size = AGS_SET_BUFFER_SIZE(task); gobject = set_buffer_size->gobject; if(AGS_IS_DEVOUT(gobject)){ ags_set_buffer_size_devout(set_buffer_size, AGS_DEVOUT(gobject)); }else if(AGS_IS_AUDIO(gobject)){ ags_set_buffer_size_audio(set_buffer_size, AGS_AUDIO(gobject)); }else if(AGS_IS_CHANNEL(gobject)){ ags_set_buffer_size_channel(set_buffer_size, AGS_CHANNEL(gobject)); }else if(AGS_IS_RECYCLING(gobject)){ ags_set_buffer_size_recycling(set_buffer_size, AGS_RECYCLING(gobject)); }else if(AGS_IS_AUDIO_SIGNAL(gobject)){ ags_set_buffer_size_audio_signal(set_buffer_size, AGS_AUDIO_SIGNAL(gobject)); } }
void ags_drum_output_line_set_channel(AgsLine *line, AgsChannel *channel) { AgsDrumOutputLine *drum_output_line; AGS_LINE_CLASS(ags_drum_output_line_parent_class)->set_channel(line, channel); drum_output_line = AGS_DRUM_OUTPUT_LINE(line); if(line->channel != NULL){ line->flags &= (~AGS_LINE_MAPPED_RECALL); } if(channel != NULL){ AgsDevout *devout; AgsAudioSignal *audio_signal; guint stop; devout = AGS_DEVOUT(AGS_AUDIO(channel->audio)->devout); stop = (guint) ceil(16.0 * AGS_DEVOUT_DEFAULT_DELAY * exp2(8.0 - 4.0) + 1.0); audio_signal = ags_audio_signal_new(devout, channel->first_recycling, NULL); audio_signal->flags |= AGS_AUDIO_SIGNAL_TEMPLATE; // ags_audio_signal_stream_resize(audio_signal, // stop); ags_recycling_add_audio_signal(channel->first_recycling, audio_signal); // audio_signal = ags_audio_signal_get_template(channel->first_recycling->audio_signal); // ags_audio_signal_stream_resize(audio_signal, stop); if((AGS_LINE_PREMAPPED_RECALL & (line->flags)) == 0){ ags_drum_output_line_add_default_recall(AGS_DRUM_OUTPUT_LINE(line)); } } }
/** * ags_output_map_audio_signal: * @output: an #AgsOutput * @recall_id: the assigned #AgsRecallID * * Maps audio signal and assigning it to recall id. * * Returns: a new #GList containing #AgsAudioSignal * * Since: 0.4 */ GList* ags_output_map_audio_signal(AgsOutput *output, AgsRecallID *recall_id) { AgsDevout *devout; AgsAudioSignal *audio_signal; GList *list_destination; if(output != NULL){ list_destination = g_list_alloc(); goto ags_copy_pattern_map_destination0; }else return(NULL); devout = AGS_DEVOUT(AGS_AUDIO(AGS_CHANNEL(output)->audio)->devout); while(output != NULL){ list_destination->next = g_list_alloc(); list_destination->next->prev = list_destination; list_destination = list_destination->next; ags_copy_pattern_map_destination0: g_message("ags_output_map_audio_signal\n\0"); audio_signal = ags_audio_signal_new((GObject *) devout, (GObject *) output->channel.first_recycling, (GObject *) recall_id); ags_connectable_connect(AGS_CONNECTABLE(audio_signal)); ags_recycling_add_audio_signal(output->channel.first_recycling, audio_signal); audio_signal->stream_current = audio_signal->stream_beginning; list_destination->data = (gpointer) audio_signal; output = (AgsOutput *) output->channel.next_pad; } return(list_destination); }
int ags_input_editor_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsInputEditor *input_editor) { AgsMachine *machine; AgsLineEditor *line_editor; AgsAudio *audio; AgsChannel *channel; if(old_parent != NULL){ return(0); } //TODO:JK: missing mutex line_editor = (AgsLineEditor *) gtk_widget_get_ancestor(widget, AGS_TYPE_LINE_EDITOR); if(line_editor != NULL){ channel = line_editor->channel; if(channel != NULL){ GtkTreeIter iter; audio = AGS_AUDIO(channel->audio); if(audio != NULL){ machine = AGS_MACHINE(audio->machine_widget); gtk_combo_box_set_model(GTK_COMBO_BOX(input_editor->soundcard), GTK_TREE_MODEL(ags_machine_get_possible_audio_input_connections(machine))); ags_input_editor_check(input_editor); } } } return(0); }
void ags_drum_input_line_map_recall(AgsDrumInputLine *drum_input_line, guint output_pad_start) { AgsDrum *drum; AgsLine *line; AgsLineMember *line_member; AgsAudio *audio; AgsChannel *source; AgsChannel *current, *destination; AgsCopyChannel *copy_channel; AgsCopyChannelRun *copy_channel_run; GList *list; guint i; line = AGS_LINE(drum_input_line); line->flags |= AGS_LINE_MAPPED_RECALL; audio = AGS_AUDIO(line->channel->audio); drum = AGS_DRUM(audio->machine); source = line->channel; /* ags-play */ // ags_recall_factory_create(audio, // "ags-play\0", // 0, audio->audio_channels, // source->pad, source->pad + 1, // FALSE, // FALSE); /* ags-volume */ ags_recall_factory_create(audio, NULL, NULL, "ags-volume\0", source->audio_channel, source->audio_channel + 1, source->pad, source->pad + 1, (AGS_RECALL_FACTORY_INPUT | AGS_RECALL_FACTORY_RECALL | AGS_RECALL_FACTORY_ADD), 0); /* ags-copy */ ags_recall_factory_create(audio, NULL, NULL, "ags-copy\0", source->audio_channel, source->audio_channel + 1, source->pad, source->pad + 1, (AGS_RECALL_FACTORY_INPUT | AGS_RECALL_FACTORY_RECALL | AGS_RECALL_FACTORY_ADD), 0); current = source; destination = ags_channel_nth(audio->output, current->audio_channel); while(destination != NULL){ /* recall */ list = current->recall; while((list = ags_recall_find_type(list, AGS_TYPE_COPY_CHANNEL)) != NULL){ copy_channel = AGS_COPY_CHANNEL(list->data); g_object_set(G_OBJECT(copy_channel), "destination\0", destination, NULL); list = list->next; } list = current->recall; while((list = ags_recall_find_type(list, AGS_TYPE_COPY_CHANNEL_RUN)) != NULL){ copy_channel_run = AGS_COPY_CHANNEL_RUN(list->data); g_object_set(G_OBJECT(copy_channel_run), "destination\0", destination, NULL); list = list->next; } destination = destination->next_pad; } /* ags-stream */ ags_recall_factory_create(audio, NULL, NULL, "ags-stream\0", source->audio_channel, source->audio_channel + 1, source->pad, source->pad + 1, (AGS_RECALL_FACTORY_INPUT | AGS_RECALL_FACTORY_PLAY | AGS_RECALL_FACTORY_RECALL | AGS_RECALL_FACTORY_ADD), 0); }
volume); break; case AGS_APPLY_SYNTH_SQUARE: ags_synth_square(soundcard, (signed short *) stream->data, offset, frequency, phase, frame_count, volume); break; case AGS_APPLY_SYNTH_TRIANGLE: ags_synth_triangle(soundcard, (signed short *) stream->data, offset, frequency, phase, frame_count, volume); break; default: g_warning("ags_apply_synth_launch_write: warning no wave selected\n\0"); } } apply_synth = AGS_APPLY_SYNTH(task); channel = apply_synth->start_channel; soundcard = AGS_AUDIO(channel->audio)->soundcard; ags_soundcard_get_presets(AGS_SOUNDCARD(soundcard), NULL, &samplerate, &buffer_size, NULL); wave = (gint) apply_synth->wave; g_message("wave = %d\n\0", wave); /* some settings */ frequency = apply_synth->frequency; volume = (double) apply_synth->volume; /* settings which needs to be initialized for factorizing */
void ags_panel_input_line_map_recall(AgsLine *line, guint output_pad_start) { AgsPanel *panel; AgsPanelInputLine *panel_input_line; AgsAudio *audio; AgsChannel *source; AgsChannel *current; AgsPlayChannel *play_channel; AgsPlayChannelRunMaster *play_channel_run; GList *list; if((AGS_LINE_MAPPED_RECALL & (line->flags)) != 0 || (AGS_LINE_PREMAPPED_RECALL & (line->flags)) != 0){ return; } panel_input_line = AGS_PANEL_INPUT_LINE(line); audio = AGS_AUDIO(line->channel->audio); panel = AGS_PANEL(audio->machine_widget); source = line->channel; /* ags-play */ ags_recall_factory_create(audio, NULL, NULL, "ags-play-master\0", source->audio_channel, source->audio_channel + 1, source->pad, source->pad + 1, (AGS_RECALL_FACTORY_INPUT, AGS_RECALL_FACTORY_PLAY | AGS_RECALL_FACTORY_ADD), 0); /* set audio channel */ list = source->play; while((list = ags_recall_template_find_type(list, AGS_TYPE_PLAY_CHANNEL)) != NULL){ GValue audio_channel_value = {0,}; play_channel = AGS_PLAY_CHANNEL(list->data); g_value_init(&audio_channel_value, G_TYPE_UINT64); g_value_set_uint64(&audio_channel_value, source->audio_channel); ags_port_safe_write(play_channel->audio_channel, &audio_channel_value); list = list->next; } /* call parent */ AGS_LINE_CLASS(ags_panel_input_line_parent_class)->map_recall(line, output_pad_start); }
AgsRecall *template; AgsLoopChannelRun *loop_channel_run; AgsRecallDependency *recall_dependency; AgsCountBeatsAudioRun *count_beats_audio_run; GList *list; AgsRecallID *recall_id; guint i, i_stop; loop_channel_run = AGS_LOOP_CHANNEL_RUN(recall); template = AGS_RECALL(ags_recall_find_template(AGS_RECALL_CONTAINER(recall->container)->recall_channel_run)->data); list = template->dependencies; channel = AGS_RECALL_CHANNEL_RUN(loop_channel_run)->source; audio = AGS_AUDIO(channel->audio); recall_id = recall->recall_id; count_beats_audio_run = NULL; i_stop = 1; for(i = 0; i < i_stop && list != NULL;){ recall_dependency = AGS_RECALL_DEPENDENCY(list->data); if(AGS_IS_COUNT_BEATS_AUDIO_RUN(recall_dependency->dependency)){ count_beats_audio_run = (AgsCountBeatsAudioRun *) ags_recall_dependency_resolve(recall_dependency, recall_id); i++; }
void ags_mixer_set_audio_channels(AgsAudio *audio, guint audio_channels, guint audio_channels_old, gpointer data) { AgsMixer *mixer; GtkVScale *scale; GList *list_input_pad; guint i; mixer = AGS_MIXER(audio->machine); if(audio_channels_old < audio_channels){ AgsMixerInputPad *mixer_input_pad; AgsChannel *channel; /* AgsInput */ channel = audio->input; list_input_pad = gtk_container_get_children((GtkContainer *) mixer->input_pad); for(i = 0; i < audio->input_pads; i++){ if(audio_channels_old == 0){ /* create AgsPad's if necessary */ mixer_input_pad = g_object_new(AGS_TYPE_MIXER_INPUT_PAD, "channel\0", channel, NULL); gtk_box_pack_start((GtkBox *) mixer->input_pad, (GtkWidget *) mixer_input_pad, FALSE, FALSE, 0); ags_pad_resize_lines((AgsPad *) mixer_input_pad, AGS_TYPE_MIXER_INPUT_LINE, AGS_AUDIO(channel->audio)->audio_channels, 0); if(GTK_WIDGET_VISIBLE((GtkWidget *) mixer)){ ags_connectable_connect(AGS_CONNECTABLE(mixer_input_pad)); ags_pad_find_port(AGS_PAD(mixer_input_pad)); gtk_widget_show_all((GtkWidget *) mixer_input_pad); } }else{ mixer_input_pad = AGS_MIXER_INPUT_PAD(list_input_pad->data); ags_pad_resize_lines((AgsPad *) mixer_input_pad, AGS_TYPE_MIXER_INPUT_LINE, audio_channels, audio_channels_old); } channel = channel->next_pad; if(audio_channels_old != 0) list_input_pad = list_input_pad->next; } }else{ GList *list_input_pad_next; list_input_pad = gtk_container_get_children((GtkContainer *) mixer->input_pad); if(audio_channels == 0){ /* AgsInput */ while(list_input_pad != NULL){ list_input_pad_next = list_input_pad->next; gtk_widget_destroy(GTK_WIDGET(list_input_pad->data)); list_input_pad->next = list_input_pad_next; } }else{ /* AgsInput */ for(i = 0; list_input_pad != NULL; i++){ ags_pad_resize_lines(AGS_PAD(list_input_pad->data), AGS_TYPE_MIXER_INPUT_PAD, audio_channels, audio_channels_old); list_input_pad = list_input_pad->next; } } } }
void ags_drum_input_pad_open_callback(GtkWidget *widget, AgsDrumInputPad *drum_input_pad) { GtkFileChooserDialog *file_chooser; GtkHBox *hbox; GtkLabel *label; GtkSpinButton *spin_button; GtkToggleButton *play; if(drum_input_pad->file_chooser != NULL) return; drum_input_pad->file_chooser = file_chooser = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new(i18n("Open File"), (GtkWindow *) gtk_widget_get_toplevel((GtkWidget *) drum_input_pad), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_shortcut_folder_uri(GTK_FILE_CHOOSER(file_chooser), "file:///usr/share/hydrogen/data/drumkits", NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), FALSE); g_object_set_data((GObject *) file_chooser, (char *) g_type_name(AGS_TYPE_AUDIO_FILE), NULL); g_object_set_data((GObject *) file_chooser, AGS_DRUM_INPUT_PAD_OPEN_AUDIO_FILE_NAME, NULL); hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_file_chooser_set_extra_widget((GtkFileChooser *) file_chooser, (GtkWidget *) hbox); label = (GtkLabel *) gtk_label_new(i18n("channel: ")); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 0); spin_button = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, AGS_AUDIO(AGS_PAD(drum_input_pad)->channel->audio)->audio_channels - 1, 1.0); g_object_set_data((GObject *) file_chooser, AGS_DRUM_INPUT_PAD_OPEN_SPIN_BUTTON, spin_button); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) spin_button, FALSE, FALSE, 0); if(drum_input_pad->pad.group->active){ gtk_widget_set_sensitive((GtkWidget *) spin_button, FALSE); } #if 0 play = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON, "label", GTK_STOCK_MEDIA_PLAY, "use-stock", TRUE, "use-underline", TRUE, NULL); gtk_box_pack_start((GtkBox *) GTK_DIALOG(file_chooser)->action_area, (GtkWidget *) play, FALSE, FALSE, 0); gtk_box_reorder_child((GtkBox *) GTK_DIALOG(file_chooser)->action_area, (GtkWidget *) play, 0); #endif gtk_widget_show_all((GtkWidget *) file_chooser); g_signal_connect((GObject *) file_chooser, "response", G_CALLBACK(ags_drum_input_pad_open_response_callback), (gpointer) drum_input_pad); }
void ags_matrix_set_pads(AgsAudio *audio, GType type, guint pads, guint pads_old, gpointer data) { AgsMachine *machine; AgsMatrix *matrix; AgsChannel *channel, *source; AgsAudioSignal *audio_signal; guint i, j; gboolean grow; GValue value = {0,}; if(pads == pads_old){ return; } matrix = (AgsMatrix *) audio->machine_widget; machine = AGS_MACHINE(matrix); if(type == AGS_TYPE_INPUT){ if(pads < AGS_MATRIX_OCTAVE){ gtk_widget_set_size_request((GtkWidget *) matrix->drawing_area, 32 * AGS_MATRIX_CELL_WIDTH +1, pads * AGS_MATRIX_CELL_HEIGHT +1); }else if(pads_old < AGS_MATRIX_OCTAVE){ gtk_widget_set_size_request((GtkWidget *) matrix->drawing_area, 32 * AGS_MATRIX_CELL_WIDTH +1, AGS_MATRIX_OCTAVE * AGS_MATRIX_CELL_HEIGHT +1); } } if(pads_old == pads) return; if(pads_old < pads) grow = TRUE; else grow = FALSE; if(type == AGS_TYPE_INPUT){ AgsPattern *pattern; GList *list, *notation; if(grow){ /* create pattern */ source = ags_channel_nth(audio->input, pads_old); while(source != NULL){ if(source->pattern == NULL){ source->pattern = g_list_alloc(); source->pattern->data = (gpointer) ags_pattern_new(); ags_pattern_set_dim((AgsPattern *) source->pattern->data, 1, 9, 32); } source = source->next; } if((AGS_MACHINE_MAPPED_RECALL & (machine->flags)) != 0){ ags_matrix_input_map_recall(matrix, pads_old); } }else{ } }else{ if(grow){ AgsChannel *current, *output; GList *recall; GList *list; guint stop; source = ags_channel_nth(audio->output, pads_old); if(source != NULL){ AgsAudioSignal *audio_signal; AgsSoundcard *soundcard; gdouble delay; guint stop; soundcard = AGS_SOUNDCARD(AGS_AUDIO(source->audio)->soundcard); delay = ags_soundcard_get_delay(soundcard); stop = (guint) ceil(16.0 * delay * exp2(8.0 - 4.0) + 1.0); audio_signal = ags_audio_signal_new(soundcard, source->first_recycling, NULL); audio_signal->flags |= AGS_AUDIO_SIGNAL_TEMPLATE; // ags_audio_signal_stream_resize(audio_signal, // stop); ags_recycling_add_audio_signal(source->first_recycling, audio_signal); if((AGS_MACHINE_MAPPED_RECALL & (machine->flags)) != 0){ ags_matrix_output_map_recall(matrix, pads_old); } } }else{ } } }