static gboolean xmms_faad_gapless_try (xmms_xform_t *xform) { xmms_faad_data_t *data; gint64 start = 0, stop = 0; g_return_val_if_fail (xform, FALSE); data = xmms_xform_private_data_get (xform); g_return_val_if_fail (data, FALSE); xmms_xform_auxdata_get_int64 (xform, "startsamples", &start); if (start == 0) { XMMS_DBG ("First frame of AAC should be ignored, but is not. Trying to fix."); start = xmms_faad_get_framesize (xform); if (start == 0) { XMMS_DBG ("No luck. Couldn't get the framesize."); } } if (start != 0) { xmms_xform_auxdata_set_int (xform, "startsamples", start); } xmms_xform_auxdata_get_int64 (xform, "stopsamples", &stop); if (stop != 0) { xmms_xform_auxdata_set_int (xform, "stopsamples", stop); } return (start != 0) || (stop != 0); }
static void __int_xmms_cmd_add (xmms_object_t *object, xmms_object_cmd_arg_t *arg) { xmmsv_t *t; if (xmmsv_list_get_size (arg->args) != 1) { XMMS_DBG ("Wrong number of arguments to add (%d)", xmmsv_list_get_size (arg->args)); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to add"); return; } GString * argval0; if (!xmmsv_list_get (arg->args, 0, &t)) { XMMS_DBG ("Missing arg 0 in add"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in add"); return; } if (!xmms_bin_to_gstring (t, &argval0)) { XMMS_DBG ("Error parsing arg 0 in add"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in add"); return; } gchar * retval = xmms_bindata_client_add ((xmms_bindata_t *) object, argval0, &arg->error); if (retval != NULL) { arg->retval = xmms_convert_and_kill_string (retval); } }
static void __int_xmms_cmd_rehash (xmms_object_t *object, xmms_object_cmd_arg_t *arg) { xmmsv_t *t; if (xmmsv_list_get_size (arg->args) != 1) { XMMS_DBG ("Wrong number of arguments to rehash (%d)", xmmsv_list_get_size (arg->args)); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to rehash"); return; } gint32 argval0; if (!xmmsv_list_get (arg->args, 0, &t)) { XMMS_DBG ("Missing arg 0 in rehash"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in rehash"); return; } if (!xmmsv_get_int (t, &argval0)) { XMMS_DBG ("Error parsing arg 0 in rehash"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in rehash"); return; } xmms_medialib_client_rehash ((xmms_medialib_t *) object, argval0, &arg->error); arg->retval = xmmsv_new_none (); }
static void xmms_playlist_client_load (xmms_playlist_t *playlist, const gchar *name, xmms_error_t *err) { xmmsv_coll_t *plcoll, *active_coll; if (strcmp (name, XMMS_ACTIVE_PLAYLIST) == 0) { xmms_error_set (err, XMMS_ERROR_INVAL, "invalid playlist to load"); return; } active_coll = xmms_playlist_get_coll (playlist, XMMS_ACTIVE_PLAYLIST, err); if (active_coll == NULL) { xmms_error_set (err, XMMS_ERROR_GENERIC, "no active playlist"); return; } plcoll = xmms_playlist_get_coll (playlist, name, err); if (plcoll == NULL) { xmms_error_set (err, XMMS_ERROR_NOENT, "no such playlist"); return; } if (active_coll == plcoll) { XMMS_DBG ("Not loading %s playlist, already active!", name); return; } XMMS_DBG ("Loading new playlist! %s", name); xmms_collection_update_pointer (playlist->colldag, XMMS_ACTIVE_PLAYLIST, XMMS_COLLECTION_NSID_PLAYLISTS, plcoll); xmms_object_emit (XMMS_OBJECT (playlist), XMMS_IPC_SIGNAL_PLAYLIST_LOADED, xmmsv_new_string (name)); }
static void __int_xmms_cmd_remove (xmms_object_t *object, xmms_object_cmd_arg_t *arg) { xmmsv_t *t; if (xmmsv_list_get_size (arg->args) != 1) { XMMS_DBG ("Wrong number of arguments to remove (%d)", xmmsv_list_get_size (arg->args)); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to remove"); return; } const char * argval0; if (!xmmsv_list_get (arg->args, 0, &t)) { XMMS_DBG ("Missing arg 0 in remove"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in remove"); return; } if (!xmmsv_get_string (t, &argval0)) { XMMS_DBG ("Error parsing arg 0 in remove"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in remove"); return; } xmms_bindata_client_remove ((xmms_bindata_t *) object, argval0, &arg->error); arg->retval = xmmsv_new_none (); }
static void xmms_rss_start_element (xmms_rss_data_t *data, const xmlChar *name, const xmlChar **attrs) { xmms_xform_t *xform = data->xform; int i; XMMS_DBG ("start elem %s", name); if (!attrs || !data) return; if (!xmlStrEqual (name, BAD_CAST "enclosure")) return; for (i = 0; attrs[i]; i += 2) { char *attr; if (!xmlStrEqual (attrs[i], BAD_CAST "url")) continue; attr = (char *) attrs[i + 1]; XMMS_DBG ("Found %s", attr); xmms_xform_browse_add_symlink (xform, NULL, attr); break; } }
static gboolean xmms_xform_match (xmms_plugin_t *plugin, gpointer user_data) { xmms_xform_plugin_t *xform_plugin = (xmms_xform_plugin_t *) plugin; match_state_t *state = (match_state_t *) user_data; gint priority = 0; g_assert (plugin->type == XMMS_PLUGIN_TYPE_XFORM); XMMS_DBG ("Trying plugin '%s'", xmms_plugin_shortname_get (plugin)); if (!xmms_xform_plugin_supports (xform_plugin, state->out_type, &priority)) { return TRUE; } XMMS_DBG ("Plugin '%s' matched (priority %d)", xmms_plugin_shortname_get (plugin), priority); if (priority > state->priority) { if (state->match) { xmms_plugin_t *previous_plugin = (xmms_plugin_t *) state->match; XMMS_DBG ("Using plugin '%s' (priority %d) instead of '%s' (priority %d)", xmms_plugin_shortname_get (plugin), priority, xmms_plugin_shortname_get (previous_plugin), state->priority); } state->match = xform_plugin; state->priority = priority; } return TRUE; }
/** * @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 gboolean song_changed (void *data) { /* executes in the output thread; NOT the filler thread */ xmms_output_song_changed_arg_t *arg = (xmms_output_song_changed_arg_t *)data; xmms_medialib_entry_t entry; entry = xmms_xform_entry_get (arg->chain); XMMS_DBG ("Running hotspot! Song changed!! %d", entry); arg->output->played = 0; arg->output->current_entry = entry; if (!xmms_output_format_set (arg->output, xmms_xform_outtype_get (arg->chain))) { XMMS_DBG ("Couldn't set format, stopping filler.."); xmms_output_filler_state_nolock (arg->output, FILLER_STOP); xmms_ringbuf_set_eos (arg->output->filler_buffer, TRUE); return FALSE; } if (arg->flush) xmms_output_flush (arg->output); xmms_object_emit_f (XMMS_OBJECT (arg->output), XMMS_IPC_SIGNAL_OUTPUT_CURRENTID, XMMSV_TYPE_UINT32, entry); return TRUE; }
void write_buffer_to_channel (GIOChannel *chan, gchar *buf, gint bufsize) { guint total_sent_bytes = 0; gsize sent_bytes; GIOStatus io_stat; GError *err = NULL; do { io_stat = g_io_channel_write_chars (chan, buf + total_sent_bytes, bufsize - total_sent_bytes, &sent_bytes, &err); if (io_stat == G_IO_STATUS_ERROR) { if (NULL != err) { XMMS_DBG ("Error writing to channel: %s\n", err->message); } break; } bufsize -= sent_bytes; total_sent_bytes += sent_bytes; } while (bufsize > 0); g_io_channel_flush (chan, &err); if (NULL != err) { XMMS_DBG ("warning: error flushing channel: %s\n", err->message); } }
static gboolean xmms_id3v2_init (xmms_xform_t *xform) { xmms_id3v2_data_t *data; xmms_id3v2_header_t head; xmms_error_t err; guchar hbuf[20]; gint filesize; guchar *buf; gint res; const gchar *metakey; xmms_error_reset (&err); if (xmms_xform_read (xform, hbuf, 10, &err) != 10) { XMMS_DBG ("Couldn't read id3v2 header..."); return FALSE; } data = g_new0 (xmms_id3v2_data_t, 1); xmms_xform_private_data_set (xform, data); if (!xmms_id3v2_is_header (hbuf, &head)) { XMMS_DBG ("Couldn't parse id3v2 header!?"); return FALSE; } /* Total data length is the length of header data plus header bytes */ data->len = head.len + 10; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; xmms_xform_metadata_set_int (xform, metakey, filesize - head.len); } buf = g_malloc (head.len); res = xmms_xform_read (xform, buf, head.len, &err); if (res != head.len) { XMMS_DBG ("Couldn't read id3v2 %d bytes of id3-data data (%d)", head.len, res); return FALSE; } xmms_id3v2_parse (xform, buf, &head); g_free (buf); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/octet-stream", XMMS_STREAM_TYPE_END); return TRUE; }
static GNode * xmms_magic_add_node (GNode *tree, const gchar *s, GNode *prev_node) { xmms_magic_entry_t *entry; gpointer *data = tree->data; guint indent = 0, prev_indent; g_assert (s); XMMS_DBG ("adding magic spec to tree '%s'", (gchar *) data[0]); /* indent level is number of leading '>' characters */ while (*s == '>') { indent++; s++; } entry = parse_entry (s); if (!entry) { XMMS_DBG ("cannot parse magic entry"); return NULL; } if (!indent) { return g_node_append_data (tree, entry); } if (!prev_node) { XMMS_DBG ("invalid indent level"); xmms_magic_entry_free (entry); return NULL; } prev_indent = g_node_depth (prev_node) - 2; if (indent > prev_indent) { /* larger jumps are invalid */ if (indent != prev_indent + 1) { XMMS_DBG ("invalid indent level"); xmms_magic_entry_free (entry); return NULL; } return g_node_append_data (prev_node, entry); } else { while (indent < prev_indent) { prev_indent--; prev_node = prev_node->parent; } return g_node_insert_after (prev_node->parent, prev_node, g_node_new (entry)); } }
static void __int_xmms_cmd_set_property_int (xmms_object_t *object, xmms_object_cmd_arg_t *arg) { xmmsv_t *t; if (xmmsv_list_get_size (arg->args) != 4) { XMMS_DBG ("Wrong number of arguments to set_property_int (%d)", xmmsv_list_get_size (arg->args)); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to set_property_int"); return; } gint32 argval0; const char * argval1; const char * argval2; gint32 argval3; if (!xmmsv_list_get (arg->args, 0, &t)) { XMMS_DBG ("Missing arg 0 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in set_property_int"); return; } if (!xmmsv_get_int (t, &argval0)) { XMMS_DBG ("Error parsing arg 0 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in set_property_int"); return; } if (!xmmsv_list_get (arg->args, 1, &t)) { XMMS_DBG ("Missing arg 1 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 1 in set_property_int"); return; } if (!xmmsv_get_string (t, &argval1)) { XMMS_DBG ("Error parsing arg 1 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 1 in set_property_int"); return; } if (!xmmsv_list_get (arg->args, 2, &t)) { XMMS_DBG ("Missing arg 2 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 2 in set_property_int"); return; } if (!xmmsv_get_string (t, &argval2)) { XMMS_DBG ("Error parsing arg 2 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 2 in set_property_int"); return; } if (!xmmsv_list_get (arg->args, 3, &t)) { XMMS_DBG ("Missing arg 3 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 3 in set_property_int"); return; } if (!xmmsv_get_int (t, &argval3)) { XMMS_DBG ("Error parsing arg 3 in set_property_int"); xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 3 in set_property_int"); return; } xmms_medialib_client_set_property_int ((xmms_medialib_t *) object, argval0, argval1, argval2, argval3, &arg->error); arg->retval = xmmsv_new_none (); }
/** * 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 * xmms_magic_match (xmms_magic_checker_t *c, const gchar *uri) { const GList *l; gchar *u, *dump; int i; g_return_val_if_fail (c, NULL); /* only one of the contained sets has to match */ for (l = magic_list; l; l = g_list_next (l)) { GNode *tree = l->data; if (tree_match (c, tree)) { gpointer *data = tree->data; XMMS_DBG ("magic plugin detected '%s' (%s)", (char *)data[1], (char *)data[0]); return (char *) (data[1]); } } if (!uri) return NULL; u = g_ascii_strdown (uri, -1); for (l = ext_list; l; l = g_list_next (l)) { xmms_magic_ext_data_t *e = l->data; if (g_pattern_match_simple (e->pattern, u)) { XMMS_DBG ("magic plugin detected '%s' (by extension '%s')", e->type, e->pattern); g_free (u); return e->type; } } g_free (u); if (c->dumpcount > 0) { dump = g_malloc ((MIN (c->read, c->dumpcount) * 3) + 1); u = dump; XMMS_DBG ("Magic didn't match anything..."); for (i = 0; i < c->dumpcount && i < c->read; i++) { g_sprintf (u, "%02X ", (unsigned char)c->buf[i]); u += 3; } XMMS_DBG ("%s", dump); g_free (dump); } return NULL; }
static gboolean xmms_asf_init (xmms_xform_t *xform) { xmms_asf_data_t *data; asf_iostream_t stream; gint ret; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_asf_data_t, 1); stream.read = xmms_asf_read_callback; stream.write = NULL; stream.seek = xmms_asf_seek_callback; stream.opaque = xform; data->file = asf_open_cb (&stream); if (!data->file) { g_free (data); return FALSE; } data->packet = asf_packet_create (); data->outbuf = g_string_new (NULL); xmms_xform_private_data_set (xform, data); ret = asf_init (data->file); if (ret < 0) { XMMS_DBG ("ASF parser failed to init with error %d", ret); asf_packet_destroy (data->packet); asf_close (data->file); return FALSE; } data->track = xmms_asf_get_track (xform, data->file); if (data->track < 0) { XMMS_DBG ("No audio track found"); asf_packet_destroy (data->packet); asf_close (data->file); return FALSE; } xmms_asf_get_mediainfo (xform); XMMS_DBG ("ASF demuxer inited successfully!"); 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; }
/* * 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; }
static gboolean xmms_cdda_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error) { track_t track_count, t; gchar cdda_url[XMMS_PATH_MAX]; xmms_config_property_t *val; const gchar *device; gchar *disc_id; g_return_val_if_fail (xform, FALSE); val = xmms_xform_config_lookup (xform, "device"); device = xmms_config_property_get_string (val); if (!get_disc_ids (device, &disc_id, 0, &track_count)) { return FALSE; } for (t = 1; t <= track_count; t++) { gchar trackno[3]; g_snprintf (cdda_url, XMMS_PATH_MAX, "cdda://%s/%d", disc_id, t); XMMS_DBG ("Adding '%s'.", cdda_url); g_snprintf (trackno, sizeof (trackno), "%d", t); xmms_xform_browse_add_symlink (xform, trackno, cdda_url); xmms_xform_browse_add_entry_property_int (xform, "intsort", t); } g_free (disc_id); return TRUE; }
static gboolean xmms_metadata_test_coverart (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { XMMS_DBG ("amagad"); return TRUE; }
static void handle_comments (xmms_xform_t *xform, xmms_flac_data_t *data) { FLAC__StreamMetadata_VorbisComment *vc; gint i; g_return_if_fail (data->vorbiscomment); vc = &data->vorbiscomment->data.vorbis_comment; for (i = 0; i < vc->num_comments; i++) { const gchar *entry, *ptr; gchar key[64]; gsize length; entry = (const gchar *) vc->comments[i].entry; length = vc->comments[i].length; if (entry == NULL || *entry == '\0') continue; ptr = memchr (entry, '=', length); if (ptr == NULL) continue; ptr++; g_strlcpy (key, entry, MIN (ptr - entry, sizeof (key))); if (!xmms_xform_metadata_mapper_match (xform, key, ptr, length - (ptr - entry))) { XMMS_DBG ("Unhandled tag '%s'", entry); } } }
static void xmms_ipc_client_destroy (xmms_ipc_client_t *client) { guint i; XMMS_DBG ("Destroying client!"); if (client->ipc) { g_mutex_lock (client->ipc->mutex_lock); client->ipc->clients = g_list_remove (client->ipc->clients, client); g_mutex_unlock (client->ipc->mutex_lock); } g_main_loop_unref (client->ml); g_io_channel_unref (client->iochan); xmms_ipc_transport_destroy (client->transport); g_mutex_lock (client->lock); while (!g_queue_is_empty (client->out_msg)) { xmms_ipc_msg_t *msg = g_queue_pop_head (client->out_msg); xmms_ipc_msg_destroy (msg); } g_queue_free (client->out_msg); for (i = 0; i < XMMS_IPC_SIGNAL_END; i++) { g_list_free (client->broadcasts[i]); } g_mutex_unlock (client->lock); g_mutex_free (client->lock); g_free (client); }
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 add_metadatum (gpointer _key, gpointer _value, gpointer user_data) { xmmsv_t *value = (xmmsv_t *) _value; gchar *key = (gchar *) _key; metadata_festate_t *st = (metadata_festate_t *) user_data; if (xmmsv_get_type (value) == XMMSV_TYPE_STRING) { const gchar *s; xmmsv_get_string (value, &s); xmms_medialib_entry_property_set_str_source (st->session, st->entry, key, s, st->source); } else if (xmmsv_get_type (value) == XMMSV_TYPE_INT32) { gint i; xmmsv_get_int (value, &i); xmms_medialib_entry_property_set_int_source (st->session, st->entry, key, i, st->source); } else { XMMS_DBG ("Unknown type?!?"); } }
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 (); }
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 qr_reply (DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context) { GMDNSUserData *ud = context; gchar addr[1000]; const guchar *rd = (guchar *)rdata; g_return_if_fail (ud); g_return_if_fail (rrtype == kDNSServiceType_A); g_snprintf (addr, 1000, "%d.%d.%d.%d", rd[0], rd[1], rd[2], rd[3]); ud->server->address = g_strdup (addr); XMMS_DBG ("adding server %s %s", ud->server->mdnsname, ud->server->address); g_mutex_lock (ud->mdns->mutex); ud->mdns->service_list = g_slist_prepend (ud->mdns->service_list, ud->server); g_mutex_unlock (ud->mdns->mutex); if (ud->mdns->callback) { ud->mdns->callback (ud->mdns, G_MDNS_SERVER_ADD, ud->server, ud->mdns->user_data); } g_mdns_user_data_destroy (ud); }
static gboolean xmms_icymetaint_init (xmms_xform_t *xform) { xmms_icymetaint_data_t *data; gint32 meta_offset; gboolean res; g_return_val_if_fail (xform, FALSE); res = xmms_xform_auxdata_get_int (xform, "meta_offset", &meta_offset); g_return_val_if_fail (res, FALSE); XMMS_DBG ("meta_offset = %d", meta_offset); data = g_new0 (xmms_icymetaint_data_t, 1); data->metabuffer = g_malloc (256 * 16); data->meta_offset = meta_offset; xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/octet-stream", XMMS_STREAM_TYPE_END); xmms_xform_private_data_set (xform, data); return TRUE; }
static void handle_shoutcast_metadata (xmms_xform_t *xform, gchar *metadata) { xmms_icymetaint_data_t *data; gchar **tags; guint i = 0; g_return_if_fail (xform); g_return_if_fail (metadata); XMMS_DBG ("metadata: %s", metadata); data = xmms_xform_private_data_get (xform); tags = g_strsplit (metadata, ";", 0); while (tags[i] != NULL) { if (g_ascii_strncasecmp (tags[i], "StreamTitle=", 12) == 0) { const gchar *metakey; gchar *raw; raw = tags[i] + 13; raw[strlen (raw) - 1] = '\0'; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE; xmms_xform_metadata_set_str (xform, metakey, raw); } i++; } g_strfreev (tags); }
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); }