/** * 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; }
static gboolean xmms_vocoder_init (xmms_xform_t *xform) { xmms_vocoder_data_t *priv; xmms_config_property_t *config; g_return_val_if_fail (xform, FALSE); priv = g_new0 (xmms_vocoder_data_t, 1); priv->winsize = 2048; priv->channels = xmms_xform_indata_get_int (xform, XMMS_STREAM_TYPE_FMT_CHANNELS); priv->bufsize = priv->winsize * priv->channels; priv->iobuf = g_malloc (priv->bufsize * sizeof (gint16)); priv->procbuf = g_malloc (priv->bufsize * sizeof (pvocoder_sample_t)); priv->resbuf = g_malloc (priv->bufsize * sizeof (gfloat)); priv->outbuf = g_string_new (NULL); priv->pvoc = pvocoder_init (priv->winsize, priv->channels); g_return_val_if_fail (priv->pvoc, FALSE); priv->resampler = src_new (SRC_LINEAR, priv->channels, NULL); g_return_val_if_fail (priv->resampler, FALSE); xmms_xform_private_data_set (xform, priv); config = xmms_xform_config_lookup (xform, "enabled"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->enabled = !!xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "speed"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->speed = (gfloat) xmms_config_property_get_int (config) / 100.0; config = xmms_xform_config_lookup (xform, "pitch"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->pitch = 100.0 / (gfloat) xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "attack_detection"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->attack_detection = !!xmms_config_property_get_int (config); pvocoder_set_scale (priv->pvoc, priv->speed * priv->pitch); pvocoder_set_attack_detection (priv->pvoc, priv->attack_detection); priv->resdata.data_in = NULL; priv->resdata.input_frames = 0; priv->resdata.data_out = priv->resbuf; priv->resdata.output_frames = priv->winsize; priv->resdata.src_ratio = priv->pitch; priv->resdata.end_of_input = 0; xmms_xform_outdata_type_copy (xform); return TRUE; }
static gboolean xmms_magic_plugin_init (xmms_xform_t *xform) { xmms_magic_checker_t c; gchar *res; const gchar *url; xmms_config_property_t *cv; c.xform = xform; c.read = c.offset = 0; c.alloc = 128; /* start with a 128 bytes buffer */ c.buf = g_malloc (c.alloc); cv = xmms_xform_config_lookup (xform, "dumpcount"); c.dumpcount = xmms_config_property_get_int (cv); url = xmms_xform_indata_find_str (xform, XMMS_STREAM_TYPE_URL); res = xmms_magic_match (&c, url); if (res) { xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_MIME, res); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, res, XMMS_STREAM_TYPE_END); } g_free (c.buf); return !!res; }
static void xmms_normalize_config_changed (xmms_object_t *obj, xmmsv_t *_value, gpointer udata) { xmms_normalize_data_t *data = udata; const gchar *name; gint value; name = xmms_config_property_get_name ((xmms_config_property_t *) obj); value = xmms_config_property_get_int ((xmms_config_property_t *) obj); if (!g_ascii_strcasecmp (name, "normalize.use_anticlip")) { data->use_anticlip = !!value; } else if (!g_ascii_strcasecmp (name, "normalize.target")) { data->target = value; } else if (!g_ascii_strcasecmp (name, "normalize.max_gain")) { data->max_gain = value; } else if (!g_ascii_strcasecmp (name, "normalize.smooth")) { data->smooth = value; } else if (!g_ascii_strcasecmp (name, "normalize.buckets")) { data->buckets = value; } /* reconfigure needed */ data->dirty = TRUE; }
static gboolean xmms_ringbuf_plugin_init (xmms_xform_t *xform) { xmms_config_property_t *config; xmms_ringbuf_priv_t *priv; gint buffer_size; priv = g_new0 (xmms_ringbuf_priv_t, 1); xmms_xform_private_data_set (xform, priv); config = xmms_xform_config_lookup (xform, "buffersize"); buffer_size = xmms_config_property_get_int (config); g_cond_init (&priv->state_cond); g_mutex_init (&priv->state_lock); g_mutex_init (&priv->buffer_lock); priv->state = STATE_WANT_BUFFER; priv->buffer = xmms_ringbuf_new (MAX (4096, buffer_size)); priv->thread = g_thread_new ("x2 ringbuf", xmms_ringbuf_xform_thread, xform); xmms_xform_outdata_type_copy (xform); return TRUE; }
static void on_playlist_r_one_changed (xmms_object_t *object, xmmsv_t *_data, gpointer udata) { xmms_playlist_t *playlist = udata; gint value; value = xmms_config_property_get_int ((xmms_config_property_t *) object); g_mutex_lock (playlist->mutex); playlist->repeat_one = !!value; g_mutex_unlock (playlist->mutex); }
/** * 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 gint xmms_id3v1_get_tags (xmms_xform_t *xform) { xmms_config_property_t *config; gint enabled; xmms_error_t err; gint64 res; guchar buf[128]; gint ret = 0; config = xmms_xform_config_lookup (xform, "id3v1_enable"); g_return_val_if_fail (config, -1); enabled = xmms_config_property_get_int (config); if (!enabled) { XMMS_DBG ("ID3v1 tags disabled."); return 0; } xmms_error_reset (&err); res = xmms_xform_seek (xform, -128, XMMS_XFORM_SEEK_END, &err); if (res == -1) { XMMS_DBG ("Couldn't seek - not getting id3v1 tag"); return 0; } if (xmms_xform_read (xform, buf, 128, &err) == 128) { if (xmms_id3v1_parse (xform, buf)) { ret = 128; } } else { XMMS_DBG ("Read of 128 bytes failed?!"); xmms_error_reset (&err); } res = xmms_xform_seek (xform, 0, XMMS_XFORM_SEEK_SET, &err); if (res == -1) { XMMS_DBG ("Couldn't seek after getting id3 tag?!? very bad"); return -1; } return ret; }
static void xmms_vocoder_config_changed (xmms_object_t *object, xmmsv_t *_data, gpointer userdata) { xmms_config_property_t *val; xmms_vocoder_data_t *data; const gchar *name; gint value; g_return_if_fail (object); g_return_if_fail (userdata); val = (xmms_config_property_t *) object; data = (xmms_vocoder_data_t *) userdata; name = xmms_config_property_get_name (val); value = xmms_config_property_get_int (val); XMMS_DBG ("config value changed! %s => %d", name, value); /* we are passed the full config key, not just the last token, * which makes this code kinda ugly. * fix when bug 97 has been resolved */ name = strrchr (name, '.') + 1; if (!strcmp (name, "enabled")) { data->enabled = !!value; } else if (!strcmp (name, "speed")) { data->speed = (gfloat) value / 100.0; pvocoder_set_scale (data->pvoc, data->speed * data->pitch); } else if (!strcmp (name, "pitch") && value != 0) { data->pitch = 100.0 / (gfloat) value; data->resdata.src_ratio = data->pitch; pvocoder_set_scale (data->pvoc, data->speed * data->pitch); } else if (!strcmp (name, "attack_detection") && value != 0) { data->attack_detection = value; pvocoder_set_attack_detection (data->pvoc, value); } }
gboolean xmms_xform_plugin_supports (const xmms_xform_plugin_t *plugin, xmms_stream_type_t *st, gint *priority) { GList *t; g_return_val_if_fail (st, FALSE); g_return_val_if_fail (plugin, FALSE); g_return_val_if_fail (priority, FALSE); for (t = plugin->in_types; t; t = g_list_next (t)) { xmms_config_property_t *config_priority; const gchar *type_name; gchar *config_key; if (!xmms_stream_type_match (t->data, st)) { continue; } type_name = xmms_stream_type_get_str (t->data, XMMS_STREAM_TYPE_NAME); config_key = g_strconcat ("priority.", type_name, NULL); config_priority = xmms_plugin_config_lookup ((xmms_plugin_t *) plugin, config_key); g_free (config_key); if (config_priority) { *priority = xmms_config_property_get_int (config_priority); } else { *priority = XMMS_STREAM_TYPE_PRIORITY_DEFAULT; } return TRUE; } return FALSE; }
static gboolean xmms_replaygain_init (xmms_xform_t *xform) { xmms_replaygain_data_t *data; xmms_config_property_t *cfgv; xmms_sample_format_t fmt; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_replaygain_data_t, 1); g_return_val_if_fail (data, FALSE); xmms_xform_private_data_set (xform, data); cfgv = xmms_xform_config_lookup (xform, "mode"); xmms_config_property_callback_set (cfgv, xmms_replaygain_config_changed, xform); data->mode = parse_mode (xmms_config_property_get_string (cfgv)); cfgv = xmms_xform_config_lookup (xform, "use_anticlip"); xmms_config_property_callback_set (cfgv, xmms_replaygain_config_changed, xform); data->use_anticlip = !!xmms_config_property_get_int (cfgv); cfgv = xmms_xform_config_lookup (xform, "preamp"); xmms_config_property_callback_set (cfgv, xmms_replaygain_config_changed, xform); data->preamp = pow (10.0, atof (xmms_config_property_get_string (cfgv)) / 20.0); cfgv = xmms_xform_config_lookup (xform, "enabled"); xmms_config_property_callback_set (cfgv, xmms_replaygain_config_changed, xform); data->enabled = !!xmms_config_property_get_int (cfgv); xmms_xform_outdata_type_copy (xform); compute_gain (xform, data); fmt = xmms_xform_indata_get_int (xform, XMMS_STREAM_TYPE_FMT_FORMAT); switch (fmt) { case XMMS_SAMPLE_FORMAT_S8: data->apply = apply_s8; break; case XMMS_SAMPLE_FORMAT_U8: data->apply = apply_u8; break; case XMMS_SAMPLE_FORMAT_S16: data->apply = apply_s16; break; case XMMS_SAMPLE_FORMAT_U16: data->apply = apply_u16; break; case XMMS_SAMPLE_FORMAT_S32: data->apply = apply_s32; break; case XMMS_SAMPLE_FORMAT_U32: data->apply = apply_u32; break; case XMMS_SAMPLE_FORMAT_FLOAT: data->apply = apply_float; break; case XMMS_SAMPLE_FORMAT_DOUBLE: data->apply = apply_double; break; default: /* we shouldn't ever get here, since we told the daemon * earlier about this list of supported formats. */ g_assert_not_reached (); break; } return TRUE; }
static void xmms_modplug_config_changed (xmms_object_t *obj, xmmsv_t *_value, gpointer udata) { xmms_modplug_data_t *data = udata; xmms_config_property_t *prop = (xmms_config_property_t *) obj; const gchar *name; const gchar *value; gint intvalue; name = xmms_config_property_get_name (prop); if (!g_ascii_strcasecmp (name, "modplug.resample")) { value = xmms_config_property_get_string (prop); if (!g_ascii_strcasecmp (value, "fir")) { data->settings.mResamplingMode = MODPLUG_RESAMPLE_FIR; } else if (!g_ascii_strcasecmp (value, "spline")) { data->settings.mResamplingMode = MODPLUG_RESAMPLE_SPLINE; } else if (!g_ascii_strcasecmp (value, "linear")) { data->settings.mResamplingMode = MODPLUG_RESAMPLE_LINEAR; } else { data->settings.mResamplingMode = MODPLUG_RESAMPLE_NEAREST; } } else { intvalue = xmms_config_property_get_int (prop); if (!g_ascii_strcasecmp (name, "modplug.freq")) { data->settings.mFrequency = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.reverb_depth")) { data->settings.mReverbDepth = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.reverb_delay")) { data->settings.mReverbDelay = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.bass_amount")) { data->settings.mBassAmount = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.bass_range")) { data->settings.mBassRange = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.surround_depth")) { data->settings.mSurroundDepth = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.surround_delay")) { data->settings.mSurroundDelay = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.loop")) { data->settings.mLoopCount = intvalue; } else if (!g_ascii_strcasecmp (name, "modplug.enable_oversampling")) { if (intvalue) { data->settings.mFlags |= MODPLUG_ENABLE_OVERSAMPLING; } else { data->settings.mFlags &= ~MODPLUG_ENABLE_OVERSAMPLING; } } else if (!g_ascii_strcasecmp (name, "modplug.enable_noise_reduction")) { if (intvalue) { data->settings.mFlags |= MODPLUG_ENABLE_NOISE_REDUCTION; } else { data->settings.mFlags &= ~MODPLUG_ENABLE_NOISE_REDUCTION; } } else if (!g_ascii_strcasecmp (name, "modplug.enable_reverb")) { if (intvalue) { data->settings.mFlags |= MODPLUG_ENABLE_REVERB; } else { data->settings.mFlags &= ~MODPLUG_ENABLE_REVERB; } } else if (!g_ascii_strcasecmp (name, "modplug.enable_megabass")) { if (intvalue) { data->settings.mFlags |= MODPLUG_ENABLE_MEGABASS; } else { data->settings.mFlags &= ~MODPLUG_ENABLE_MEGABASS; } } else if (!g_ascii_strcasecmp (name, "modplug.enable_surround")) { if (intvalue) { data->settings.mFlags |= MODPLUG_ENABLE_SURROUND; } else { data->settings.mFlags &= ~MODPLUG_ENABLE_SURROUND; } } } ModPlug_SetSettings (&data->settings); }
static gboolean xmms_gme_init (xmms_xform_t *xform) { xmms_gme_data_t *data; gme_err_t init_error; GString *file_contents; /* The raw data from the file. */ gme_info_t *metadata = NULL; xmms_config_property_t *val; int loops; int maxlength; const char *subtune_str; int subtune = 0; long fadelen = -1; int samplerate; double stereodepth; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_gme_data_t, 1); xmms_xform_private_data_set (xform, data); val = xmms_xform_config_lookup (xform, "samplerate"); samplerate = xmms_config_property_get_int (val); if (samplerate < 1) samplerate = GME_DEFAULT_SAMPLE_RATE; data->samplerate = samplerate; xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", /* PCM samples */ XMMS_STREAM_TYPE_FMT_FORMAT, XMMS_SAMPLE_FORMAT_S16, /* 16-bit signed */ XMMS_STREAM_TYPE_FMT_CHANNELS, 2, /* stereo */ XMMS_STREAM_TYPE_FMT_SAMPLERATE, samplerate, XMMS_STREAM_TYPE_END); file_contents = g_string_new (""); for (;;) { xmms_error_t error; gchar buf[4096]; gint ret; ret = xmms_xform_read (xform, buf, sizeof (buf), &error); if (ret == -1) { XMMS_DBG ("Error reading emulated music data"); return FALSE; } if (ret == 0) { break; } g_string_append_len (file_contents, buf, ret); } init_error = gme_open_data (file_contents->str, file_contents->len, &data->emu, samplerate); g_string_free (file_contents, TRUE); if (init_error) { XMMS_DBG ("gme_open_data returned an error: %s", init_error); return FALSE; } if (xmms_xform_metadata_get_str (xform, "subtune", &subtune_str)) { subtune = strtol (subtune_str, NULL, 10); XMMS_DBG ("Setting subtune to %d", subtune); if ((subtune < 0 || subtune > gme_track_count (data->emu))) { XMMS_DBG ("Invalid subtune index"); return FALSE; } } else { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_SUBTUNES, gme_track_count (data->emu)); } /* * Get metadata here */ init_error = gme_track_info (data->emu, &metadata, subtune); if (init_error) { XMMS_DBG ("Couldn't get GME track info: %s", init_error); init_error = ""; } else { xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE, metadata->song); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST, metadata->author); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM, metadata->game); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_COMMENT, metadata->comment); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_YEAR, metadata->copyright); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_GENRE, metadata->system); /* I mapped genre to the system type */ val = xmms_xform_config_lookup (xform, "loops"); loops = xmms_config_property_get_int (val); XMMS_DBG ("intro_length = %d, loops = %d, loop_length = %d", metadata->intro_length, loops, metadata->loop_length); if (metadata->intro_length > 0) { if ((loops > 0) && (metadata->loop_length > 0)) { fadelen = metadata->intro_length + loops * metadata->loop_length; XMMS_DBG ("fadelen now = %ld", fadelen); } else { fadelen = metadata->length; XMMS_DBG ("fadelen now = %ld", fadelen); } } } val = xmms_xform_config_lookup (xform, "maxlength"); maxlength = xmms_config_property_get_int (val); XMMS_DBG ("maxlength = %d seconds", maxlength); if (maxlength > 0 && (fadelen < 0 || (maxlength * 1000L < fadelen))) { fadelen = maxlength * 1000L; XMMS_DBG ("fadelen now = %ld", fadelen); } XMMS_DBG ("gme.fadelen = %ld", fadelen); val = xmms_xform_config_lookup (xform, "stereodepth"); stereodepth = xmms_config_property_get_float (val); if (stereodepth >= 0.0 && stereodepth <= 1.0) { XMMS_DBG ("Setting stereo depth to %f.", stereodepth); gme_set_stereo_depth (data->emu, stereodepth); } else { XMMS_DBG ("gme.stereodepth = %f out of range 0.0 - 1.0; not setting.", stereodepth); } init_error = gme_start_track (data->emu, subtune); if (init_error) { XMMS_DBG ("gme_start_track returned an error: %s", init_error); gme_free_info (metadata); return FALSE; } if (fadelen > 0) { XMMS_DBG ("Setting song length and fade length..."); xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, fadelen); gme_set_fade (data->emu, fadelen); } gme_free_info (metadata); return TRUE; }
static gboolean xmms_speex_init (xmms_xform_t *xform) { gint pe; xmms_config_property_t *val; xmms_speex_data_t *data; xmms_error_t error; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_speex_data_t, 1); g_return_val_if_fail (data, FALSE); xmms_xform_private_data_set (xform, data); ogg_sync_init (&data->sync_state); speex_bits_init (&data->speex_bits); /* Find the speex header */ while (42) { gint ret; data->ogg_data = ogg_sync_buffer (&data->sync_state, 1024); ret = xmms_xform_read (xform, data->ogg_data, 1024, &error); ogg_sync_wrote (&data->sync_state, ret); if (ret <= 0) { return FALSE; } if (ogg_sync_pageout (&data->sync_state, &data->ogg_page) == 1) { break; } } ogg_stream_init (&data->stream_state, ogg_page_serialno (&data->ogg_page)); if (ogg_stream_pagein (&data->stream_state, &data->ogg_page) < 0) { return FALSE; } if (ogg_stream_packetout (&data->stream_state, &data->ogg_packet) != 1) { return FALSE; } data->speexheader = speex_packet_to_header ((char *)data->ogg_packet.packet, data->ogg_packet.bytes); data->speex_state = speex_decoder_init (speex_mode_list[data->speexheader->mode]); val = xmms_xform_config_lookup (xform, "perceptual_enhancer"); pe = xmms_config_property_get_int (val); speex_decoder_ctl (data->speex_state, SPEEX_SET_ENH, &pe); ogg_sync_pageout (&data->sync_state, &data->ogg_page); ogg_stream_pagein (&data->stream_state, &data->ogg_page); ogg_stream_packetout (&data->stream_state, &data->ogg_packet); data->samples_buf = g_new (gint16, data->speexheader->frames_per_packet * data->speexheader->frame_size * data->speexheader->nb_channels); data->samples_start = data->samples_buf; data->samples_count = 0; xmms_speex_read_metadata (xform, data); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", XMMS_STREAM_TYPE_FMT_FORMAT, XMMS_SAMPLE_FORMAT_S16, XMMS_STREAM_TYPE_FMT_CHANNELS, data->speexheader->nb_channels, XMMS_STREAM_TYPE_FMT_SAMPLERATE, data->speexheader->rate, XMMS_STREAM_TYPE_END); return TRUE; }
/** * 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; }
static void xmms_eq_config_changed (xmms_object_t * object, xmmsv_t *_data, gpointer userdata) { xmms_config_property_t *val; xmms_equalizer_data_t *priv; const gchar *name; gint value, i, j; g_return_if_fail (object); g_return_if_fail (userdata); val = (xmms_config_property_t *) object; priv = (xmms_equalizer_data_t *) userdata; name = xmms_config_property_get_name (val); value = xmms_config_property_get_int (val); XMMS_DBG ("config value changed! %s => %d", name, value); /* we are passed the full config key, not just the last token, * which makes this code kinda ugly. * fix when bug 97 has been resolved */ name = strrchr (name, '.') + 1; if (!strcmp (name, "enabled")) { priv->enabled = !!value; } else if (!strcmp (name, "extra_filtering")) { priv->extra_filtering = value; } else if (!strcmp (name, "use_legacy")) { gfloat gain; priv->use_legacy = value; if (priv->use_legacy) { for (i=0; i<EQ_BANDS_LEGACY; i++) { gain = xmms_config_property_get_float (priv->legacy[i]); for (j=0; j<EQ_CHANNELS; j++) { set_gain (j, i, xmms_eq_gain_scale (gain, FALSE)); } } } else { for (i=0; i<priv->bands; i++) { gain = xmms_config_property_get_float (priv->gain[i]); for (j=0; j<EQ_CHANNELS; j++) { set_gain (j, i, xmms_eq_gain_scale (gain, FALSE)); } } } } else if (!strcmp (name, "bands")) { if (value != 10 && value != 15 && value != 25 && value != 31) { gchar buf[20]; /* Illegal new value so we restore the old value */ g_snprintf (buf, sizeof (buf), "%d", priv->bands); xmms_config_property_set_data (val, buf); } else { priv->bands = value; for (i=0; i<EQ_MAX_BANDS; i++) { xmms_config_property_set_data (priv->gain[i], "0.0"); if (!priv->use_legacy) { for (j=0; j<EQ_CHANNELS; j++) { set_gain (j, i, xmms_eq_gain_scale (0.0, FALSE)); } } } } } }
static gboolean xmms_eq_init (xmms_xform_t *xform) { xmms_equalizer_data_t *priv; xmms_config_property_t *config; gint i, j, srate; gfloat gain; g_return_val_if_fail (xform, FALSE); priv = g_new0 (xmms_equalizer_data_t, 1); g_return_val_if_fail (priv, FALSE); xmms_xform_private_data_set (xform, priv); config = xmms_xform_config_lookup (xform, "enabled"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_eq_config_changed, priv); priv->enabled = !!xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "bands"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_eq_config_changed, priv); priv->bands = xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "extra_filtering"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_eq_config_changed, priv); priv->extra_filtering = xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "use_legacy"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_eq_config_changed, priv); priv->use_legacy = xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "preamp"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_eq_gain_changed, priv); gain = xmms_config_property_get_float (config); for (i=0; i<EQ_CHANNELS; i++) { set_preamp (i, xmms_eq_gain_scale (gain, TRUE)); } for (i=0; i<EQ_BANDS_LEGACY; i++) { gchar buf[16]; g_snprintf (buf, sizeof (buf), "legacy%d", i); config = xmms_xform_config_lookup (xform, buf); g_return_val_if_fail (config, FALSE); priv->legacy[i] = config; xmms_config_property_callback_set (config, xmms_eq_gain_changed, priv); gain = xmms_config_property_get_float (config); if (priv->use_legacy) { for (j = 0; j < EQ_CHANNELS; j++) { set_gain (i, j, xmms_eq_gain_scale (gain, FALSE)); } } } for (i=0; i<EQ_MAX_BANDS; i++) { gchar buf[16]; g_snprintf (buf, sizeof (buf), "gain%02d", i); config = xmms_xform_config_lookup (xform, buf); g_return_val_if_fail (config, FALSE); priv->gain[i] = config; xmms_config_property_callback_set (config, xmms_eq_gain_changed, priv); gain = xmms_config_property_get_float (config); if (!priv->use_legacy) { for (j = 0; j < EQ_CHANNELS; j++) { set_gain (i, j, xmms_eq_gain_scale (gain, FALSE)); } } } init_iir (); srate = xmms_xform_indata_get_int (xform, XMMS_STREAM_TYPE_FMT_SAMPLERATE); if (priv->use_legacy) { config_iir (srate, EQ_BANDS_LEGACY, 1); } else { config_iir (srate, priv->bands, 0); } xmms_xform_outdata_type_copy (xform); XMMS_DBG ("Equalizer initialized successfully!"); return TRUE; }