/**
* ags_soundcard_helper_config_get_pcm_channels:
* @config: the #AgsConfig
*
* Get pcm channels count.
*
* Returns: the count of pcm channels
*
* Since: 2.0.0
*/
guint
ags_soundcard_helper_config_get_pcm_channels(AgsConfig *config)
{
gchar *str;
guint pcm_channels;
if(!AGS_IS_CONFIG(config)){
return(AGS_SOUNDCARD_DEFAULT_PCM_CHANNELS);
}
/* pcm-channels */
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"pcm-channels");
if(str == NULL){
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD_0,
"pcm-channels");
}
if(str != NULL){
pcm_channels = g_ascii_strtoull(str,
NULL,
10);
free(str);
}else{
pcm_channels = AGS_SOUNDCARD_DEFAULT_PCM_CHANNELS;
}
return(pcm_channels);
}
/**
* ags_soundcard_helper_config_get_buffer_size:
* @config: the #AgsConfig
*
* Get buffer size.
*
* Returns: the buffer size
*
* Since: 2.0.0
*/
guint
ags_soundcard_helper_config_get_buffer_size(AgsConfig *config)
{
gchar *str;
guint buffer_size;
if(!AGS_IS_CONFIG(config)){
return(AGS_SOUNDCARD_DEFAULT_BUFFER_SIZE);
}
/* buffer-size */
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"buffer-size");
if(str == NULL){
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD_0,
"buffer-size");
}
if(str != NULL){
buffer_size = g_ascii_strtoull(str,
NULL,
10);
free(str);
}else{
buffer_size = AGS_SOUNDCARD_DEFAULT_BUFFER_SIZE;
}
return(buffer_size);
}
/**
* ags_soundcard_helper_config_get_format:
* @config: the #AgsConfig
*
* Get format as #AgsSoundcardFormat-enum.
*
* Returns: the format
*
* Since: 2.0.0
*/
guint
ags_soundcard_helper_config_get_format(AgsConfig *config)
{
gchar *str;
guint format;
if(!AGS_IS_CONFIG(config)){
return(AGS_SOUNDCARD_DEFAULT_FORMAT);
}
/* format */
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"format");
if(str == NULL){
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD_0,
"format");
}
if(str != NULL){
format = g_ascii_strtoull(str,
NULL,
10);
free(str);
}else{
format = AGS_SOUNDCARD_DEFAULT_FORMAT;
}
return(format);
}
/**
* ags_soundcard_helper_config_get_samplerate:
* @config: the #AgsConfig
*
* Get samplerate.
*
* Returns: the samplerate
*
* Since: 2.0.0
*/
gdouble
ags_soundcard_helper_config_get_samplerate(AgsConfig *config)
{
gchar *str;
gdouble samplerate;
if(!AGS_IS_CONFIG(config)){
return(AGS_SOUNDCARD_DEFAULT_SAMPLERATE);
}
/* samplerate */
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"samplerate");
if(str == NULL){
str = ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD_0,
"samplerate");
}
if(str != NULL){
samplerate = g_ascii_strtod(str,
NULL);
free(str);
}else{
samplerate = AGS_SOUNDCARD_DEFAULT_SAMPLERATE;
}
return(samplerate);
}
void
ags_menu_action_save_callback(GtkWidget *menu_item, gpointer data)
{
AgsApplicationContext *application_context;
AgsWindow *window;
GError *error;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
if(g_strcmp0(ags_config_get_value(AGS_APPLICATION_CONTEXT(application_context)->config,
AGS_CONFIG_GENERIC,
"simple-file"),
"false")){
AgsSimpleFile *simple_file;
simple_file = (AgsSimpleFile *) g_object_new(AGS_TYPE_SIMPLE_FILE,
"application-context", application_context,
"filename", window->name,
NULL);
error = NULL;
ags_simple_file_rw_open(simple_file,
TRUE,
&error);
ags_simple_file_write(simple_file);
ags_simple_file_close(simple_file);
g_object_unref(G_OBJECT(simple_file));
}else{
AgsFile *file;
file = (AgsFile *) g_object_new(AGS_TYPE_FILE,
"application-context", application_context,
"filename", window->name,
NULL);
error = NULL;
ags_file_rw_open(file,
TRUE,
&error);
ags_file_write(file);
ags_file_close(file);
g_object_unref(G_OBJECT(file));
}
}
void
ags_devout_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsDevout *devout;
devout = AGS_DEVOUT(gobject);
//TODO:JK: implement set functionality
switch(prop_id){
case PROP_APPLICATION_CONTEXT:
{
AgsApplicationContext *application_context;
application_context = g_value_get_object(value);
if(devout->application_context == application_context){
return;
}
if(devout->application_context != NULL){
g_object_unref(G_OBJECT(devout->application_context));
}
if(application_context != NULL){
AgsConfig *config;
g_object_ref(G_OBJECT(application_context));
devout->application_mutex = &(application_context->mutex);
config = application_context->config;
devout->dsp_channels = g_ascii_strtoull(ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"dsp-channels\0"),
NULL,
10);
devout->pcm_channels = g_ascii_strtoull(ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"pcm-channels\0"),
NULL,
10);
devout->format = AGS_SOUNDCARD_DEFAULT_FORMAT;
devout->buffer_size = g_ascii_strtoull(ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"buffer-size\0"),
NULL,
10);
devout->samplerate = g_ascii_strtoull(ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"samplerate\0"),
NULL,
10);
// devout->out.oss.device = NULL;
devout->out.alsa.handle = NULL;
devout->out.alsa.device = g_strdup(ags_config_get_value(config,
AGS_CONFIG_SOUNDCARD,
"alsa-handle\0"));
}else{
devout->application_mutex = NULL;
}
devout->application_context = application_context;
}
break;
case PROP_DEVICE:
{
char *device;
device = (char *) g_value_get_string(value);
if((AGS_DEVOUT_OSS & (devout->flags)) != 0){
devout->out.oss.device = g_strdup(device);
}else if((AGS_DEVOUT_ALSA & (devout->flags)) != 0){
devout->out.alsa.device = g_strdup(device);
}
}
break;
case PROP_DSP_CHANNELS:
{
guint dsp_channels;
dsp_channels = g_value_get_uint(value);
if(dsp_channels == devout->dsp_channels){
return;
}
devout->dsp_channels = dsp_channels;
}
break;
case PROP_PCM_CHANNELS:
{
guint pcm_channels;
pcm_channels = g_value_get_uint(value);
if(pcm_channels == devout->pcm_channels){
return;
}
devout->pcm_channels = pcm_channels;
free(devout->buffer[0]);
free(devout->buffer[1]);
free(devout->buffer[2]);
free(devout->buffer[3]);
devout->buffer[0] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short));
devout->buffer[1] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short));
devout->buffer[2] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short));
devout->buffer[3] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short));
}
break;
case PROP_FORMAT:
{
//TODO:JK: implement me
}
break;
case PROP_BUFFER_SIZE:
{
guint buffer_size;
buffer_size = g_value_get_uint(value);
if(buffer_size == devout->buffer_size){
return;
}
devout->buffer_size = buffer_size;
free(devout->buffer[0]);
free(devout->buffer[1]);
free(devout->buffer[2]);
free(devout->buffer[3]);
devout->buffer[0] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short));
devout->buffer[1] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short));
devout->buffer[2] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short));
devout->buffer[3] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short));
}
break;
case PROP_SAMPLERATE:
{
guint samplerate;
samplerate = g_value_get_uint(value);
if(samplerate == devout->samplerate){
return;
}
devout->samplerate = samplerate;
}
break;
case PROP_BUFFER:
{
//TODO:JK: implement me
}
break;
case PROP_BPM:
{
//TODO:JK: implement me
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_osc_server_preferences_reset(AgsApplicable *applicable)
{
AgsOscServerPreferences *osc_server_preferences;
AgsConfig *config;
gchar *str;
osc_server_preferences = AGS_OSC_SERVER_PREFERENCES(applicable);
config = ags_config_get_instance();
/* block update */
osc_server_preferences->flags |= AGS_OSC_SERVER_PREFERENCES_BLOCK_UPDATE;
/* auto-start */
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"auto-start");
if(str != NULL &&
!g_ascii_strncasecmp(str,
"true",
5)){
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->auto_start,
TRUE);
}else{
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->auto_start,
FALSE);
}
/* any address */
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"any-address");
if(str != NULL &&
!g_ascii_strncasecmp(str,
"true",
5)){
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->any_address,
TRUE);
}else{
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->any_address,
FALSE);
}
/* IPv4 */
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"enable-ip4");
if(str != NULL &&
!g_ascii_strncasecmp(str,
"true",
5)){
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->enable_ip4,
TRUE);
}else{
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->enable_ip4,
FALSE);
}
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"ip4-address");
if(str != NULL){
gtk_entry_set_text(osc_server_preferences->ip4_address,
str);
}
/* IPv6 */
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"enable-ip6");
if(str != NULL &&
!g_ascii_strncasecmp(str,
"true",
5)){
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->enable_ip6,
TRUE);
}else{
gtk_toggle_button_set_active((GtkToggleButton *) osc_server_preferences->enable_ip6,
FALSE);
}
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"ip6-address");
if(str != NULL){
gtk_entry_set_text(osc_server_preferences->ip6_address,
str);
}
/* port */
str = ags_config_get_value(config,
AGS_CONFIG_OSC_SERVER,
"server-port");
if(str != NULL){
gtk_entry_set_text(osc_server_preferences->port,
str);
}
/* unblock update */
osc_server_preferences->flags &= (~AGS_OSC_SERVER_PREFERENCES_BLOCK_UPDATE);
}
void
ags_generic_preferences_reset(AgsApplicable *applicable)
{
AgsGenericPreferences *generic_preferences;
AgsConfig *config;
gchar *str;
generic_preferences = AGS_GENERIC_PREFERENCES(applicable);
config = ags_config_get_instance();
/* auto-save thread */
str = ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread");
if(str != NULL){
gtk_toggle_button_set_active((GtkToggleButton *) generic_preferences->autosave_thread,
((!g_ascii_strncasecmp(str,
"true",
5)) ? TRUE: FALSE));
}else{
gtk_toggle_button_set_active((GtkToggleButton *) generic_preferences->autosave_thread,
FALSE);
}
g_free(str);
/* engine mode */
str = ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"engine-mode");
if(str != NULL){
if(!g_ascii_strncasecmp(str,
"performance",
12)){
gtk_combo_box_set_active((GtkComboBox *) generic_preferences->engine_mode,
1);
}else{
gtk_combo_box_set_active((GtkComboBox *) generic_preferences->engine_mode,
0);
}
}
g_free(str);
/* rt-safe */
str = ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"rt-safe");
if(str != NULL &&
!g_ascii_strncasecmp(str,
"true",
5)){
gtk_toggle_button_set_active((GtkToggleButton *) generic_preferences->rt_safe,
TRUE);
}
g_free(str);
}
void
ags_test_launch_filename(gchar *filename,
gboolean single_thread)
{
AgsThread *audio_loop, *polling_thread, *gui_thread, *task_thread;
AgsThreadPool *thread_pool;
AgsConfig *config;
GList *start_queue;
/* get threads, thread pool and config */
g_object_get(ags_application_context,
"config", &config,
"main-loop", &audio_loop,
"task-thread", &task_thread,
NULL);
g_object_get(task_thread,
"thread-pool", &thread_pool,
NULL);
polling_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_POLLING_THREAD);
gui_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_GUI_THREAD);
/* open file */
if(g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"simple-file\0"),
"false\0")){
AgsSimpleFile *simple_file;
AgsSimpleFileRead *simple_file_read;
GError *error;
simple_file = (AgsSimpleFile *) g_object_new(AGS_TYPE_SIMPLE_FILE,
"application-context\0", ags_application_context,
"filename\0", filename,
NULL);
error = NULL;
ags_simple_file_open(simple_file,
&error);
if(error != NULL){
ags_test_show_file_error(filename,
error);
ags_application_context_quit(ags_application_context);
}
/* start engine */
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = NULL;
start_queue = g_list_prepend(start_queue,
polling_thread);
start_queue = g_list_prepend(start_queue,
task_thread);
// start_queue = g_list_prepend(start_queue,
// gui_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
/* start audio loop and thread pool */
ags_thread_start(audio_loop);
ags_thread_pool_start(thread_pool);
if(!single_thread){
/* wait for audio loop */
pthread_mutex_lock(audio_loop->start_mutex);
if(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE){
g_atomic_int_set(&(audio_loop->start_done),
FALSE);
while(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE &&
g_atomic_int_get(&(audio_loop->start_done)) == FALSE){
pthread_cond_wait(audio_loop->start_cond,
audio_loop->start_mutex);
}
}
pthread_mutex_unlock(audio_loop->start_mutex);
/* start gui thread */
ags_thread_start(gui_thread);
/* wait for gui thread */
pthread_mutex_lock(gui_thread->start_mutex);
if(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
while(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
pthread_cond_wait(gui_thread->start_cond,
gui_thread->start_mutex);
}
}
pthread_mutex_unlock(gui_thread->start_mutex);
/* autosave thread */
if(!g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread\0"),
"true\0")){
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = g_atomic_pointer_get(&(audio_loop->start_queue));
start_queue = g_list_prepend(start_queue,
task_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
}
/* now start read task */
simple_file_read = ags_simple_file_read_new(simple_file);
ags_task_thread_append_task((AgsTaskThread *) task_thread,
(AgsTask *) simple_file_read);
}else{
AgsFile *file;
GError *error;
file = g_object_new(AGS_TYPE_FILE,
"application-context\0", ags_application_context,
"filename\0", filename,
NULL);
error = NULL;
ags_file_open(file,
&error);
if(error != NULL){
ags_test_show_file_error(filename,
error);
ags_application_context_quit(ags_application_context);
}
ags_file_read(file);
ags_file_close(file);
}
}
}
void
ags_test_launch(gboolean single_thread)
{
AgsThread *audio_loop, *polling_thread, *gui_thread, *task_thread;
AgsThreadPool *thread_pool;
AgsConfig *config;
GList *start_queue;
g_object_get(ags_application_context,
"config", &config,
"main-loop", &audio_loop,
"task-thread", &task_thread,
NULL);
g_object_get(task_thread,
"thread-pool", &thread_pool,
NULL);
polling_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_POLLING_THREAD);
gui_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_GUI_THREAD);
/* start engine */
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = NULL;
start_queue = g_list_prepend(start_queue,
polling_thread);
start_queue = g_list_prepend(start_queue,
task_thread);
// start_queue = g_list_prepend(start_queue,
// gui_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
/* start audio loop and thread pool*/
ags_thread_start(audio_loop);
ags_thread_pool_start(thread_pool);
if(!single_thread){
/* wait for audio loop */
pthread_mutex_lock(audio_loop->start_mutex);
if(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE){
g_atomic_int_set(&(audio_loop->start_done),
FALSE);
while(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE &&
g_atomic_int_get(&(audio_loop->start_done)) == FALSE){
pthread_cond_wait(audio_loop->start_cond,
audio_loop->start_mutex);
}
}
pthread_mutex_unlock(audio_loop->start_mutex);
/* start gui thread */
ags_thread_start(gui_thread);
/* wait for gui thread */
pthread_mutex_lock(gui_thread->start_mutex);
if(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
while(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
pthread_cond_wait(gui_thread->start_cond,
gui_thread->start_mutex);
}
}
pthread_mutex_unlock(gui_thread->start_mutex);
g_atomic_int_set(&(AGS_XORG_APPLICATION_CONTEXT(ags_application_context)->gui_ready),
1);
/* autosave thread */
if(!g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread\0"),
"true\0")){
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = g_atomic_pointer_get(&(audio_loop->start_queue));
start_queue = g_list_prepend(start_queue,
task_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
}
}else{
AgsSingleThread *single_thread;
/* single thread */
single_thread = ags_single_thread_new((GObject *) ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(ags_application_context))->data);
/* add known threads to single_thread */
ags_thread_add_child(AGS_THREAD(single_thread),
audio_loop);
/* autosave thread */
if(!g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread\0"),
"true\0")){
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = g_atomic_pointer_get(&(audio_loop->start_queue));
start_queue = g_list_prepend(start_queue,
task_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
}
/* start thread tree */
ags_thread_start((AgsThread *) single_thread);
}
}
void
ags_menu_action_save_as_callback(GtkWidget *menu_item, gpointer data)
{
AgsApplicationContext *application_context;
AgsWindow *window;
GtkFileChooserDialog *file_chooser;
gint response;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
file_chooser = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new("save file as",
(GtkWindow *) window,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), TRUE);
gtk_widget_show_all((GtkWidget *) file_chooser);
response = gtk_dialog_run(GTK_DIALOG(file_chooser));
if(response == GTK_RESPONSE_ACCEPT){
gchar *filename;
gchar *str;
GError *error;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
if(g_strcmp0(ags_config_get_value(AGS_APPLICATION_CONTEXT(application_context)->config,
AGS_CONFIG_GENERIC,
"simple-file"),
"false")){
AgsSimpleFile *simple_file;
simple_file = (AgsSimpleFile *) g_object_new(AGS_TYPE_SIMPLE_FILE,
"application-context", application_context,
"filename", filename,
NULL);
error = NULL;
ags_simple_file_rw_open(simple_file,
TRUE,
&error);
ags_simple_file_write(simple_file);
ags_simple_file_close(simple_file);
g_object_unref(G_OBJECT(simple_file));
}else{
AgsFile *file;
file = (AgsFile *) g_object_new(AGS_TYPE_FILE,
"application-context", application_context,
"filename", filename,
NULL);
error = NULL;
ags_file_rw_open(file,
TRUE,
&error);
ags_file_write(file);
ags_file_close(file);
g_object_unref(G_OBJECT(file));
}
if(window->name != NULL){
g_free(window->name);
}
window->name = g_strdup(filename);
str = g_strconcat("GSequencer - ", window->name, NULL);
gtk_window_set_title((GtkWindow *) window, str);
g_free(str);
}
gtk_widget_destroy((GtkWidget *) file_chooser);
}