/**
* 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;
}
