/**
* 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{
}
}
}
