void*
ags_thread_loop(void *ptr)
{
AgsThread *thread;
ags_thread_self =
thread = AGS_THREAD(ptr);
}
void
ags_devout_thread_init(AgsDevoutThread *devout_thread)
{
AgsThread *thread;
thread = AGS_THREAD(devout_thread);
thread->freq = AGS_DEVOUT_THREAD_DEFAULT_JIFFIE;
devout_thread->timestamp_thread = ags_timestamp_thread_new();
ags_thread_add_child(thread, devout_thread->timestamp_thread);
devout_thread->error = NULL;
}
void
ags_thread_finalize(GObject *gobject)
{
AgsThread *thread;
thread = AGS_THREAD(gobject);
if(thread->devout != NULL){
g_object_unref(G_OBJECT(thread->devout));
}
/* call parent */
G_OBJECT_CLASS(ags_thread_parent_class)->finalize(gobject);
}
void
ags_soundcard_thread_connect(AgsConnectable *connectable)
{
AgsThread *audio_loop, *soundcard_thread;
soundcard_thread = AGS_THREAD(connectable);
if((AGS_THREAD_CONNECTED & (g_atomic_int_get(&(soundcard_thread->flags)))) != 0){
return;
}
ags_soundcard_thread_parent_connectable_interface->connect(connectable);
audio_loop = ags_thread_get_toplevel(soundcard_thread);
g_signal_connect((GObject *) audio_loop, "stopped-all",
G_CALLBACK(ags_soundcard_thread_stopped_all_callback), soundcard_thread);
}
void
ags_thread_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsThread *thread;
thread = AGS_THREAD(gobject);
switch(prop_id){
case PROP_DEVOUT:
{
AgsDevout *devout;
AgsThread *current;
devout = (AgsDevout *) g_value_get_object(value);
if(thread->devout != NULL){
g_object_unref(G_OBJECT(thread->devout));
}
if(devout != NULL){
g_object_ref(G_OBJECT(devout));
}
thread->devout = G_OBJECT(devout);
current = thread->children;
while(current != NULL){
g_object_set(G_OBJECT(current),
"devout\0", devout,
NULL);
current = current->next;
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_thread_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsThread *thread;
thread = AGS_THREAD(gobject);
switch(prop_id){
case PROP_DEVOUT:
{
g_value_set_object(value, G_OBJECT(thread->devout));
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_xorg_application_context_init(AgsXorgApplicationContext *xorg_application_context)
{
AgsWindow *window;
AgsServer *server;
AgsAudioLoop *audio_loop;
GObject *soundcard;
AgsConfig *config;
struct passwd *pw;
uid_t uid;
gchar *wdir, *config_file;
AGS_APPLICATION_CONTEXT(xorg_application_context)->log = (AgsLog *) g_object_new(AGS_TYPE_LOG,
"file\0", stderr,
NULL);
/**/
config = ags_config_new(NULL);
AGS_APPLICATION_CONTEXT(xorg_application_context)->config = config;
g_object_set(config,
"application-context\0", xorg_application_context,
NULL);
uid = getuid();
pw = getpwuid(uid);
wdir = g_strdup_printf("%s/%s\0",
pw->pw_dir,
AGS_DEFAULT_DIRECTORY);
config_file = g_strdup_printf("%s/%s\0",
wdir,
AGS_DEFAULT_CONFIG);
ags_config_load_from_file(config,
config_file);
g_free(wdir);
g_free(config_file);
/* AgsSoundcard */
soundcard = ags_devout_new(xorg_application_context);
xorg_application_context->soundcard = g_list_prepend(xorg_application_context->soundcard,
soundcard);
g_object_ref(G_OBJECT(soundcard));
/* AgsWindow */
window = ags_window_new(xorg_application_context);
g_object_set(window,
"soundcard\0", soundcard,
NULL);
AGS_XORG_APPLICATION_CONTEXT(xorg_application_context)->window = window;
g_object_ref(G_OBJECT(window));
gtk_window_set_default_size((GtkWindow *) window, 500, 500);
gtk_paned_set_position((GtkPaned *) window->paned, 300);
ags_connectable_connect(AGS_CONNECTABLE(window));
gtk_widget_show_all((GtkWidget *) window);
/* AgsServer */
xorg_application_context->server = ags_server_new(xorg_application_context);
/* AgsMainLoop */
audio_loop = (AgsThread *) ags_audio_loop_new((GObject *) soundcard,
xorg_application_context);
g_object_set(xorg_application_context,
"main-loop\0", audio_loop,
NULL);
g_object_ref(audio_loop);
ags_connectable_connect(AGS_CONNECTABLE(audio_loop));
/* AgsTaskThread */
AGS_APPLICATION_CONTEXT(xorg_application_context)->task_thread = (AgsThread *) ags_task_thread_new();
ags_thread_add_child(AGS_THREAD(audio_loop), AGS_APPLICATION_CONTEXT(xorg_application_context)->task_thread);
/* AgsSoundcardThread */
xorg_application_context->soundcard_thread = (AgsThread *) ags_soundcard_thread_new(soundcard);
ags_thread_add_child(AGS_THREAD(audio_loop), xorg_application_context->soundcard_thread);
/* AgsExportThread */
xorg_application_context->export_thread = (AgsThread *) ags_export_thread_new(soundcard,
NULL);
ags_thread_add_child(AGS_THREAD(audio_loop), xorg_application_context->export_thread);
/* AgsGuiThread */
xorg_application_context->gui_thread = (AgsThread *) ags_gui_thread_new();
ags_thread_add_child(AGS_THREAD(audio_loop), xorg_application_context->gui_thread);
/* AgsThreadPool */
AGS_XORG_APPLICATION_CONTEXT(xorg_application_context)->thread_pool = ags_thread_pool_new(AGS_APPLICATION_CONTEXT(xorg_application_context)->task_thread);
}
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_thread_pool_creation_thread(void *ptr)
{
AgsThreadPool *thread_pool;
AgsThread *thread;
GList *tmplist;
guint n_threads, max_threads;
guint i, i_stop;
thread_pool = AGS_THREAD_POOL(ptr);
#ifdef AGS_DEBUG
g_message("ags_thread_pool_creation_thread\0");
#endif
while((AGS_THREAD_POOL_RUNNING & (g_atomic_int_get(&(thread_pool->flags)))) != 0){
#ifdef AGS_DEBUG
g_message("ags_thread_pool_creation_thread@loopStart\0");
#endif
pthread_mutex_lock(thread_pool->creation_mutex);
g_atomic_int_or(&(thread_pool->flags),
AGS_THREAD_POOL_READY);
while(g_atomic_int_get(&(thread_pool->newly_pulled)) == 0){
pthread_cond_wait(thread_pool->creation_cond,
thread_pool->creation_mutex);
}
n_threads = g_atomic_int_get(&(thread_pool->n_threads));
max_threads = g_atomic_int_get(&(thread_pool->max_threads));
i_stop = g_atomic_int_get(&(thread_pool->newly_pulled));
g_atomic_int_set(&(thread_pool->newly_pulled),
0);
#ifdef AGS_DEBUG
g_message("ags_thread_pool_creation_thread@loop0\0");
#endif
g_atomic_int_and(&(thread_pool->flags),
(~AGS_THREAD_POOL_READY));
if(n_threads < max_threads){
for(i = 0; i < i_stop && n_threads < max_threads; i++){
thread = (AgsThread *) ags_returnable_thread_new(thread_pool);
tmplist = g_atomic_pointer_get(&(thread_pool->returnable_thread));
g_atomic_pointer_set(&(thread_pool->returnable_thread),
g_list_prepend(tmplist, thread));
ags_thread_add_child(AGS_THREAD(thread_pool->parent),
thread);
ags_connectable_connect(AGS_CONNECTABLE(thread));
g_atomic_int_inc(&(thread_pool->n_threads));
n_threads++;
}
}
pthread_mutex_unlock(thread_pool->creation_mutex);
#ifdef AGS_DEBUG
g_message("ags_thread_pool_creation_thread@loopEND\0");
#endif
}
}
void
ags_soundcard_thread_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsSoundcardThread *soundcard_thread;
soundcard_thread = AGS_SOUNDCARD_THREAD(gobject);
switch(prop_id){
case PROP_SOUNDCARD:
{
GObject *soundcard;
guint samplerate;
guint buffer_size;
soundcard = (GObject *) g_value_get_object(value);
if(soundcard_thread->soundcard != NULL){
g_object_unref(G_OBJECT(soundcard_thread->soundcard));
}
if(soundcard != NULL){
g_object_ref(G_OBJECT(soundcard));
ags_soundcard_get_presets(AGS_SOUNDCARD(soundcard),
NULL,
&samplerate,
&buffer_size,
NULL);
g_object_set(soundcard_thread,
"frequency", ceil((gdouble) samplerate / (gdouble) buffer_size) + AGS_SOUNDCARD_DEFAULT_OVERCLOCK,
NULL);
/* playback */
if(AGS_IS_DEVOUT(soundcard)){
g_atomic_int_or(&(AGS_THREAD(soundcard_thread)->flags),
(AGS_THREAD_INTERMEDIATE_POST_SYNC));
}else if(AGS_IS_JACK_DEVOUT(soundcard) ||
AGS_IS_PULSE_DEVOUT(soundcard)){
g_atomic_int_or(&(AGS_THREAD(soundcard_thread)->flags),
(AGS_THREAD_INTERMEDIATE_POST_SYNC));
}else if(AGS_IS_CORE_AUDIO_DEVOUT(soundcard)){
g_atomic_int_or(&(AGS_THREAD(soundcard_thread)->flags),
(AGS_THREAD_INTERMEDIATE_POST_SYNC));
}
/* capture */
if(AGS_IS_DEVIN(soundcard)){
g_atomic_int_or(&(AGS_THREAD(soundcard_thread)->flags),
(AGS_THREAD_INTERMEDIATE_PRE_SYNC));
}else if(AGS_IS_JACK_DEVIN(soundcard) ||
AGS_IS_PULSE_DEVIN(soundcard)){
g_atomic_int_or(&(AGS_THREAD(soundcard_thread)->flags),
(AGS_THREAD_INTERMEDIATE_PRE_SYNC));
}else if(AGS_IS_CORE_AUDIO_DEVIN(soundcard)){
g_atomic_int_or(&(AGS_THREAD(soundcard_thread)->flags),
(AGS_THREAD_INTERMEDIATE_PRE_SYNC));
}
/* duplex */
//TODO:JK: implement me
}
soundcard_thread->soundcard = G_OBJECT(soundcard);
}
break;
case PROP_SOUNDCARD_CAPABILITY:
{
soundcard_thread->soundcard_capability = g_value_get_uint(value);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
