static void
xmms_ipc_register_signal (xmms_ipc_client_t *client,
xmms_ipc_msg_t *msg, xmmsv_t *arguments)
{
xmmsv_t *arg;
gint32 signalid;
int r;
if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {
xmms_log_error ("No signalid in this msg?!");
return;
}
r = xmmsv_get_int (arg, &signalid);
if (!r) {
xmms_log_error ("Cannot extract signal id from value");
return;
}
if (signalid < 0 || signalid >= XMMS_IPC_SIGNAL_END) {
xmms_log_error ("Bad signal id (%d)", signalid);
return;
}
g_mutex_lock (client->lock);
client->pendingsignals[signalid] = xmms_ipc_msg_get_cookie (msg);
g_mutex_unlock (client->lock);
}
static gint
xmms_faad_read_some (xmms_xform_t *xform, xmms_error_t *err)
{
xmms_faad_data_t *data;
NeAACDecFrameInfo frameInfo;
gpointer sample_buffer;
guint bytes_read = 0;
g_return_val_if_fail (xform, -1);
data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, -1);
while (data->outbuf->len == 0) {
gboolean need_read;
/* MP4 demuxer always gives full packets so we need different handling */
if (data->filetype == FAAD_TYPE_MP4)
need_read = (data->buffer_length == 0);
else
need_read = (data->buffer_length < data->buffer_size);
if (need_read) {
bytes_read = xmms_xform_read (xform,
(gchar *) data->buffer + data->buffer_length,
data->buffer_size - data->buffer_length,
err);
if (bytes_read <= 0 && data->buffer_length == 0) {
XMMS_DBG ("EOF");
return 0;
}
data->buffer_length += bytes_read;
}
sample_buffer = NeAACDecDecode (data->decoder, &frameInfo, data->buffer,
data->buffer_length);
g_memmove (data->buffer, data->buffer + frameInfo.bytesconsumed,
data->buffer_length - frameInfo.bytesconsumed);
data->buffer_length -= frameInfo.bytesconsumed;
bytes_read = frameInfo.samples * xmms_sample_size_get (data->sampleformat);
if (bytes_read > 0 && frameInfo.error == 0) {
if (data->samplerate != frameInfo.samplerate ||
data->channels != frameInfo.channels) {
/* We should inform output to change parameters somehow */
xmms_log_error ("Output format changed in the middle of a read!");
data->samplerate = frameInfo.samplerate;
data->channels = frameInfo.channels;
}
g_string_append_len (data->outbuf, sample_buffer, bytes_read);
} else if (frameInfo.error > 0) {
xmms_log_error ("ERROR %d in faad decoding: %s", frameInfo.error,
NeAACDecGetErrorMessage (frameInfo.error));
return -1;
}
}
return data->outbuf->len;
}
static void
xmms_ipc_register_broadcast (xmms_ipc_client_t *client,
xmms_ipc_msg_t *msg, xmmsv_t *arguments)
{
xmmsv_t *arg;
gint32 broadcastid;
int r;
if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {
xmms_log_error ("No broadcastid in this msg?!");
return;
}
r = xmmsv_get_int (arg, &broadcastid);
if (!r) {
xmms_log_error ("Cannot extract broadcast id from value");
return;
}
if (broadcastid < 0 || broadcastid >= XMMS_IPC_SIGNAL_END) {
xmms_log_error ("Bad broadcast id (%d)", broadcastid);
return;
}
g_mutex_lock (client->lock);
client->broadcasts[broadcastid] =
g_list_append (client->broadcasts[broadcastid],
GUINT_TO_POINTER (xmms_ipc_msg_get_cookie (msg)));
g_mutex_unlock (client->lock);
}
gboolean
xmms_magic_add (const gchar *desc, const gchar *mime, ...)
{
GNode *tree, *node = NULL;
va_list ap;
gchar *s;
gpointer *root_props;
gboolean ret = TRUE;
g_return_val_if_fail (desc, FALSE);
g_return_val_if_fail (mime, FALSE);
/* now process the magic specs in the argument list */
va_start (ap, mime);
s = va_arg (ap, gchar *);
if (!s) { /* no magic specs passed -> failure */
va_end (ap);
return FALSE;
}
/* root node stores the description and the mimetype */
root_props = g_new0 (gpointer, 2);
root_props[0] = g_strdup (desc);
root_props[1] = g_strdup (mime);
tree = g_node_new (root_props);
do {
if (!*s) {
ret = FALSE;
xmms_log_error ("invalid magic spec: '%s'", s);
break;
}
s = g_strdup (s); /* we need our own copy */
node = xmms_magic_add_node (tree, s, node);
if (!node) {
xmms_log_error ("invalid magic spec: '%s'", s);
ret = FALSE;
g_free (s);
break;
}
g_free (s);
} while ((s = va_arg (ap, gchar *)));
va_end (ap);
/* only add this tree to the list if all spec chunks are valid */
if (ret) {
magic_list =
g_list_insert_sorted (magic_list, tree,
(GCompareFunc) cb_sort_magic_list);
} else {
xmms_magic_tree_free (tree);
}
return ret;
}
/*
* Member functions
*/
static gboolean
xmms_samba_init (xmms_xform_t *xform)
{
xmms_samba_data_t *data;
const gchar *url;
const gchar *metakey;
struct stat st;
gint fd, err;
g_return_val_if_fail (xform, FALSE);
url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL);
g_return_val_if_fail (url, FALSE);
G_LOCK (mutex);
err = smbc_stat (url, &st);
G_UNLOCK (mutex);
if (err < 0) {
xmms_log_error ("%s", strerror (errno));
return FALSE;
}
if (!S_ISREG (st.st_mode)) {
xmms_log_error ("%s is not a regular file.", url);
return FALSE;
}
G_LOCK (mutex);
fd = smbc_open (url, O_RDONLY | O_NONBLOCK, 0);
G_UNLOCK (mutex);
if (fd == -1) {
xmms_log_error ("%s", strerror (errno));
return FALSE;
}
data = g_new0 (xmms_samba_data_t, 1);
data->fd = fd;
xmms_xform_private_data_set (xform, data);
xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE,
"application/octet-stream",
XMMS_STREAM_TYPE_END);
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE;
xmms_xform_metadata_set_int (xform, metakey, st.st_size);
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_LMOD;
xmms_xform_metadata_set_int (xform, metakey, st.st_mtime);
return TRUE;
}
static gboolean
xmms_samba_plugin_setup (xmms_xform_plugin_t *xform_plugin)
{
xmms_xform_methods_t methods;
gint err;
XMMS_XFORM_METHODS_INIT (methods);
methods.init = xmms_samba_init;
methods.destroy = xmms_samba_destroy;
methods.read = xmms_samba_read;
methods.seek = xmms_samba_seek;
methods.browse = xmms_samba_browse;
xmms_xform_plugin_methods_set (xform_plugin, &methods);
xmms_xform_plugin_indata_add (xform_plugin, XMMS_STREAM_TYPE_MIMETYPE,
"application/x-url", XMMS_STREAM_TYPE_URL,
"smb://*", XMMS_STREAM_TYPE_END);
G_LOCK (mutex);
if (smbc_set_context (NULL) == NULL) {
/* This should really be cleaned up when the program closes.
* However, given that we have no means of doing so, we're
* just going to forget that we ever created it and let the OS
* clean up after us.
*/
SMBCCTX *ctx = smbc_new_context ();
if (ctx == NULL) {
xmms_log_error ("Failed to create SMBCCTX.", NULL);
return FALSE;
}
if (smbc_init_context (ctx) == NULL) {
xmms_log_error ("Failed to init SMBCCTX.", NULL);
smbc_free_context (ctx, 1);
return FALSE;
}
smbc_setOptionUseKerberos (ctx, TRUE);
smbc_setOptionFallbackAfterKerberos (ctx, TRUE);
smbc_set_context (ctx);
}
err = smbc_init (xmms_samba_auth_fn, 0);
G_UNLOCK (mutex);
if (err < 0) {
xmms_log_error ("%s", strerror (errno));
return FALSE;
}
return TRUE;
}
/**
* 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;
}
static gboolean
xmms_samba_plugin_setup (xmms_xform_plugin_t *xform_plugin)
{
xmms_xform_methods_t methods;
gint err;
XMMS_XFORM_METHODS_INIT (methods);
methods.init = xmms_samba_init;
methods.destroy = xmms_samba_destroy;
methods.read = xmms_samba_read;
methods.seek = xmms_samba_seek;
methods.browse = xmms_samba_browse;
xmms_xform_plugin_methods_set (xform_plugin, &methods);
xmms_xform_plugin_indata_add (xform_plugin, XMMS_STREAM_TYPE_MIMETYPE,
"application/x-url", XMMS_STREAM_TYPE_URL,
"smb://*", XMMS_STREAM_TYPE_END);
g_static_mutex_lock (&mutex);
err = smbc_init (xmms_samba_auth_fn, 0);
g_static_mutex_unlock (&mutex);
if (err < 0) {
xmms_log_error ("%s", strerror (errno));
return FALSE;
}
return TRUE;
}
/*
* Private stuff
*/
static CdIo_t *
open_cd (xmms_xform_t *xform)
{
CdIo_t *cdio;
xmms_config_property_t *val;
const gchar *device;
const gchar *accessmode;
cdio_log_set_handler (log_handler);
val = xmms_xform_config_lookup (xform, "device");
device = xmms_config_property_get_string (val);
val = xmms_xform_config_lookup (xform, "accessmode");
accessmode = xmms_config_property_get_string (val);
XMMS_DBG ("Trying to open device '%s', using '%s' access mode.",
device, accessmode);
if (g_ascii_strcasecmp (accessmode, "default") == 0) {
cdio = cdio_open (device, DRIVER_UNKNOWN);
} else {
cdio = cdio_open_am (device, DRIVER_UNKNOWN, accessmode);
}
if (!cdio) {
xmms_log_error ("Failed to open device '%s'.", device);
} else {
cdio_set_speed (cdio, 1);
xmms_log_info ("Opened device '%s'.", device);
}
return cdio;
}
GHashTable *
xmms_metadata_mapper_init (const xmms_xform_metadata_basic_mapping_t *basic_mappings, gint basic_count,
const xmms_xform_metadata_mapping_t *mappings, gint count)
{
GHashTable *default_mapper, *result;
gint i;
result = g_hash_table_new (xmms_strcase_hash, xmms_strcase_equal);
default_mapper = xmms_metadata_mapper_get_default ();
/* Initialize default mappers */
for (i = 0; i < basic_count; i++) {
const xmms_xform_metadata_mapping_t *mapping;
mapping = g_hash_table_lookup (default_mapper, basic_mappings[i].to);
if (mapping == NULL) {
xmms_log_error ("No default metadata mapper for '%s'", basic_mappings[i].to);
continue;
}
g_hash_table_insert (result, (gpointer) basic_mappings[i].from, (gpointer) mapping);
}
for (i = 0; i < count; i++) {
g_hash_table_insert (result, (gpointer) mappings[i].key, (gpointer) &mappings[i]);
}
g_hash_table_unref (default_mapper);
return result;
}
static gint64
xmms_cdda_seek (xmms_xform_t *xform, gint64 samples,
xmms_xform_seek_mode_t whence, xmms_error_t *err)
{
xmms_cdda_data_t *data;
lsn_t new_lsn;
g_return_val_if_fail (xform, -1);
data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, FALSE);
/* Magic number 42... really should think of a better way to do this but
* it seemed that the lsn is off by about 42 everytime...
*/
new_lsn = samples / 441.0 * CDIO_CD_FRAMES_PER_SEC / 100 + 42;
if ((data->first_lsn + new_lsn) > data->last_lsn) {
xmms_log_error ("Trying to seek past the end of track.");
return -1;
}
data->current_lsn = data->first_lsn + new_lsn;
return samples;
}
static void
xmms_ipc_handle_cmd_value (xmms_ipc_msg_t *msg, xmmsv_t *val)
{
if (xmms_ipc_msg_put_value (msg, val) == (uint32_t) -1) {
xmms_log_error ("Failed to serialize the return value into the IPC message!");
}
}
static gint
xmms_faad_get_framesize (xmms_xform_t *xform) {
xmms_faad_data_t *data;
const guchar *tmpbuf;
gsize tmpbuflen;
guchar *copy;
mp4AudioSpecificConfig mp4ASC;
g_return_val_if_fail (xform, 0);
data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, 0);
if (data->filetype != FAAD_TYPE_MP4) {
return 0;
}
if (!xmms_xform_auxdata_get_bin (xform, "decoder_config", &tmpbuf,
&tmpbuflen)) {
xmms_log_error ("ERROR: Cannot get AAC decoder config, but filetype is FAAD_TYPE_MP4!");
return 0;
}
copy = g_memdup (tmpbuf, tmpbuflen);
if ((signed char)NeAACDecAudioSpecificConfig (copy, tmpbuflen, &mp4ASC) < 0) {
/* FIXME: That function ^^^ returns char. How can it signal errors when
* char is unsigned?!
*/
g_free (copy);
XMMS_DBG ("ERROR: Could not get mp4ASC!");
return 0;
}
g_free (copy);
return ((mp4ASC.frameLengthFlag == 1) ? 960 : 1024)
* ((mp4ASC.sbr_present_flag == 1) ? 2 : 1);
}
static gboolean
get_disc_ids (const gchar *device, gchar **disc_id,
gchar **cddb_id, track_t *tracks)
{
DiscId *disc = discid_new ();
g_return_val_if_fail (disc, FALSE);
if (discid_read_sparse (disc, device, 0) == 0) {
xmms_log_error ("Could not read disc: %s", discid_get_error_msg (disc));
discid_free (disc);
return FALSE;
}
*disc_id = g_strdup (discid_get_id (disc));
if (tracks) {
*tracks = discid_get_last_track_num (disc);
}
if (cddb_id) {
*cddb_id = g_strdup (discid_get_freedb_id (disc));
}
discid_free (disc);
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));
}
}
}
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));
}
}
/**
* Start the server
*/
gboolean
xmms_ipc_setup_server (const gchar *path)
{
xmms_ipc_transport_t *transport;
xmms_ipc_t *ipc;
gchar **split;
gint i = 0, num_init = 0;
g_return_val_if_fail (path, FALSE);
split = g_strsplit (path, ";", 0);
for (i = 0; split && split[i]; i++) {
ipc = g_new0 (xmms_ipc_t, 1);
if (!ipc) {
XMMS_DBG ("No IPC server initialized.");
continue;
}
transport = xmms_ipc_server_init (split[i]);
if (!transport) {
g_free (ipc);
xmms_log_error ("Couldn't setup IPC listening on '%s'.", split[i]);
continue;
}
ipc->mutex_lock = g_mutex_new ();
ipc->transport = transport;
ipc->signals = ipc_object_pool->signals;
ipc->broadcasts = ipc_object_pool->broadcasts;
ipc->objects = ipc_object_pool->objects;
xmms_ipc_setup_server_internaly (ipc);
xmms_log_info ("IPC listening on '%s'.", split[i]);
g_mutex_lock (ipc_servers_lock);
ipc_servers = g_list_prepend (ipc_servers, ipc);
g_mutex_unlock (ipc_servers_lock);
num_init++;
}
g_strfreev (split);
/* If there is less than one socket, there is sth. wrong. */
if (num_init < 1)
return FALSE;
XMMS_DBG ("IPC setup done.");
return TRUE;
}
static gchar *
get_url_for_entry (xmms_medialib_session_t *session, xmms_medialib_entry_t entry)
{
gchar *url = NULL;
url = xmms_medialib_entry_property_get_str (session, entry, XMMS_MEDIALIB_ENTRY_PROPERTY_URL);
if (!url) {
xmms_log_error ("Couldn't get url for entry (%d)", entry);
}
return url;
}
gint
xmms_output_read (xmms_output_t *output, char *buffer, gint len)
{
gint ret;
xmms_error_t err;
xmms_error_reset (&err);
g_return_val_if_fail (output, -1);
g_return_val_if_fail (buffer, -1);
g_mutex_lock (output->filler_mutex);
xmms_ringbuf_wait_used (output->filler_buffer, len, output->filler_mutex);
ret = xmms_ringbuf_read (output->filler_buffer, buffer, len);
if (ret == 0 && xmms_ringbuf_iseos (output->filler_buffer)) {
xmms_output_status_set (output, XMMS_PLAYBACK_STATUS_STOP);
g_mutex_unlock (output->filler_mutex);
return -1;
}
g_mutex_unlock (output->filler_mutex);
update_playtime (output, ret);
if (ret < len) {
XMMS_DBG ("Underrun %d of %d (%d)", ret, len, xmms_sample_frame_size_get (output->format));
if ((ret % xmms_sample_frame_size_get (output->format)) != 0) {
xmms_log_error ("***********************************");
xmms_log_error ("* Read non-multiple of sample size,");
xmms_log_error ("* you probably hear noise now :)");
xmms_log_error ("***********************************");
}
output->buffer_underruns++;
}
output->bytes_written += ret;
return ret;
}
void
xmms_output_set_error (xmms_output_t *output, xmms_error_t *error)
{
g_return_if_fail (output);
xmms_output_status_set (output, XMMS_PLAYBACK_STATUS_STOP);
if (error) {
xmms_log_error ("Output plugin %s reported error, '%s'",
xmms_plugin_shortname_get ((xmms_plugin_t *)output->plugin),
xmms_error_message_get (error));
}
}
/**
* @internal Switch to using another output plugin
* @param object An object
* @param data The name of the output plugin to switch to
* @param userdata The #xmms_main_t object
*/
static void
change_output (xmms_object_t *object, xmmsv_t *_data, gpointer userdata)
{
xmms_output_plugin_t *plugin;
xmms_main_t *mainobj = (xmms_main_t*)userdata;
const gchar *outname;
if (!mainobj->output)
return;
outname = xmms_config_property_get_string ((xmms_config_property_t *) object);
xmms_log_info ("Switching to output %s", outname);
plugin = (xmms_output_plugin_t *)xmms_plugin_find (XMMS_PLUGIN_TYPE_OUTPUT, outname);
if (!plugin) {
xmms_log_error ("Baaaaad output plugin, try to change the output.plugin config variable to something usefull");
} else {
if (!xmms_output_plugin_switch (mainobj->output, plugin)) {
xmms_log_error ("Baaaaad output plugin, try to change the output.plugin config variable to something usefull");
}
}
}
/**
* @internal Execute all programs or scripts in a directory. Used when starting
* up and shutting down the daemon.
*
* @param[in] scriptdir Directory to search for executable programs/scripts.
* started.
* @param arg1 value passed to executed scripts as argument 1. This makes
* it possible to handle start and stop in one script
*/
static void
do_scriptdir (const gchar *scriptdir, const gchar *arg1)
{
GError *err = NULL;
GDir *dir;
const gchar *f;
gchar *argv[3] = {NULL, NULL, NULL};
XMMS_DBG ("Running scripts in %s", scriptdir);
if (!g_file_test (scriptdir, G_FILE_TEST_IS_DIR)) {
g_mkdir_with_parents (scriptdir, 0755);
install_scripts (scriptdir);
}
dir = g_dir_open (scriptdir, 0, &err);
if (!dir) {
xmms_log_error ("Could not open script dir '%s' error: %s", scriptdir, err->message);
return;
}
argv[1] = g_strdup (arg1);
while ((f = g_dir_read_name (dir))) {
argv[0] = g_strdup_printf ("%s/%s", scriptdir, f);
if (g_file_test (argv[0], G_FILE_TEST_IS_EXECUTABLE)) {
if (!g_spawn_async (g_get_home_dir (), argv, NULL, 0,
spawn_script_setup, NULL, NULL, &err)) {
xmms_log_error ("Could not run script '%s', error: %s",
argv[0], err->message);
}
}
g_free (argv[0]);
}
g_free (argv[1]);
g_dir_close (dir);
}
static gboolean
xmms_samba_browse (xmms_xform_t *xform,
const gchar *url,
xmms_error_t *error)
{
struct smbc_dirent *dir;
int handle;
G_LOCK (mutex);
handle = smbc_opendir (url);
G_UNLOCK (mutex);
if (handle < 0) {
xmms_error_set (error, XMMS_ERROR_GENERIC, "Couldn't browse URL");
xmms_log_error ("Couldn't open directory %s!", url);
return FALSE;
}
while (42) {
guint32 flags = 0;
G_LOCK (mutex);
dir = smbc_readdir (handle);
if (!dir) {
G_UNLOCK (mutex);
break;
}
if (dir->name[0] == '.') {
G_UNLOCK (mutex);
continue;
}
if (dir->smbc_type == SMBC_DIR ||
dir->smbc_type == SMBC_WORKGROUP ||
dir->smbc_type == SMBC_SERVER ||
dir->smbc_type == SMBC_FILE_SHARE)
flags |= XMMS_XFORM_BROWSE_FLAG_DIR;
xmms_xform_browse_add_entry (xform, dir->name, flags);
G_UNLOCK (mutex);
}
G_LOCK (mutex);
smbc_closedir (handle);
G_UNLOCK (mutex);
return TRUE;
}
static gboolean
xmms_ipc_source_accept (GIOChannel *chan, GIOCondition cond, gpointer data)
{
xmms_ipc_t *ipc = (xmms_ipc_t *) data;
xmms_ipc_transport_t *transport;
xmms_ipc_client_t *client;
if (!(cond & G_IO_IN)) {
xmms_log_error ("IPC listener got error/hup");
return FALSE;
}
XMMS_DBG ("Client connected");
transport = xmms_ipc_server_accept (ipc->transport);
if (!transport) {
xmms_log_error ("accept returned null!");
return TRUE;
}
client = xmms_ipc_client_new (ipc, transport);
if (!client) {
xmms_ipc_transport_destroy (transport);
return TRUE;
}
g_mutex_lock (ipc->mutex_lock);
ipc->clients = g_list_append (ipc->clients, client);
g_mutex_unlock (ipc->mutex_lock);
/* Now that the client has been registered in the ipc->clients list
* we may safely start its thread.
*/
g_thread_create (xmms_ipc_client_thread, client, FALSE, NULL);
return TRUE;
}
/**
* This function uses the statfs() call to
* check if the path is on a remote filesystem
* or not.
*
* @returns TRUE if path is on a remote filesystem
*/
gboolean
xmms_statfs_is_remote (const gchar *path)
{
struct statvfs st;
if (statvfs (path, &st) == -1) {
xmms_log_error ("Failed to run statfs, will not guess.");
return FALSE;
}
if (g_ascii_strcasecmp (st.f_basetype, "nfs") == 0) {
return TRUE;
}
return FALSE;
}
static void
log_handler (cdio_log_level_t level, const char *message)
{
switch (level) {
case CDIO_LOG_DEBUG:
XMMS_DBG ("libcdio (%d): %s.", level, message);
break;
case CDIO_LOG_INFO:
case CDIO_LOG_WARN:
xmms_log_info ("libcdio (%d): %s.", level, message);
break;
default:
xmms_log_error ("libcdio (%d): %s.", level, message);
break;
}
}
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 gboolean
xmms_ipc_client_read_cb (GIOChannel *iochan,
GIOCondition cond,
gpointer data)
{
xmms_ipc_client_t *client = data;
bool disconnect = FALSE;
g_return_val_if_fail (client, FALSE);
if (cond & G_IO_IN) {
while (TRUE) {
if (!client->read_msg) {
client->read_msg = xmms_ipc_msg_alloc ();
}
if (xmms_ipc_msg_read_transport (client->read_msg, client->transport, &disconnect)) {
xmms_ipc_msg_t *msg = client->read_msg;
client->read_msg = NULL;
process_msg (client, msg);
xmms_ipc_msg_destroy (msg);
} else {
break;
}
}
}
if (disconnect || (cond & G_IO_HUP)) {
if (client->read_msg) {
xmms_ipc_msg_destroy (client->read_msg);
client->read_msg = NULL;
}
XMMS_DBG ("disconnect was true!");
g_main_loop_quit (client->ml);
return FALSE;
}
if (cond & G_IO_ERR) {
xmms_log_error ("Client got error, maybe connection died?");
g_main_loop_quit (client->ml);
return FALSE;
}
return TRUE;
}
/**
* This function uses the statfs() call to
* check if the path is on a remote filesystem
* or not.
*
* @returns TRUE if path is on a remote filesystem
*/
gboolean
xmms_statfs_is_remote (const gchar *path)
{
struct statfs st;
if (statfs (path, &st) == -1) {
xmms_log_error ("Failed to run statfs, will not guess.");
return FALSE;
}
if (st.f_type == 0xFF534D42 || /* cifs */
st.f_type == 0x6969 || /* nfs */
st.f_type == 0x517B) { /* smb */
return TRUE;
}
return FALSE;
}
static gboolean
xmms_sndfile_init (xmms_xform_t *xform)
{
xmms_sndfile_data_t *data;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_sndfile_data_t, 1);
g_return_val_if_fail (data, FALSE);
xmms_xform_private_data_set (xform, data);
data->sfvirtual.get_filelen = &xmms_sf_virtual_get_filelen;
data->sfvirtual.seek = &xmms_sf_virtual_seek;
data->sfvirtual.read = &xmms_sf_virtual_read;
data->sfvirtual.write = &xmms_sf_virtual_write;
data->sfvirtual.tell = &xmms_sf_virtual_tell;
data->sndfile = sf_open_virtual (&data->sfvirtual, SFM_READ,
&data->sf_info, xform);
if (data->sndfile == NULL) {
char errstr[1024];
sf_error_str (NULL, errstr, sizeof (errstr));
xmms_log_error ("libsndfile: sf_open_virtual failed with \"%s\".",
errstr);
g_free (data);
return FALSE;
}
xmms_sndfile_get_media_info (xform);
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm",
XMMS_STREAM_TYPE_FMT_FORMAT,
XMMS_SAMPLE_FORMAT_S32,
XMMS_STREAM_TYPE_FMT_CHANNELS,
data->sf_info.channels,
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
data->sf_info.samplerate,
XMMS_STREAM_TYPE_END);
return TRUE;
}
