void
ags_play_channel_run_run_pre(AgsRecall *recall)
{
AgsChannel *source;
AgsDevout *devout;
AgsRecycling *recycling;
AgsAudioSignal *audio_signal;
gdouble delay;
guint attack;
guint tic_counter_incr;
devout = AGS_DEVOUT(recall->devout);
// g_message("ags_copy_pattern_channel_run_sequencer_alloc_callback - playing channel: %u; playing pattern: %u\0",
// AGS_RECALL_CHANNEL(copy_pattern_channel)->source->line,
// copy_pattern_audio_run->count_beats_audio_run->sequencer_counter);
/* get source */
source = AGS_RECALL_CHANNEL_RUN(recall)->source;
/* create new audio signals */
recycling = source->first_recycling;
tic_counter_incr = devout->tic_counter + 1;
//TODO:JK: unclear
attack = 0; //devout->attack[((tic_counter_incr == AGS_NOTATION_TICS_PER_BEAT) ?
// 0:
// tic_counter_incr)];
delay = 0.0; // devout->delay[((tic_counter_incr == AGS_NOTATION_TICS_PER_BEAT) ?
// 0:
// tic_counter_incr)];
if(recycling != NULL){
while(recycling != source->last_recycling->next){
audio_signal = ags_audio_signal_new((GObject *) recall->devout,
(GObject *) recycling,
(GObject *) recall->recall_id);
ags_recycling_create_audio_signal_with_defaults(recycling,
audio_signal,
delay, attack);
audio_signal->stream_current = audio_signal->stream_beginning;
ags_audio_signal_connect(audio_signal);
/*
* emit add_audio_signal on AgsRecycling
*/
ags_recycling_add_audio_signal(recycling,
audio_signal);
/* */
recycling = recycling->next;
}
}
/* call parent */
AGS_RECALL_CLASS(ags_play_channel_run_parent_class)->run_pre(recall);
}
/**
* 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);
}
void
ags_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);
}
}
void
ags_play_audio_signal_run_inter(AgsRecall *recall)
{
AgsDevout *devout;
AgsRecycling *recycling;
AgsAudioSignal *source;
AgsPlayChannel *play_channel;
AgsPlayAudioSignal *play_audio_signal;
GList *stream;
signed short *buffer0, *buffer1;
guint audio_channel;
gboolean muted;
GValue muted_value = {0,};
GValue audio_channel_value = {0,};
play_audio_signal = AGS_PLAY_AUDIO_SIGNAL(recall);
devout = AGS_DEVOUT(AGS_RECALL(play_audio_signal)->devout);
source = AGS_AUDIO_SIGNAL(AGS_RECALL_AUDIO_SIGNAL(play_audio_signal)->source);
stream = source->stream_current;
if(devout == NULL){
g_warning("no devout\0");
return;
}
if(stream == NULL){
ags_recall_done(recall);
return;
}
if((AGS_DEVOUT_BUFFER0 & devout->flags) != 0){
buffer0 = devout->buffer[1];
buffer1 = devout->buffer[2];
}else if((AGS_DEVOUT_BUFFER1 & devout->flags) != 0){
buffer0 = devout->buffer[2];
buffer1 = devout->buffer[3];
}else if((AGS_DEVOUT_BUFFER2 & devout->flags) != 0){
buffer0 = devout->buffer[3];
buffer1 = devout->buffer[0];
}else if((AGS_DEVOUT_BUFFER3 & devout->flags) != 0){
buffer0 = devout->buffer[0];
buffer1 = devout->buffer[1];
}else{
g_warning("no output buffer\0");
return;
}
play_channel = AGS_PLAY_CHANNEL(AGS_RECALL_CHANNEL_RUN(recall->parent->parent)->recall_channel);
g_value_init(&muted_value, G_TYPE_BOOLEAN);
ags_port_safe_read(play_channel->muted,
&muted_value);
muted = g_value_get_boolean(&muted_value);
if(muted){
return;
}
g_value_init(&audio_channel_value, G_TYPE_UINT);
ags_port_safe_read(play_channel->audio_channel,
&audio_channel_value);
audio_channel = g_value_get_uint(&audio_channel_value);
if((AGS_RECALL_INITIAL_RUN & (AGS_RECALL_AUDIO_SIGNAL(recall)->flags)) != 0){
AGS_RECALL_AUDIO_SIGNAL(recall)->flags &= (~AGS_RECALL_INITIAL_RUN);
ags_audio_signal_copy_buffer_to_buffer(&(buffer0[audio_channel + source->attack * devout->pcm_channels]),
devout->pcm_channels,
(signed short *) stream->data, 1,
AGS_DEVOUT_DEFAULT_BUFFER_SIZE - source->attack);
}else{
ags_audio_signal_copy_buffer_to_buffer(&(buffer0[audio_channel]), devout->pcm_channels,
(signed short *) stream->data, 1,
devout->buffer_size);
}
/* call parent */
AGS_RECALL_CLASS(ags_play_audio_signal_parent_class)->run_inter(recall);
}
void
ags_stream_audio_signal_run_post(AgsRecall *recall)
{
AgsStreamChannel *stream_channel;
AgsStreamChannelRun *stream_channel_run;
AgsStreamAudioSignal *stream_audio_signal;
stream_audio_signal = AGS_STREAM_AUDIO_SIGNAL(recall);
if(recall->parent != NULL &&
recall->parent->parent != NULL){
stream_channel_run = recall->parent->parent;
stream_channel = AGS_RECALL_CHANNEL_RUN(stream_channel_run)->recall_channel;
}else{
stream_channel_run = NULL;
stream_channel = NULL;
}
if(AGS_RECALL_AUDIO_SIGNAL(recall)->source->stream_current != NULL){
if(stream_channel != NULL &&
AGS_RECALL_AUDIO_SIGNAL(recall)->source->stream_current->next == NULL){
GValue value = {0,};
g_value_init(&value, G_TYPE_BOOLEAN);
ags_port_safe_read(stream_channel->auto_sense,
&value);
if(g_value_get_boolean(&value)){
signed short *buffer;
guint buffer_size;
guint i;
gboolean add_stream;
buffer = AGS_RECALL_AUDIO_SIGNAL(recall)->source->stream_current->data;
buffer_size = AGS_RECALL_AUDIO_SIGNAL(recall)->source->buffer_size;
add_stream = FALSE;
for(i = buffer_size - 1; i > buffer_size / 2; i--){
if(buffer[i] != 0){
add_stream = TRUE;
break;
}
}
if(add_stream){
ags_audio_signal_add_stream(AGS_RECALL_AUDIO_SIGNAL(recall)->source);
}
}
}
AGS_RECALL_AUDIO_SIGNAL(recall)->source->stream_current = AGS_RECALL_AUDIO_SIGNAL(recall)->source->stream_current->next;
/* call parent */
AGS_RECALL_CLASS(ags_stream_audio_signal_parent_class)->run_post(recall);
}else{
/* call parent */
AGS_RECALL_CLASS(ags_stream_audio_signal_parent_class)->run_post(recall);
if(recall->parent != NULL){
ags_recycling_remove_audio_signal(AGS_RECALL_RECYCLING(recall->parent)->source,
AGS_RECALL_AUDIO_SIGNAL(recall)->source);
}
ags_recall_done(recall);
}
}
void
ags_recall_dependency_test_find_dependency_by_provider()
{
AgsChannel *channel[3];
AgsAudio *audio[3];
AgsRecall *recall;
AgsRecallAudio *recall_audio;
AgsRecallDependency *recall_dependency[6];
GList *list, *current;
list = NULL;
/* dependency #0 */
audio[0] = g_object_new(AGS_TYPE_AUDIO,
NULL);
recall_audio = g_object_new(AGS_TYPE_RECALL_AUDIO,
"audio", audio[0],
NULL);
recall = g_object_new(AGS_TYPE_RECALL_AUDIO_RUN,
"recall-audio", recall_audio,
NULL);
recall_dependency[0] = g_object_new(AGS_TYPE_RECALL_DEPENDENCY,
"dependency", recall,
NULL);
list = g_list_prepend(list,
recall_dependency[0]);
/* dependency #1 */
channel[0] = g_object_new(AGS_TYPE_CHANNEL,
NULL);
recall = g_object_new(AGS_TYPE_RECALL_CHANNEL_RUN,
"source", channel[0],
NULL);
recall_dependency[1] = g_object_new(AGS_TYPE_RECALL_DEPENDENCY,
"dependency", recall,
NULL);
list = g_list_prepend(list,
recall_dependency[1]);
/* dependency #2 */
channel[1] = g_object_new(AGS_TYPE_CHANNEL,
NULL);
recall = g_object_new(AGS_TYPE_RECALL_CHANNEL_RUN,
"source", channel[1],
NULL);
recall_dependency[2] = g_object_new(AGS_TYPE_RECALL_DEPENDENCY,
"dependency", recall,
NULL);
list = g_list_prepend(list,
recall_dependency[2]);
/* dependency #3 */
audio[1] = g_object_new(AGS_TYPE_AUDIO,
NULL);
recall_audio = g_object_new(AGS_TYPE_RECALL_AUDIO,
"audio", audio[1],
NULL);
recall = g_object_new(AGS_TYPE_RECALL_AUDIO_RUN,
"recall-audio", recall_audio,
NULL);
recall_dependency[3] = g_object_new(AGS_TYPE_RECALL_DEPENDENCY,
"dependency", recall,
NULL);
list = g_list_prepend(list,
recall_dependency[3]);
/* dependency #4 */
audio[2] = g_object_new(AGS_TYPE_AUDIO,
NULL);
recall_audio = g_object_new(AGS_TYPE_RECALL_AUDIO,
"audio", audio[2],
NULL);
recall = g_object_new(AGS_TYPE_RECALL_AUDIO_RUN,
"recall-audio", recall_audio,
NULL);
recall_dependency[4] = g_object_new(AGS_TYPE_RECALL_DEPENDENCY,
"dependency", recall,
NULL);
list = g_list_prepend(list,
recall_dependency[4]);
/* dependency #5 */
channel[2] = g_object_new(AGS_TYPE_CHANNEL,
NULL);
recall = g_object_new(AGS_TYPE_RECALL_CHANNEL_RUN,
"source", channel[2],
NULL);
recall_dependency[5] = g_object_new(AGS_TYPE_RECALL_DEPENDENCY,
"dependency", recall,
NULL);
list = g_list_prepend(list,
recall_dependency[5]);
/* find and assert - audio */
CU_ASSERT((current = ags_recall_dependency_find_dependency_by_provider(list,
audio[0])) != NULL &&
AGS_RECALL_AUDIO_RUN(AGS_RECALL_DEPENDENCY(current->data)->dependency)->recall_audio->audio == audio[0]);
CU_ASSERT((current = ags_recall_dependency_find_dependency_by_provider(list,
audio[1])) != NULL &&
AGS_RECALL_AUDIO_RUN(AGS_RECALL_DEPENDENCY(current->data)->dependency)->recall_audio->audio == audio[1]);
CU_ASSERT((current = ags_recall_dependency_find_dependency_by_provider(list,
audio[2])) != NULL &&
AGS_RECALL_AUDIO_RUN(AGS_RECALL_DEPENDENCY(current->data)->dependency)->recall_audio->audio == audio[2]);
/* find and assert - channel */
CU_ASSERT((current = ags_recall_dependency_find_dependency_by_provider(list,
channel[0])) != NULL &&
AGS_RECALL_CHANNEL_RUN(AGS_RECALL_DEPENDENCY(current->data)->dependency)->source == channel[0]);
CU_ASSERT((current = ags_recall_dependency_find_dependency_by_provider(list,
channel[1])) != NULL &&
AGS_RECALL_CHANNEL_RUN(AGS_RECALL_DEPENDENCY(current->data)->dependency)->source == channel[1]);
CU_ASSERT((current = ags_recall_dependency_find_dependency_by_provider(list,
channel[2])) != NULL &&
AGS_RECALL_CHANNEL_RUN(AGS_RECALL_DEPENDENCY(current->data)->dependency)->source == channel[2]);
}
AgsChannel *channel;
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++;
}
