/**
* @internal
*/
static gboolean
xmms_output_format_set (xmms_output_t *output, xmms_stream_type_t *fmt)
{
g_return_val_if_fail (output, FALSE);
g_return_val_if_fail (fmt, FALSE);
XMMS_DBG ("Setting format!");
if (!xmms_output_plugin_format_set_always (output->plugin)) {
if (output->format && xmms_stream_type_match (output->format, fmt)) {
XMMS_DBG ("audio formats are equal, not updating");
return TRUE;
}
xmms_object_unref (output->format);
xmms_object_ref (fmt);
output->format = fmt;
return xmms_output_plugin_method_format_set (output->plugin, output, output->format);
} else {
if (output->format && !xmms_stream_type_match (output->format, fmt)) {
xmms_object_unref (output->format);
xmms_object_ref (fmt);
output->format = fmt;
}
if (!output->format) {
xmms_object_unref (output->format);
xmms_object_ref (fmt);
output->format = fmt;
}
return xmms_output_plugin_method_format_set (output->plugin, output, output->format);
}
}
static void
xmms_xform_destroy (xmms_object_t *object)
{
xmms_xform_t *xform = (xmms_xform_t *)object;
XMMS_DBG ("Freeing xform '%s'", xmms_xform_shortname (xform));
/* The 'destroy' method is not mandatory */
if (xform->plugin && xform->inited) {
if (xmms_xform_plugin_can_destroy (xform->plugin)) {
xmms_xform_plugin_destroy (xform->plugin, xform);
}
}
g_hash_table_destroy (xform->metadata);
g_hash_table_destroy (xform->privdata);
g_queue_free (xform->hotspots);
g_free (xform->buffer);
xmms_object_unref (xform->out_type);
xmms_object_unref (xform->plugin);
if (xform->prev) {
xmms_object_unref (xform->prev);
}
}
static void
xmms_output_destroy (xmms_object_t *object)
{
xmms_output_t *output = (xmms_output_t *)object;
output->monitor_volume_running = FALSE;
if (output->monitor_volume_thread) {
g_thread_join (output->monitor_volume_thread);
output->monitor_volume_thread = NULL;
}
xmms_output_filler_state (output, FILLER_QUIT);
g_thread_join (output->filler_thread);
if (output->plugin) {
xmms_output_plugin_method_destroy (output->plugin, output);
xmms_object_unref (output->plugin);
}
xmms_object_unref (output->playlist);
g_mutex_free (output->status_mutex);
g_mutex_free (output->playtime_mutex);
g_mutex_free (output->filler_mutex);
g_cond_free (output->filler_state_cond);
xmms_ringbuf_destroy (output->filler_buffer);
xmms_ipc_broadcast_unregister ( XMMS_IPC_SIGNAL_OUTPUT_VOLUME_CHANGED);
xmms_ipc_broadcast_unregister ( XMMS_IPC_SIGNAL_PLAYBACK_STATUS);
xmms_ipc_broadcast_unregister ( XMMS_IPC_SIGNAL_OUTPUT_CURRENTID);
xmms_ipc_signal_unregister (XMMS_IPC_SIGNAL_OUTPUT_PLAYTIME);
xmms_ipc_object_unregister (XMMS_IPC_OBJECT_OUTPUT);
}
static void
xmms_output_destroy (xmms_object_t *object)
{
xmms_output_t *output = (xmms_output_t *)object;
XMMS_DBG ("Deactivating output object.");
output->monitor_volume_running = FALSE;
if (output->monitor_volume_thread) {
g_thread_join (output->monitor_volume_thread);
output->monitor_volume_thread = NULL;
}
xmms_output_filler_state (output, FILLER_QUIT);
g_thread_join (output->filler_thread);
if (output->plugin) {
xmms_output_plugin_method_destroy (output->plugin, output);
xmms_object_unref (output->plugin);
}
xmms_output_format_list_clear (output);
xmms_object_unref (output->playlist);
xmms_object_unref (output->medialib);
g_mutex_clear (&output->status_mutex);
g_mutex_clear (&output->playtime_mutex);
g_mutex_clear (&output->filler_mutex);
g_cond_clear (&output->filler_state_cond);
xmms_ringbuf_destroy (output->filler_buffer);
xmms_playback_unregister_ipc_commands ();
}
/**
* @internal Destroy the main object
* @param[in] object The object to destroy
*/
static void
xmms_main_destroy (xmms_object_t *object)
{
xmms_main_t *mainobj = (xmms_main_t *) object;
xmms_config_property_t *cv;
cv = xmms_config_lookup ("core.shutdownpath");
do_scriptdir (xmms_config_property_get_string (cv), "stop");
xmms_object_unref (mainobj->xform_object);
xmms_object_unref (mainobj->visualization_object);
xmms_object_unref (mainobj->output_object);
xmms_object_unref (mainobj->bindata_object);
xmms_object_unref (mainobj->playlist_object);
xmms_object_unref (mainobj->colldag_object);
xmms_object_unref (mainobj->medialib_object);
xmms_object_unref (mainobj->mediainfo_object);
xmms_object_unref (mainobj->plsupdater_object);
xmms_object_unref (mainobj->collsync_object);
xmms_config_save ();
xmms_config_shutdown ();
xmms_plugin_shutdown ();
xmms_main_unregister_ipc_commands ();
xmms_ipc_shutdown ();
xmms_log_shutdown ();
}
/**
* @internal Destroy the main object
* @param[in] object The object to destroy
*/
static void
xmms_main_destroy (xmms_object_t *object)
{
xmms_main_t *mainobj = (xmms_main_t *) object;
xmms_object_cmd_arg_t arg;
xmms_config_property_t *cv;
cv = xmms_config_lookup ("core.shutdownpath");
do_scriptdir (xmms_config_property_get_string (cv), "stop");
/* stop output */
xmms_object_cmd_arg_init (&arg);
xmms_object_cmd_call (XMMS_OBJECT (mainobj->output),
XMMS_IPC_CMD_STOP, &arg);
g_usleep (G_USEC_PER_SEC); /* wait for the output thread to end */
xmms_object_unref (mainobj->vis);
xmms_object_unref (mainobj->output);
xmms_object_unref (xform_obj);
xmms_config_save ();
xmms_config_shutdown ();
xmms_plugin_shutdown ();
xmms_ipc_object_unregister (XMMS_IPC_OBJECT_MAIN);
xmms_ipc_shutdown ();
xmms_log_shutdown ();
}
static void
xmms_playlist_destroy (xmms_object_t *object)
{
xmms_config_property_t *val;
xmms_playlist_t *playlist = (xmms_playlist_t *) object;
XMMS_DBG ("Deactivating playlist object");
g_return_if_fail (playlist);
val = xmms_config_lookup ("playlist.repeat_one");
xmms_config_property_callback_remove (val, on_playlist_r_one_changed, playlist);
val = xmms_config_lookup ("playlist.repeat_all");
xmms_config_property_callback_remove (val, on_playlist_r_all_changed, playlist);
xmms_object_disconnect (XMMS_OBJECT (playlist->medialib),
XMMS_IPC_SIGNAL_MEDIALIB_ENTRY_REMOVED,
on_medialib_entry_removed, playlist);
xmms_object_disconnect (XMMS_OBJECT (playlist->colldag),
XMMS_IPC_SIGNAL_COLLECTION_CHANGED,
on_collection_changed, playlist);
xmms_object_unref (playlist->colldag);
xmms_object_unref (playlist->medialib);
g_mutex_free (playlist->mutex);
xmms_playlist_unregister_ipc_commands ();
}
CLEANUP () {
xmms_object_unref (playlist);
xmms_object_unref (colldag);
xmms_object_unref (medialib);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
return 0;
}
CLEANUP ()
{
xmms_object_unref (medialib);
xmms_object_unref (xform_object);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
return 0;
}
CLEANUP () {
xmms_object_unref (medialib); medialib = NULL;
xmms_object_unref (dag); dag = NULL;
xmms_config_shutdown ();
xmms_ipc_shutdown ();
return 0;
}
/**
* @internal Shut down the plugin system. This function unrefs all the plugins
* loaded.
*/
void
xmms_plugin_shutdown ()
{
#ifdef HAVE_VALGRIND
/* print out a leak summary at this point, because the final leak
* summary won't include proper backtraces of leaks found in
* plugins, since we close the so's here.
*
* note: the following call doesn't do anything if we're not run
* in valgrind
*/
VALGRIND_DO_LEAK_CHECK
;
#endif
while (xmms_plugin_list) {
xmms_plugin_t *p = xmms_plugin_list->data;
/* if this plugin's refcount is > 1, then there's a bug
* in one of the other subsystems
*/
if (p->object.ref > 1) {
XMMS_DBG ("%s's refcount is %i",
p->name, p->object.ref);
}
xmms_object_unref (p);
xmms_plugin_list = g_list_delete_link (xmms_plugin_list,
xmms_plugin_list);
}
}
static void
song_changed_arg_free (void *data)
{
xmms_output_song_changed_arg_t *arg = (xmms_output_song_changed_arg_t *)data;
xmms_object_unref (arg->chain);
g_free (arg);
}
static void
run_performance_tests (xmmsv_t *databases, xmmsv_t *testcases, gint format)
{
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (databases, &it);
while (xmmsv_list_iter_valid (it)) {
xmms_medialib_t *medialib;
const gchar *filename;
xmmsv_list_iter_entry_string (it, &filename);
if (format == FORMAT_PRETTY)
g_print ("Running suite with: %s\n", filename);
xmms_ipc_init ();
xmms_config_init ("memory://");
xmms_config_property_register ("medialib.path", filename, NULL, NULL);
medialib = xmms_medialib_init ();
if (medialib == NULL) {
g_print ("Could not open database: %s (%d)\n", filename, s4_errno ());
exit (EXIT_FAILURE);
}
run_tests (medialib, testcases, run_performance_test, format, filename);
xmms_object_unref (medialib);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
xmmsv_list_iter_next (it);
}
}
static void
xmms_xform_effect_properties_update (xmms_object_t *object, xmmsv_t *data, gpointer udata)
{
xmms_config_property_t *cfg = (xmms_config_property_t *) object;
xmms_xform_plugin_t *plugin;
const gchar *name;
gchar key[64];
gint effect_no = GPOINTER_TO_INT (udata);
name = xmms_config_property_get_string (cfg);
if (!name[0]) {
return;
}
plugin = xmms_xform_find_plugin (name);
if (!plugin) {
xmms_log_error ("Couldn't find any effect named '%s'", name);
} else {
xmms_xform_plugin_config_property_register (plugin, "enabled",
"1", NULL, NULL);
xmms_object_unref (plugin);
}
/* setup new effect.order.n */
g_snprintf (key, sizeof (key), "effect.order.%i", effect_no + 1);
if (!xmms_config_lookup (key)) {
xmms_config_property_register (key, "", xmms_xform_effect_properties_update,
GINT_TO_POINTER (effect_no + 1));
}
}
static gboolean
xmms_converter_plugin_init (xmms_xform_t *xform)
{
xmms_conv_xform_data_t *data;
xmms_sample_converter_t *conv;
xmms_stream_type_t *intype;
xmms_stream_type_t *to;
const GList *goal_hints;
intype = xmms_xform_intype_get (xform);
goal_hints = xmms_xform_goal_hints_get (xform);
to = xmms_stream_type_coerce (intype, goal_hints);
if (!to) {
return FALSE;
}
conv = xmms_sample_converter_init (intype, to);
if (!conv) {
return FALSE;
}
xmms_xform_outdata_type_set (xform, to);
xmms_object_unref (to);
data = g_new0 (xmms_conv_xform_data_t, 1);
data->conv = conv;
xmms_xform_private_data_set (xform, data);
return TRUE;
}
static void
update_effect_properties (xmms_object_t *object, xmmsv_t *data,
gpointer userdata)
{
gint effect_no = GPOINTER_TO_INT (userdata);
const gchar *name;
xmms_config_property_t *cfg;
xmms_xform_plugin_t *xform_plugin;
xmms_plugin_t *plugin;
gchar key[64];
name = xmms_config_property_get_string ((xmms_config_property_t *) object);
if (name[0]) {
plugin = xmms_plugin_find (XMMS_PLUGIN_TYPE_XFORM, name);
if (!plugin) {
xmms_log_error ("Couldn't find any effect named '%s'", name);
} else {
xform_plugin = (xmms_xform_plugin_t *) plugin;
xmms_xform_plugin_config_property_register (xform_plugin, "enabled",
"1", NULL, NULL);
xmms_object_unref (plugin);
}
/* setup new effect.order.n */
g_snprintf (key, sizeof (key), "effect.order.%i", effect_no + 1);
cfg = xmms_config_lookup (key);
if (!cfg) {
xmms_config_property_register (key, "", update_effect_properties,
GINT_TO_POINTER (effect_no + 1));
}
}
}
/**
* Switch to another output plugin.
* @param output output pointer
* @param new_plugin the new #xmms_plugin_t to use as output.
* @returns TRUE on success and FALSE on failure
*/
gboolean
xmms_output_plugin_switch (xmms_output_t *output, xmms_output_plugin_t *new_plugin)
{
xmms_output_plugin_t *old_plugin;
gboolean ret;
g_return_val_if_fail (output, FALSE);
g_return_val_if_fail (new_plugin, FALSE);
xmms_output_stop (output, NULL);
g_mutex_lock (output->status_mutex);
old_plugin = output->plugin;
ret = set_plugin (output, new_plugin);
/* if the switch succeeded, release the reference to the old plugin
* now.
* if we couldn't switch to the new plugin, but we had a working
* plugin before, switch back to the old plugin.
*/
if (ret) {
xmms_object_unref (old_plugin);
} else if (old_plugin) {
XMMS_DBG ("cannot switch plugin, going back to old one");
set_plugin (output, old_plugin);
}
g_mutex_unlock (output->status_mutex);
return ret;
}
static gboolean
kill_server (gpointer object) {
xmms_object_emit_f (XMMS_OBJECT (object),
XMMS_IPC_SIGNAL_QUIT,
XMMSV_TYPE_INT32,
time (NULL)-((xmms_main_t*)object)->starttime);
xmms_object_unref (object);
exit (EXIT_SUCCESS);
}
static void
xmms_output_format_list_free_elem (gpointer data, gpointer user_data)
{
xmms_stream_type_t *f;
g_return_if_fail (data);
f = data;
xmms_object_unref (f);
}
GList *
xmms_xform_browse (const gchar *url, xmms_error_t *error)
{
GList *list = NULL;
gchar *durl;
xmms_xform_t *xform = NULL;
xmms_xform_t *xform2 = NULL;
xform = xmms_xform_new (NULL, NULL, 0, NULL);
durl = g_strdup (url);
xmms_medialib_decode_url (durl);
XMMS_DBG ("url = %s", durl);
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"application/x-url",
XMMS_STREAM_TYPE_URL,
durl,
XMMS_STREAM_TYPE_END);
xform2 = xmms_xform_find (xform, 0, NULL);
if (xform2) {
XMMS_DBG ("found xform %s", xmms_xform_shortname (xform2));
} else {
xmms_error_set (error, XMMS_ERROR_GENERIC, "Couldn't handle that URL");
xmms_object_unref (xform);
g_free (durl);
return NULL;
}
list = xmms_xform_browse_method (xform2, durl, error);
xmms_object_unref (xform);
xmms_object_unref (xform2);
g_free (durl);
return list;
}
static gboolean
kill_server (gpointer object) {
xmms_main_t *mainobj = (xmms_main_t *) object;
gint uptime = time (NULL) - mainobj->starttime;
xmms_object_emit (XMMS_OBJECT (object),
XMMS_IPC_SIGNAL_QUIT,
xmmsv_new_int (uptime));
xmms_object_unref (object);
exit (EXIT_SUCCESS);
}
static xmms_xform_t *
xmms_xform_new_effect (xmms_xform_t *last, xmms_medialib_entry_t entry,
GList *goal_formats, const gchar *name)
{
xmms_plugin_t *plugin;
xmms_xform_plugin_t *xform_plugin;
xmms_xform_t *xform;
gint priority;
plugin = xmms_plugin_find (XMMS_PLUGIN_TYPE_XFORM, name);
if (!plugin) {
xmms_log_error ("Couldn't find any effect named '%s'", name);
return last;
}
xform_plugin = (xmms_xform_plugin_t *) plugin;
if (!xmms_xform_plugin_supports (xform_plugin, last->out_type, &priority)) {
xmms_log_info ("Effect '%s' doesn't support format, skipping",
xmms_plugin_shortname_get (plugin));
xmms_object_unref (plugin);
return last;
}
xform = xmms_xform_new (xform_plugin, last, entry, goal_formats);
if (xform) {
xmms_object_unref (last);
last = xform;
} else {
xmms_log_info ("Effect '%s' failed to initialize, skipping",
xmms_plugin_shortname_get (plugin));
}
xmms_xform_plugin_config_property_register (xform_plugin,
"enabled", "0",
NULL, NULL);
xmms_object_unref (plugin);
return last;
}
xmms_xform_t *
xmms_xform_chain_setup_url_session (xmms_medialib_t *medialib,
xmms_medialib_session_t *session,
xmms_medialib_entry_t entry, const gchar *url,
GList *goal_formats, gboolean rehash)
{
xmms_xform_t *last;
xmms_plugin_t *plugin;
xmms_xform_plugin_t *xform_plugin;
gboolean add_segment = FALSE;
gint priority;
last = chain_setup (medialib, entry, url, goal_formats);
if (!last) {
return NULL;
}
/* first check that segment plugin is available in the system */
plugin = xmms_plugin_find (XMMS_PLUGIN_TYPE_XFORM, "segment");
xform_plugin = (xmms_xform_plugin_t *) plugin;
/* if segment plugin input is the same as current output, include it
* for collecting additional duration metadata on audio entries */
if (xform_plugin) {
add_segment = xmms_xform_plugin_supports (xform_plugin,
last->out_type,
&priority);
xmms_object_unref (plugin);
}
/* add segment plugin to the chain if it can be added */
if (add_segment) {
last = xmms_xform_new_effect (last, entry, goal_formats, "segment");
if (!last) {
return NULL;
}
}
/* if not rehashing, also initialize all the effect plugins */
if (!rehash) {
last = add_effects (last, entry, goal_formats);
if (!last) {
return NULL;
}
}
chain_finalize (session, last, entry, url, rehash);
return last;
}
static void
xmms_converter_plugin_destroy (xmms_xform_t *xform)
{
xmms_conv_xform_data_t *data;
data = xmms_xform_private_data_get (xform);
if (data) {
if (data->conv) {
xmms_object_unref (data->conv);
}
g_free (data);
}
}
static void
xmms_medialib_session_free (xmms_medialib_session_t *session)
{
xmms_object_unref (session->medialib);
if (session->added != NULL)
g_hash_table_unref (session->added);
if (session->updated != NULL)
g_hash_table_unref (session->updated);
if (session->removed != NULL)
g_hash_table_unref (session->removed);
if (session->vals != NULL)
xmmsv_unref (session->vals);
g_free (session);
}
xmms_xform_t *
xmms_xform_chain_setup (xmms_medialib_t *medialib, xmms_medialib_entry_t entry,
GList *goal_formats, gboolean rehash)
{
xmms_medialib_session_t *session;
xmms_xform_t *ret = NULL;
do {
session = xmms_medialib_session_begin (medialib);
if (ret != NULL)
xmms_object_unref (ret);
ret = xmms_xform_chain_setup_session (medialib, session, entry, goal_formats, rehash);
} while (!xmms_medialib_session_commit (session));
return ret;
}
static void
effect_callbacks_init (void)
{
gint effect_no;
xmms_config_property_t *cfg;
xmms_xform_plugin_t *xform_plugin;
xmms_plugin_t *plugin;
gchar key[64];
const gchar *name;
for (effect_no = 0; ; effect_no++) {
g_snprintf (key, sizeof (key), "effect.order.%i", effect_no);
cfg = xmms_config_lookup (key);
if (!cfg) {
break;
}
xmms_config_property_callback_set (cfg, update_effect_properties,
GINT_TO_POINTER (effect_no));
name = xmms_config_property_get_string (cfg);
if (!name[0]) {
continue;
}
plugin = xmms_plugin_find (XMMS_PLUGIN_TYPE_XFORM, name);
if (!plugin) {
xmms_log_error ("Couldn't find any effect named '%s'", name);
continue;
}
xform_plugin = (xmms_xform_plugin_t *) plugin;
xmms_xform_plugin_config_property_register (xform_plugin, "enabled",
"1", NULL, NULL);
xmms_object_unref (plugin);
}
/* the name stored in the last present property was not "" or there was no
last present property */
if ((!effect_no) || name[0]) {
xmms_config_property_register (key, "", update_effect_properties,
GINT_TO_POINTER (effect_no));
}
}
static void
destroy (xmms_object_t *obj)
{
xmms_xform_plugin_t *plugin = (xmms_xform_plugin_t *) obj;
while (plugin->in_types) {
xmms_object_unref (plugin->in_types->data);
plugin->in_types = g_list_delete_link (plugin->in_types,
plugin->in_types);
}
if (plugin->metadata_mapper != NULL) {
g_hash_table_unref (plugin->metadata_mapper);
}
xmms_plugin_destroy ((xmms_plugin_t *) obj);
}
xmms_xform_t *
xmms_xform_new (xmms_xform_plugin_t *plugin, xmms_xform_t *prev,
xmms_medialib_t *medialib, xmms_medialib_entry_t entry,
GList *goal_hints)
{
xmms_xform_t *xform;
xform = xmms_object_new (xmms_xform_t, xmms_xform_destroy);
xmms_object_ref (plugin);
xform->plugin = plugin;
xform->entry = entry;
xform->medialib = medialib;
xform->goal_hints = goal_hints;
xform->lr.bufend = &xform->lr.buf[0];
if (prev) {
xmms_object_ref (prev);
xform->prev = prev;
}
xform->metadata = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify) xmmsv_unref);
xform->privdata = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify) xmmsv_unref);
xform->hotspots = g_queue_new ();
if (plugin && entry) {
if (!xmms_xform_plugin_init (xform->plugin, xform)) {
xmms_object_unref (xform);
return NULL;
}
xform->inited = TRUE;
g_return_val_if_fail (xform->out_type, NULL);
}
xform->buffer = g_malloc (READ_CHUNK);
xform->buffersize = READ_CHUNK;
return xform;
}
static gboolean
xmms_output_status_set (xmms_output_t *output, gint status)
{
gboolean ret = TRUE;
if (!output->plugin) {
XMMS_DBG ("No plugin to set status on..");
return FALSE;
}
g_mutex_lock (output->status_mutex);
if (output->status != status) {
if (status == XMMS_PLAYBACK_STATUS_PAUSE &&
output->status != XMMS_PLAYBACK_STATUS_PLAY) {
XMMS_DBG ("Can only pause from play.");
ret = FALSE;
} else {
output->status = status;
if (status == XMMS_PLAYBACK_STATUS_STOP) {
xmms_object_unref (output->format);
output->format = NULL;
}
if (!xmms_output_plugin_method_status (output->plugin, output, status)) {
xmms_log_error ("Status method returned an error!");
output->status = XMMS_PLAYBACK_STATUS_STOP;
ret = FALSE;
}
xmms_object_emit_f (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_STATUS,
XMMSV_TYPE_UINT32,
output->status);
}
}
g_mutex_unlock (output->status_mutex);
return ret;
}
