xmms_playlist_updater_t *
xmms_playlist_updater_init (xmms_playlist_t *playlist)
{
xmms_playlist_updater_t *updater;
updater = xmms_object_new (xmms_playlist_updater_t,
xmms_playlist_updater_destroy);
updater->cond = g_cond_new ();
updater->mutex = g_mutex_new ();
xmms_object_ref (playlist);
updater->playlist = playlist;
updater->updating = NULL;
updater->stack = NULL;
xmms_object_connect (XMMS_OBJECT (playlist),
XMMS_IPC_SIGNAL_COLLECTION_CHANGED,
xmms_playlist_updater_need_update, updater);
xmms_object_connect (XMMS_OBJECT (playlist),
XMMS_IPC_SIGNAL_PLAYLIST_CHANGED,
xmms_playlist_updater_need_update, updater);
xmms_object_connect (XMMS_OBJECT (playlist),
XMMS_IPC_SIGNAL_PLAYLIST_CURRENT_POS,
xmms_playlist_updater_need_update, updater);
xmms_playlist_updater_start (updater);
return updater;
}
xmms_stream_type_t *
xmms_stream_type_parse (va_list ap)
{
xmms_stream_type_t *res;
res = xmms_object_new (xmms_stream_type_t, xmms_stream_type_destroy);
if (!res) {
return NULL;
}
res->priority = -1;
res->name = NULL;
for (;;) {
xmms_stream_type_val_t *val;
xmms_stream_type_key_t key;
key = va_arg (ap, int);
if (key == XMMS_STREAM_TYPE_END)
break;
if (key == XMMS_STREAM_TYPE_NAME) {
res->name = g_strdup (va_arg (ap, char *));
continue;
}
if (key == XMMS_STREAM_TYPE_PRIORITY) {
res->priority = va_arg (ap, int);
continue;
}
/**
* Initializes a new xmms_playlist_t.
*/
xmms_playlist_t *
xmms_playlist_init (xmms_medialib_t *medialib, xmms_coll_dag_t *colldag)
{
xmms_playlist_t *ret;
xmms_config_property_t *val;
ret = xmms_object_new (xmms_playlist_t, xmms_playlist_destroy);
ret->mutex = g_mutex_new ();
xmms_playlist_register_ipc_commands (XMMS_OBJECT (ret));
val = xmms_config_property_register ("playlist.repeat_one", "0",
on_playlist_r_one_changed, ret);
ret->repeat_one = xmms_config_property_get_int (val);
val = xmms_config_property_register ("playlist.repeat_all", "0",
on_playlist_r_all_changed, ret);
ret->repeat_all = xmms_config_property_get_int (val);
xmms_object_ref (medialib);
ret->medialib = medialib;
xmms_object_ref (colldag);
ret->colldag = colldag;
xmms_object_connect (XMMS_OBJECT (ret->medialib),
XMMS_IPC_SIGNAL_MEDIALIB_ENTRY_REMOVED,
on_medialib_entry_removed, ret);
xmms_object_connect (XMMS_OBJECT (ret->colldag),
XMMS_IPC_SIGNAL_COLLECTION_CHANGED,
on_collection_changed, ret);
return ret;
}
xmms_medialib_t *
xmms_medialib_init (void)
{
xmms_config_property_t *cfg;
xmms_medialib_t *medialib;
const gchar *medialib_path;
gchar *path;
const gchar *indices[] = {
XMMS_MEDIALIB_ENTRY_PROPERTY_URL,
XMMS_MEDIALIB_ENTRY_PROPERTY_STATUS,
NULL
};
medialib = xmms_object_new (xmms_medialib_t, xmms_medialib_destroy);
xmms_medialib_register_ipc_commands (XMMS_OBJECT (medialib));
path = XMMS_BUILD_PATH ("medialib.s4");
cfg = xmms_config_property_register ("medialib.path", path, NULL, NULL);
g_free (path);
path = XMMS_BUILD_PATH ("collections", "${uuid}");
xmms_config_property_register ("collection.directory", path, NULL, NULL);
g_free (path);
xmms_config_property_register ("sqlite2s4.path", "sqlite2s4", NULL, NULL);
medialib_path = xmms_config_property_get_string (cfg);
medialib->s4 = xmms_medialib_database_open (medialib_path, indices);
medialib->default_sp = s4_sourcepref_create (xmmsv_default_source_pref);
return medialib;
}
xmms_plugin_t *
xmms_xform_plugin_new (void)
{
xmms_xform_plugin_t *res;
res = xmms_object_new (xmms_xform_plugin_t, destroy);
return (xmms_plugin_t *)res;
}
xmms_xform_object_t *
xmms_xform_object_init (void)
{
xmms_xform_object_t *obj;
obj = xmms_object_new (xmms_xform_object_t, xmms_xform_object_destroy);
xmms_xform_register_ipc_commands (XMMS_OBJECT (obj));
effect_callbacks_init ();
return obj;
}
/**
* Allocate a new #xmms_output_t
*/
xmms_output_t *
xmms_output_new (xmms_output_plugin_t *plugin, xmms_playlist_t *playlist, xmms_medialib_t *medialib)
{
xmms_output_t *output;
xmms_config_property_t *prop;
gint size;
g_return_val_if_fail (playlist, NULL);
XMMS_DBG ("Trying to open output");
output = xmms_object_new (xmms_output_t, xmms_output_destroy);
xmms_object_ref (playlist);
output->playlist = playlist;
xmms_object_ref (medialib);
output->medialib = medialib;
g_mutex_init (&output->status_mutex);
g_mutex_init (&output->playtime_mutex);
prop = xmms_config_property_register ("output.buffersize", "32768", NULL, NULL);
size = xmms_config_property_get_int (prop);
XMMS_DBG ("Using buffersize %d", size);
g_mutex_init (&output->filler_mutex);
output->filler_state = FILLER_STOP;
g_cond_init (&output->filler_state_cond);
output->filler_buffer = xmms_ringbuf_new (size);
output->filler_thread = g_thread_new ("x2 out filler", xmms_output_filler, output);
xmms_config_property_register ("output.flush_on_pause", "1", NULL, NULL);
xmms_playback_register_ipc_commands (XMMS_OBJECT (output));
output->status = XMMS_PLAYBACK_STATUS_STOP;
if (plugin) {
if (!set_plugin (output, plugin)) {
xmms_log_error ("Could not initialize output plugin");
}
} else {
xmms_log_error ("initalized output without a plugin, please fix!");
}
return output;
}
/**
* Initialize the Vis module.
*/
xmms_visualization_t *
xmms_visualization_new (xmms_output_t *output)
{
vis = xmms_object_new (xmms_visualization_t, xmms_visualization_destroy);
g_mutex_init (&vis->clientlock);
vis->clientc = 0;
vis->output = output;
xmms_object_ref (output);
xmms_visualization_register_ipc_commands (XMMS_OBJECT (vis));
xmms_socket_invalidate (&vis->socket);
return vis;
}
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;
}
xmms_sample_converter_t *
xmms_sample_converter_init (xmms_stream_type_t *from, xmms_stream_type_t *to)
{
xmms_sample_converter_t *conv = xmms_object_new (xmms_sample_converter_t, xmms_sample_converter_destroy);
gint fformat, fsamplerate, fchannels;
gint tformat, tsamplerate, tchannels;
fformat = xmms_stream_type_get_int (from, XMMS_STREAM_TYPE_FMT_FORMAT);
fsamplerate = xmms_stream_type_get_int (from, XMMS_STREAM_TYPE_FMT_SAMPLERATE);
fchannels = xmms_stream_type_get_int (from, XMMS_STREAM_TYPE_FMT_CHANNELS);
tformat = xmms_stream_type_get_int (to, XMMS_STREAM_TYPE_FMT_FORMAT);
tsamplerate = xmms_stream_type_get_int (to, XMMS_STREAM_TYPE_FMT_SAMPLERATE);
tchannels = xmms_stream_type_get_int (to, XMMS_STREAM_TYPE_FMT_CHANNELS);
g_return_val_if_fail (tformat != -1, NULL);
g_return_val_if_fail (tchannels != -1, NULL);
g_return_val_if_fail (tsamplerate != -1, NULL);
conv->from = from;
conv->to = to;
conv->resample = fsamplerate != tsamplerate;
conv->func = xmms_sample_conv_get (fchannels, fformat,
tchannels, tformat,
conv->resample);
if (!conv->func) {
xmms_object_unref (conv);
xmms_log_error ("Unable to convert from %s/%d/%d to %s/%d/%d.",
xmms_sample_name_get (fformat), fsamplerate, fchannels,
xmms_sample_name_get (tformat), tsamplerate, tchannels);
return NULL;
}
if (conv->resample)
recalculate_resampler (conv, fsamplerate, tsamplerate);
return conv;
}
xmms_mediainfo_reader_t *
xmms_mediainfo_reader_start (void)
{
xmms_mediainfo_reader_t *mrt;
mrt = xmms_object_new (xmms_mediainfo_reader_t,
xmms_mediainfo_reader_stop);
xmms_ipc_object_register (XMMS_IPC_OBJECT_MEDIAINFO_READER,
XMMS_OBJECT (mrt));
xmms_ipc_broadcast_register (XMMS_OBJECT (mrt),
XMMS_IPC_SIGNAL_MEDIAINFO_READER_STATUS);
xmms_ipc_signal_register (XMMS_OBJECT (mrt),
XMMS_IPC_SIGNAL_MEDIAINFO_READER_UNINDEXED);
mrt->mutex = g_mutex_new ();
mrt->cond = g_cond_new ();
mrt->running = TRUE;
mrt->thread = g_thread_create (xmms_mediainfo_reader_thread, mrt, TRUE, NULL);
return mrt;
}
/**
* The xmms2 daemon main initialisation function
*/
int
main (int argc, char **argv)
{
xmms_output_plugin_t *o_plugin;
xmms_config_property_t *cv;
xmms_main_t *mainobj;
int loglevel = 1;
xmms_playlist_t *playlist;
gchar default_path[XMMS_PATH_MAX + 16], *tmp;
gboolean verbose = FALSE;
gboolean quiet = FALSE;
gboolean version = FALSE;
gboolean nologging = FALSE;
gboolean runasroot = FALSE;
gboolean showhelp = FALSE;
const gchar *outname = NULL;
const gchar *ipcpath = NULL;
gchar *ppath = NULL;
int status_fd = -1;
GOptionContext *context = NULL;
GError *error = NULL;
setlocale (LC_ALL, "");
/**
* The options that the server accepts.
*/
GOptionEntry opts[] = {
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Increase verbosity", NULL},
{"quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet, "Decrease verbosity", NULL},
{"version", 'V', 0, G_OPTION_ARG_NONE, &version, "Print version", NULL},
{"no-logging", 'n', 0, G_OPTION_ARG_NONE, &nologging, "Disable logging", NULL},
{"output", 'o', 0, G_OPTION_ARG_STRING, &outname, "Use 'x' as output plugin", "<x>"},
{"ipc-socket", 'i', 0, G_OPTION_ARG_FILENAME, &ipcpath, "Listen to socket 'url'", "<url>"},
{"plugindir", 'p', 0, G_OPTION_ARG_FILENAME, &ppath, "Search for plugins in directory 'foo'", "<foo>"},
{"conf", 'c', 0, G_OPTION_ARG_FILENAME, &conffile, "Specify alternate configuration file", "<file>"},
{"status-fd", 's', 0, G_OPTION_ARG_INT, &status_fd, "Specify a filedescriptor to write to when started", "fd"},
{"yes-run-as-root", 0, 0, G_OPTION_ARG_NONE, &runasroot, "Give me enough rope to shoot myself in the foot", NULL},
{"show-help", 'h', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &showhelp, "Use --help or -? instead", NULL},
{NULL}
};
/** Check that we are running against the correct glib version */
if (glib_major_version != GLIB_MAJOR_VERSION ||
glib_minor_version < GLIB_MINOR_VERSION) {
g_print ("xmms2d is build against version %d.%d,\n"
"but is (runtime) linked against %d.%d.\n"
"Refusing to start.\n",
GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION,
glib_major_version, glib_minor_version);
exit (EXIT_FAILURE);
}
xmms_signal_block ();
context = g_option_context_new ("- XMMS2 Daemon");
g_option_context_add_main_entries (context, opts, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error) || error) {
g_print ("Error parsing options: %s\n", error->message);
g_clear_error (&error);
exit (EXIT_FAILURE);
}
if (showhelp) {
#if GLIB_CHECK_VERSION(2,14,0)
g_print ("%s", g_option_context_get_help (context, TRUE, NULL));
exit (EXIT_SUCCESS);
#else
g_print ("Please use --help or -? for help\n");
exit (EXIT_FAILURE);
#endif
}
g_option_context_free (context);
if (argc != 1) {
g_print ("There were unknown options, aborting!\n");
exit (EXIT_FAILURE);
}
if (xmms_checkroot ()) {
if (runasroot) {
g_print ("***************************************\n");
g_print ("Warning! You are running XMMS2D as root, this is a bad idea!\nBut I'll allow it since you asked nicely.\n");
g_print ("***************************************\n\n");
} else {
g_print ("PLEASE DON'T RUN XMMS2D AS ROOT!\n\n(if you really must, read the help)\n");
exit (EXIT_FAILURE);
}
}
if (verbose) {
loglevel++;
} else if (quiet) {
loglevel--;
}
if (version) {
print_version ();
}
g_thread_init (NULL);
g_random_set_seed (time (NULL));
xmms_log_init (loglevel);
xmms_ipc_init ();
load_config ();
cv = xmms_config_property_register ("core.logtsfmt",
"%H:%M:%S ",
NULL, NULL);
xmms_log_set_format (xmms_config_property_get_string (cv));
xmms_fallback_ipcpath_get (default_path, sizeof (default_path));
cv = xmms_config_property_register ("core.ipcsocket",
default_path,
on_config_ipcsocket_change,
NULL);
if (!ipcpath) {
/*
* if not ipcpath is specifed on the cmd line we
* grab it from the config
*/
ipcpath = xmms_config_property_get_string (cv);
}
if (!xmms_ipc_setup_server (ipcpath)) {
xmms_ipc_shutdown ();
xmms_log_fatal ("IPC failed to init!");
}
if (!xmms_plugin_init (ppath)) {
return 1;
}
playlist = xmms_playlist_init ();
xform_obj = xmms_xform_object_init ();
bindata_obj = xmms_bindata_init ();
mainobj = xmms_object_new (xmms_main_t, xmms_main_destroy);
/* find output plugin. */
cv = xmms_config_property_register ("output.plugin",
XMMS_OUTPUT_DEFAULT,
change_output, mainobj);
if (outname) {
xmms_config_property_set_data (cv, outname);
}
outname = xmms_config_property_get_string (cv);
xmms_log_info ("Using output plugin: %s", outname);
o_plugin = (xmms_output_plugin_t *)xmms_plugin_find (XMMS_PLUGIN_TYPE_OUTPUT, outname);
if (!o_plugin) {
xmms_log_error ("Baaaaad output plugin, try to change the"
"output.plugin config variable to something usefull");
}
mainobj->output = xmms_output_new (o_plugin, playlist);
if (!mainobj->output) {
xmms_log_fatal ("Failed to create output object!");
}
mainobj->vis = xmms_visualization_new (mainobj->output);
if (status_fd != -1) {
write (status_fd, "+", 1);
}
xmms_signal_init (XMMS_OBJECT (mainobj));
xmms_ipc_object_register (XMMS_IPC_OBJECT_MAIN,
XMMS_OBJECT (mainobj));
xmms_ipc_broadcast_register (XMMS_OBJECT (mainobj),
XMMS_IPC_SIGNAL_QUIT);
xmms_object_cmd_add (XMMS_OBJECT (mainobj),
XMMS_IPC_CMD_QUIT,
XMMS_CMD_FUNC (quit));
xmms_object_cmd_add (XMMS_OBJECT (mainobj),
XMMS_IPC_CMD_HELLO,
XMMS_CMD_FUNC (hello));
xmms_object_cmd_add (XMMS_OBJECT (mainobj),
XMMS_IPC_CMD_PLUGIN_LIST,
XMMS_CMD_FUNC (plugin_list));
xmms_object_cmd_add (XMMS_OBJECT (mainobj),
XMMS_IPC_CMD_STATS,
XMMS_CMD_FUNC (stats));
/* Save the time we started in order to count uptime */
mainobj->starttime = time (NULL);
/* Dirty hack to tell XMMS_PATH a valid path */
g_strlcpy (default_path, ipcpath, sizeof (default_path));
tmp = strchr (default_path, ';');
if (tmp) {
*tmp = '\0';
}
g_setenv ("XMMS_PATH", default_path, TRUE);
/* Also put the full path for clients that understands */
g_setenv("XMMS_PATH_FULL", ipcpath, TRUE);
tmp = XMMS_BUILD_PATH ("shutdown.d");
cv = xmms_config_property_register ("core.shutdownpath",
tmp, NULL, NULL);
g_free (tmp);
tmp = XMMS_BUILD_PATH ("startup.d");
cv = xmms_config_property_register ("core.startuppath",
tmp, NULL, NULL);
g_free (tmp);
/* Startup dir */
do_scriptdir (xmms_config_property_get_string (cv), "start");
mainloop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (mainloop);
return 0;
}
/**
* Allocate a new #xmms_output_t
*/
xmms_output_t *
xmms_output_new (xmms_output_plugin_t *plugin, xmms_playlist_t *playlist)
{
xmms_output_t *output;
xmms_config_property_t *prop;
gint size;
g_return_val_if_fail (playlist, NULL);
XMMS_DBG ("Trying to open output");
output = xmms_object_new (xmms_output_t, xmms_output_destroy);
output->playlist = playlist;
output->status_mutex = g_mutex_new ();
output->playtime_mutex = g_mutex_new ();
prop = xmms_config_property_register ("output.buffersize", "32768", NULL, NULL);
size = xmms_config_property_get_int (prop);
XMMS_DBG ("Using buffersize %d", size);
output->filler_mutex = g_mutex_new ();
output->filler_state = FILLER_STOP;
output->filler_state_cond = g_cond_new ();
output->filler_buffer = xmms_ringbuf_new (size);
output->filler_thread = g_thread_create (xmms_output_filler, output, TRUE, NULL);
xmms_config_property_register ("output.flush_on_pause", "1", NULL, NULL);
xmms_ipc_object_register (XMMS_IPC_OBJECT_OUTPUT, XMMS_OBJECT (output));
/* Broadcasts are always transmitted to the client if he
* listens to them. */
xmms_ipc_broadcast_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_OUTPUT_VOLUME_CHANGED);
xmms_ipc_broadcast_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_STATUS);
xmms_ipc_broadcast_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_OUTPUT_CURRENTID);
/* Signals are only emitted if the client has a pending question to it
* after the client recivies a signal, he must ask for it again */
xmms_ipc_signal_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_OUTPUT_PLAYTIME);
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_START,
XMMS_CMD_FUNC (start));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_STOP,
XMMS_CMD_FUNC (stop));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_PAUSE,
XMMS_CMD_FUNC (pause));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_DECODER_KILL,
XMMS_CMD_FUNC (xform_kill));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_CPLAYTIME,
XMMS_CMD_FUNC (playtime));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKMS,
XMMS_CMD_FUNC (seekms));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKMS_REL,
XMMS_CMD_FUNC (seekms_rel));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKSAMPLES,
XMMS_CMD_FUNC (seeksamples));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKSAMPLES_REL,
XMMS_CMD_FUNC (seeksamples_rel));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_OUTPUT_STATUS,
XMMS_CMD_FUNC (output_status));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_CURRENTID,
XMMS_CMD_FUNC (currentid));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_VOLUME_SET,
XMMS_CMD_FUNC (volume_set));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_VOLUME_GET,
XMMS_CMD_FUNC (volume_get));
output->status = XMMS_PLAYBACK_STATUS_STOP;
if (plugin) {
if (!set_plugin (output, plugin)) {
xmms_log_error ("Could not initialize output plugin");
}
} else {
xmms_log_error ("initalized output without a plugin, please fix!");
}
return output;
}
