From 7b070385bd358caf66f1e8ffdafffc322dbd0737 Mon Sep 17 00:00:00 2001 From: Anton Khirnov Date: Tue, 23 Apr 2013 16:07:38 +0200 Subject: decoder*c: remove tabs --- src/decoder/decoder_control.c | 158 ++++++------- src/decoder/decoder_internal.c | 18 +- src/decoder/decoder_list.c | 138 ++++++------ src/decoder/decoder_plugin.c | 20 +- src/decoder/decoder_print.c | 26 +-- src/decoder/decoder_thread.c | 496 ++++++++++++++++++++--------------------- 6 files changed, 428 insertions(+), 428 deletions(-) diff --git a/src/decoder/decoder_control.c b/src/decoder/decoder_control.c index 5c952d9d..4c7d59da 100644 --- a/src/decoder/decoder_control.c +++ b/src/decoder/decoder_control.c @@ -29,163 +29,163 @@ struct decoder_control * dc_new(GCond *client_cond) { - struct decoder_control *dc = g_new(struct decoder_control, 1); + struct decoder_control *dc = g_new(struct decoder_control, 1); - dc->thread = NULL; + dc->thread = NULL; - dc->mutex = g_mutex_new(); - dc->cond = g_cond_new(); - dc->client_cond = client_cond; + dc->mutex = g_mutex_new(); + dc->cond = g_cond_new(); + dc->client_cond = client_cond; - dc->state = DECODE_STATE_STOP; - dc->command = DECODE_COMMAND_NONE; + dc->state = DECODE_STATE_STOP; + dc->command = DECODE_COMMAND_NONE; - dc->replay_gain_db = 0; - dc->replay_gain_prev_db = 0; - dc->mixramp_start = NULL; - dc->mixramp_end = NULL; - dc->mixramp_prev_end = NULL; + dc->replay_gain_db = 0; + dc->replay_gain_prev_db = 0; + dc->mixramp_start = NULL; + dc->mixramp_end = NULL; + dc->mixramp_prev_end = NULL; - return dc; + return dc; } void dc_free(struct decoder_control *dc) { - g_cond_free(dc->cond); - g_mutex_free(dc->mutex); - g_free(dc->mixramp_start); - g_free(dc->mixramp_end); - g_free(dc->mixramp_prev_end); - g_free(dc); + g_cond_free(dc->cond); + g_mutex_free(dc->mutex); + g_free(dc->mixramp_start); + g_free(dc->mixramp_end); + g_free(dc->mixramp_prev_end); + g_free(dc); } static void dc_command_wait_locked(struct decoder_control *dc) { - while (dc->command != DECODE_COMMAND_NONE) - g_cond_wait(dc->client_cond, dc->mutex); + while (dc->command != DECODE_COMMAND_NONE) + g_cond_wait(dc->client_cond, dc->mutex); } static void dc_command_locked(struct decoder_control *dc, enum decoder_command cmd) { - dc->command = cmd; - decoder_signal(dc); - dc_command_wait_locked(dc); + dc->command = cmd; + decoder_signal(dc); + dc_command_wait_locked(dc); } static void dc_command(struct decoder_control *dc, enum decoder_command cmd) { - decoder_lock(dc); - dc_command_locked(dc, cmd); - decoder_unlock(dc); + decoder_lock(dc); + dc_command_locked(dc, cmd); + decoder_unlock(dc); } static void dc_command_async(struct decoder_control *dc, enum decoder_command cmd) { - decoder_lock(dc); + decoder_lock(dc); - dc->command = cmd; - decoder_signal(dc); + dc->command = cmd; + decoder_signal(dc); - decoder_unlock(dc); + decoder_unlock(dc); } void dc_start(struct decoder_control *dc, struct song *song, unsigned start_ms, unsigned end_ms, int buffer_samples, struct music_pipe *pipe) { - assert(song != NULL); - assert(pipe != NULL); - assert(music_pipe_empty(pipe)); - - dc->song = song; - dc->start_ms = start_ms; - dc->end_ms = end_ms; - dc->buffer_samples = buffer_samples; - dc->pipe = pipe; - dc_command(dc, DECODE_COMMAND_START); + assert(song != NULL); + assert(pipe != NULL); + assert(music_pipe_empty(pipe)); + + dc->song = song; + dc->start_ms = start_ms; + dc->end_ms = end_ms; + dc->buffer_samples = buffer_samples; + dc->pipe = pipe; + dc_command(dc, DECODE_COMMAND_START); } void dc_stop(struct decoder_control *dc) { - decoder_lock(dc); + decoder_lock(dc); - if (dc->command != DECODE_COMMAND_NONE) - /* Attempt to cancel the current command. If it's too - late and the decoder thread is already executing - the old command, we'll call STOP again in this - function (see below). */ - dc_command_locked(dc, DECODE_COMMAND_STOP); + if (dc->command != DECODE_COMMAND_NONE) + /* Attempt to cancel the current command. If it's too + late and the decoder thread is already executing + the old command, we'll call STOP again in this + function (see below). */ + dc_command_locked(dc, DECODE_COMMAND_STOP); - if (dc->state != DECODE_STATE_STOP && dc->state != DECODE_STATE_ERROR) - dc_command_locked(dc, DECODE_COMMAND_STOP); + if (dc->state != DECODE_STATE_STOP && dc->state != DECODE_STATE_ERROR) + dc_command_locked(dc, DECODE_COMMAND_STOP); - decoder_unlock(dc); + decoder_unlock(dc); } bool dc_seek(struct decoder_control *dc, double where) { - assert(dc->state != DECODE_STATE_START); - assert(where >= 0.0); + assert(dc->state != DECODE_STATE_START); + assert(where >= 0.0); - if (dc->state == DECODE_STATE_STOP || - dc->state == DECODE_STATE_ERROR || !dc->seekable) - return false; + if (dc->state == DECODE_STATE_STOP || + dc->state == DECODE_STATE_ERROR || !dc->seekable) + return false; - dc->seek_where = where; - dc->seek_error = false; - dc_command(dc, DECODE_COMMAND_SEEK); + dc->seek_where = where; + dc->seek_error = false; + dc_command(dc, DECODE_COMMAND_SEEK); - if (dc->seek_error) - return false; + if (dc->seek_error) + return false; - return true; + return true; } void dc_quit(struct decoder_control *dc) { - assert(dc->thread != NULL); + assert(dc->thread != NULL); - dc->quit = true; - dc_command_async(dc, DECODE_COMMAND_STOP); + dc->quit = true; + dc_command_async(dc, DECODE_COMMAND_STOP); - g_thread_join(dc->thread); - dc->thread = NULL; + g_thread_join(dc->thread); + dc->thread = NULL; } void dc_mixramp_start(struct decoder_control *dc, char *mixramp_start) { - assert(dc != NULL); + assert(dc != NULL); - g_free(dc->mixramp_start); - dc->mixramp_start = mixramp_start; - g_debug("mixramp_start = %s", mixramp_start ? mixramp_start : "NULL"); + g_free(dc->mixramp_start); + dc->mixramp_start = mixramp_start; + g_debug("mixramp_start = %s", mixramp_start ? mixramp_start : "NULL"); } void dc_mixramp_end(struct decoder_control *dc, char *mixramp_end) { - assert(dc != NULL); + assert(dc != NULL); - g_free(dc->mixramp_end); - dc->mixramp_end = mixramp_end; - g_debug("mixramp_end = %s", mixramp_end ? mixramp_end : "NULL"); + g_free(dc->mixramp_end); + dc->mixramp_end = mixramp_end; + g_debug("mixramp_end = %s", mixramp_end ? mixramp_end : "NULL"); } void dc_mixramp_prev_end(struct decoder_control *dc, char *mixramp_prev_end) { - assert(dc != NULL); + assert(dc != NULL); - g_free(dc->mixramp_prev_end); - dc->mixramp_prev_end = mixramp_prev_end; - g_debug("mixramp_prev_end = %s", mixramp_prev_end ? mixramp_prev_end : "NULL"); + g_free(dc->mixramp_prev_end); + dc->mixramp_prev_end = mixramp_prev_end; + g_debug("mixramp_prev_end = %s", mixramp_prev_end ? mixramp_prev_end : "NULL"); } diff --git a/src/decoder/decoder_internal.c b/src/decoder/decoder_internal.c index cd8f03c1..3d62ea30 100644 --- a/src/decoder/decoder_internal.c +++ b/src/decoder/decoder_internal.c @@ -33,18 +33,18 @@ static enum decoder_command need_chunks(struct decoder_control *dc, bool do_wait) { - if (dc->command == DECODE_COMMAND_STOP || - dc->command == DECODE_COMMAND_SEEK) - return dc->command; + if (dc->command == DECODE_COMMAND_STOP || + dc->command == DECODE_COMMAND_SEEK) + return dc->command; - if (do_wait) { - decoder_wait(dc); - g_cond_signal(dc->client_cond); + if (do_wait) { + decoder_wait(dc); + g_cond_signal(dc->client_cond); - return dc->command; - } + return dc->command; + } - return DECODE_COMMAND_NONE; + return DECODE_COMMAND_NONE; } struct music_chunk *decoder_get_chunk(struct decoder *decoder) diff --git a/src/decoder/decoder_list.c b/src/decoder/decoder_list.c index d9437e86..ee65658d 100644 --- a/src/decoder/decoder_list.c +++ b/src/decoder/decoder_list.c @@ -31,12 +31,12 @@ extern const struct decoder_plugin libav_decoder_plugin; const struct decoder_plugin *const decoder_plugins[] = { - &libav_decoder_plugin, - NULL + &libav_decoder_plugin, + NULL }; enum { - num_decoder_plugins = G_N_ELEMENTS(decoder_plugins) - 1, + num_decoder_plugins = G_N_ELEMENTS(decoder_plugins) - 1, }; /** which plugins have been initialized successfully? */ @@ -45,70 +45,70 @@ bool decoder_plugins_enabled[num_decoder_plugins]; static unsigned decoder_plugin_index(const struct decoder_plugin *plugin) { - unsigned i = 0; + unsigned i = 0; - while (decoder_plugins[i] != plugin) - ++i; + while (decoder_plugins[i] != plugin) + ++i; - return i; + return i; } static unsigned decoder_plugin_next_index(const struct decoder_plugin *plugin) { - return plugin == 0 - ? 0 /* start with first plugin */ - : decoder_plugin_index(plugin) + 1; + return plugin == 0 + ? 0 /* start with first plugin */ + : decoder_plugin_index(plugin) + 1; } const struct decoder_plugin * decoder_plugin_from_suffix(const char *suffix, - const struct decoder_plugin *plugin) + const struct decoder_plugin *plugin) { - if (suffix == NULL) - return NULL; - - for (unsigned i = decoder_plugin_next_index(plugin); - decoder_plugins[i] != NULL; ++i) { - plugin = decoder_plugins[i]; - if (decoder_plugins_enabled[i] && - decoder_plugin_supports_suffix(plugin, suffix)) - return plugin; - } - - return NULL; + if (suffix == NULL) + return NULL; + + for (unsigned i = decoder_plugin_next_index(plugin); + decoder_plugins[i] != NULL; ++i) { + plugin = decoder_plugins[i]; + if (decoder_plugins_enabled[i] && + decoder_plugin_supports_suffix(plugin, suffix)) + return plugin; + } + + return NULL; } const struct decoder_plugin * decoder_plugin_from_mime_type(const char *mimeType, unsigned int next) { - static unsigned i = num_decoder_plugins; - - if (mimeType == NULL) - return NULL; - - if (!next) - i = 0; - for (; decoder_plugins[i] != NULL; ++i) { - const struct decoder_plugin *plugin = decoder_plugins[i]; - if (decoder_plugins_enabled[i] && - decoder_plugin_supports_mime_type(plugin, mimeType)) { - ++i; - return plugin; - } - } - - return NULL; + static unsigned i = num_decoder_plugins; + + if (mimeType == NULL) + return NULL; + + if (!next) + i = 0; + for (; decoder_plugins[i] != NULL; ++i) { + const struct decoder_plugin *plugin = decoder_plugins[i]; + if (decoder_plugins_enabled[i] && + decoder_plugin_supports_mime_type(plugin, mimeType)) { + ++i; + return plugin; + } + } + + return NULL; } const struct decoder_plugin * decoder_plugin_from_name(const char *name) { - decoder_plugins_for_each_enabled(plugin) - if (strcmp(plugin->name, name) == 0) - return plugin; + decoder_plugins_for_each_enabled(plugin) + if (strcmp(plugin->name, name) == 0) + return plugin; - return NULL; + return NULL; } /** @@ -120,40 +120,40 @@ decoder_plugin_from_name(const char *name) static const struct config_param * decoder_plugin_config(const char *plugin_name) { - const struct config_param *param = NULL; + const struct config_param *param = NULL; - while ((param = config_get_next_param(CONF_DECODER, param)) != NULL) { - const char *name = - config_get_block_string(param, "plugin", NULL); - if (name == NULL) - MPD_ERROR("decoder configuration without 'plugin' name in line %d", - param->line); + while ((param = config_get_next_param(CONF_DECODER, param)) != NULL) { + const char *name = + config_get_block_string(param, "plugin", NULL); + if (name == NULL) + MPD_ERROR("decoder configuration without 'plugin' name in line %d", + param->line); - if (strcmp(name, plugin_name) == 0) - return param; - } + if (strcmp(name, plugin_name) == 0) + return param; + } - return NULL; + return NULL; } void decoder_plugin_init_all(void) { - for (unsigned i = 0; decoder_plugins[i] != NULL; ++i) { - const struct decoder_plugin *plugin = decoder_plugins[i]; - const struct config_param *param = - decoder_plugin_config(plugin->name); - - if (!config_get_block_bool(param, "enabled", true)) - /* the plugin is disabled in mpd.conf */ - continue; - - if (decoder_plugin_init(plugin, param)) - decoder_plugins_enabled[i] = true; - } + for (unsigned i = 0; decoder_plugins[i] != NULL; ++i) { + const struct decoder_plugin *plugin = decoder_plugins[i]; + const struct config_param *param = + decoder_plugin_config(plugin->name); + + if (!config_get_block_bool(param, "enabled", true)) + /* the plugin is disabled in mpd.conf */ + continue; + + if (decoder_plugin_init(plugin, param)) + decoder_plugins_enabled[i] = true; + } } void decoder_plugin_deinit_all(void) { - decoder_plugins_for_each_enabled(plugin) - decoder_plugin_finish(plugin); + decoder_plugins_for_each_enabled(plugin) + decoder_plugin_finish(plugin); } diff --git a/src/decoder/decoder_plugin.c b/src/decoder/decoder_plugin.c index d32043f0..c79801ca 100644 --- a/src/decoder/decoder_plugin.c +++ b/src/decoder/decoder_plugin.c @@ -25,23 +25,23 @@ bool decoder_plugin_supports_suffix(const struct decoder_plugin *plugin, - const char *suffix) + const char *suffix) { - assert(plugin != NULL); - assert(suffix != NULL); + assert(plugin != NULL); + assert(suffix != NULL); - return plugin->suffixes != NULL && - string_array_contains(plugin->suffixes, suffix); + return plugin->suffixes != NULL && + string_array_contains(plugin->suffixes, suffix); } bool decoder_plugin_supports_mime_type(const struct decoder_plugin *plugin, - const char *mime_type) + const char *mime_type) { - assert(plugin != NULL); - assert(mime_type != NULL); + assert(plugin != NULL); + assert(mime_type != NULL); - return plugin->mime_types != NULL && - string_array_contains(plugin->mime_types, mime_type); + return plugin->mime_types != NULL && + string_array_contains(plugin->mime_types, mime_type); } diff --git a/src/decoder/decoder_print.c b/src/decoder/decoder_print.c index e14477ed..67270211 100644 --- a/src/decoder/decoder_print.c +++ b/src/decoder/decoder_print.c @@ -27,27 +27,27 @@ static void decoder_plugin_print(struct client *client, - const struct decoder_plugin *plugin) + const struct decoder_plugin *plugin) { - const char *const*p; + const char *const*p; - assert(plugin != NULL); - assert(plugin->name != NULL); + assert(plugin != NULL); + assert(plugin->name != NULL); - client_printf(client, "plugin: %s\n", plugin->name); + client_printf(client, "plugin: %s\n", plugin->name); - if (plugin->suffixes != NULL) - for (p = plugin->suffixes; *p != NULL; ++p) - client_printf(client, "suffix: %s\n", *p); + if (plugin->suffixes != NULL) + for (p = plugin->suffixes; *p != NULL; ++p) + client_printf(client, "suffix: %s\n", *p); - if (plugin->mime_types != NULL) - for (p = plugin->mime_types; *p != NULL; ++p) - client_printf(client, "mime_type: %s\n", *p); + if (plugin->mime_types != NULL) + for (p = plugin->mime_types; *p != NULL; ++p) + client_printf(client, "mime_type: %s\n", *p); } void decoder_list_print(struct client *client) { - decoder_plugins_for_each_enabled(plugin) - decoder_plugin_print(client, plugin); + decoder_plugins_for_each_enabled(plugin) + decoder_plugin_print(client, plugin); } diff --git a/src/decoder/decoder_thread.c b/src/decoder/decoder_thread.c index 964f1318..59ff26db 100644 --- a/src/decoder/decoder_thread.c +++ b/src/decoder/decoder_thread.c @@ -51,11 +51,11 @@ static void decoder_command_finished_locked(struct decoder_control *dc) { - assert(dc->command != DECODE_COMMAND_NONE); + assert(dc->command != DECODE_COMMAND_NONE); - dc->command = DECODE_COMMAND_NONE; + dc->command = DECODE_COMMAND_NONE; - g_cond_signal(dc->client_cond); + g_cond_signal(dc->client_cond); } /** @@ -72,108 +72,108 @@ decoder_command_finished_locked(struct decoder_control *dc) static struct input_stream * decoder_input_stream_open(struct decoder_control *dc, const char *uri) { - GError *error = NULL; - struct input_stream *is; + GError *error = NULL; + struct input_stream *is; - is = input_stream_open(uri, dc->mutex, dc->cond, &error); - if (is == NULL) { - if (error != NULL) { - g_warning("%s", error->message); - g_error_free(error); - } + is = input_stream_open(uri, dc->mutex, dc->cond, &error); + if (is == NULL) { + if (error != NULL) { + g_warning("%s", error->message); + g_error_free(error); + } - return NULL; - } + return NULL; + } - /* wait for the input stream to become ready; its metadata - will be available then */ + /* wait for the input stream to become ready; its metadata + will be available then */ - decoder_lock(dc); + decoder_lock(dc); - input_stream_update(is); - while (!is->ready && - dc->command != DECODE_COMMAND_STOP) { - decoder_wait(dc); + input_stream_update(is); + while (!is->ready && + dc->command != DECODE_COMMAND_STOP) { + decoder_wait(dc); - input_stream_update(is); - } + input_stream_update(is); + } - if (!input_stream_check(is, &error)) { - decoder_unlock(dc); + if (!input_stream_check(is, &error)) { + decoder_unlock(dc); - g_warning("%s", error->message); - g_error_free(error); + g_warning("%s", error->message); + g_error_free(error); - return NULL; - } + return NULL; + } - decoder_unlock(dc); + decoder_unlock(dc); - return is; + return is; } static bool decoder_stream_decode(const struct decoder_plugin *plugin, - struct decoder *decoder, - struct input_stream *input_stream) + struct decoder *decoder, + struct input_stream *input_stream) { - assert(plugin != NULL); - assert(plugin->stream_decode != NULL); - assert(decoder != NULL); - assert(decoder->stream_tag == NULL); - assert(decoder->decoder_tag == NULL); - assert(input_stream != NULL); - assert(input_stream->ready); - assert(decoder->dc->state == DECODE_STATE_START); + assert(plugin != NULL); + assert(plugin->stream_decode != NULL); + assert(decoder != NULL); + assert(decoder->stream_tag == NULL); + assert(decoder->decoder_tag == NULL); + assert(input_stream != NULL); + assert(input_stream->ready); + assert(decoder->dc->state == DECODE_STATE_START); - g_debug("probing plugin %s", plugin->name); + g_debug("probing plugin %s", plugin->name); - if (decoder->dc->command == DECODE_COMMAND_STOP) - return true; + if (decoder->dc->command == DECODE_COMMAND_STOP) + return true; - /* rewind the stream, so each plugin gets a fresh start */ - input_stream_seek(input_stream, 0, SEEK_SET, NULL); + /* rewind the stream, so each plugin gets a fresh start */ + input_stream_seek(input_stream, 0, SEEK_SET, NULL); - decoder_unlock(decoder->dc); + decoder_unlock(decoder->dc); - decoder_plugin_stream_decode(plugin, decoder, input_stream); + decoder_plugin_stream_decode(plugin, decoder, input_stream); - decoder_lock(decoder->dc); + decoder_lock(decoder->dc); - assert(decoder->dc->state == DECODE_STATE_START || - decoder->dc->state == DECODE_STATE_DECODE); + assert(decoder->dc->state == DECODE_STATE_START || + decoder->dc->state == DECODE_STATE_DECODE); - return decoder->dc->state != DECODE_STATE_START; + return decoder->dc->state != DECODE_STATE_START; } static bool decoder_file_decode(const struct decoder_plugin *plugin, - struct decoder *decoder, const char *path) + struct decoder *decoder, const char *path) { - assert(plugin != NULL); - assert(plugin->file_decode != NULL); - assert(decoder != NULL); - assert(decoder->stream_tag == NULL); - assert(decoder->decoder_tag == NULL); - assert(path != NULL); - assert(g_path_is_absolute(path)); - assert(decoder->dc->state == DECODE_STATE_START); + assert(plugin != NULL); + assert(plugin->file_decode != NULL); + assert(decoder != NULL); + assert(decoder->stream_tag == NULL); + assert(decoder->decoder_tag == NULL); + assert(path != NULL); + assert(g_path_is_absolute(path)); + assert(decoder->dc->state == DECODE_STATE_START); - g_debug("probing plugin %s", plugin->name); + g_debug("probing plugin %s", plugin->name); - if (decoder->dc->command == DECODE_COMMAND_STOP) - return true; + if (decoder->dc->command == DECODE_COMMAND_STOP) + return true; - decoder_unlock(decoder->dc); + decoder_unlock(decoder->dc); - decoder_plugin_file_decode(plugin, decoder, path); + decoder_plugin_file_decode(plugin, decoder, path); - decoder_lock(decoder->dc); + decoder_lock(decoder->dc); - assert(decoder->dc->state == DECODE_STATE_START || - decoder->dc->state == DECODE_STATE_DECODE); + assert(decoder->dc->state == DECODE_STATE_START || + decoder->dc->state == DECODE_STATE_DECODE); - return decoder->dc->state != DECODE_STATE_START; + return decoder->dc->state != DECODE_STATE_START; } /** @@ -182,12 +182,12 @@ decoder_file_decode(const struct decoder_plugin *plugin, static inline gpointer deconst_plugin(const struct decoder_plugin *plugin) { - union { - const struct decoder_plugin *in; - gpointer out; - } u = { .in = plugin }; + union { + const struct decoder_plugin *in; + gpointer out; + } u = { .in = plugin }; - return u.out; + return u.out; } /** @@ -197,31 +197,31 @@ deconst_plugin(const struct decoder_plugin *plugin) */ static bool decoder_run_stream_mime_type(struct decoder *decoder, struct input_stream *is, - GSList **tried_r) + GSList **tried_r) { - assert(tried_r != NULL); + assert(tried_r != NULL); - const struct decoder_plugin *plugin; - unsigned int next = 0; + const struct decoder_plugin *plugin; + unsigned int next = 0; - if (is->mime == NULL) - return false; + if (is->mime == NULL) + return false; - while ((plugin = decoder_plugin_from_mime_type(is->mime, next++))) { - if (plugin->stream_decode == NULL) - continue; + while ((plugin = decoder_plugin_from_mime_type(is->mime, next++))) { + if (plugin->stream_decode == NULL) + continue; - if (g_slist_find(*tried_r, plugin) != NULL) - /* don't try a plugin twice */ - continue; + if (g_slist_find(*tried_r, plugin) != NULL) + /* don't try a plugin twice */ + continue; - if (decoder_stream_decode(plugin, decoder, is)) - return true; + if (decoder_stream_decode(plugin, decoder, is)) + return true; - *tried_r = g_slist_prepend(*tried_r, deconst_plugin(plugin)); - } + *tried_r = g_slist_prepend(*tried_r, deconst_plugin(plugin)); + } - return false; + return false; } /** @@ -232,31 +232,31 @@ decoder_run_stream_mime_type(struct decoder *decoder, struct input_stream *is, */ static bool decoder_run_stream_suffix(struct decoder *decoder, struct input_stream *is, - const char *uri, GSList **tried_r) + const char *uri, GSList **tried_r) { - assert(tried_r != NULL); + assert(tried_r != NULL); - const char *suffix = uri_get_suffix(uri); - const struct decoder_plugin *plugin = NULL; + const char *suffix = uri_get_suffix(uri); + const struct decoder_plugin *plugin = NULL; - if (suffix == NULL) - return false; + if (suffix == NULL) + return false; - while ((plugin = decoder_plugin_from_suffix(suffix, plugin)) != NULL) { - if (plugin->stream_decode == NULL) - continue; + while ((plugin = decoder_plugin_from_suffix(suffix, plugin)) != NULL) { + if (plugin->stream_decode == NULL) + continue; - if (g_slist_find(*tried_r, plugin) != NULL) - /* don't try a plugin twice */ - continue; + if (g_slist_find(*tried_r, plugin) != NULL) + /* don't try a plugin twice */ + continue; - if (decoder_stream_decode(plugin, decoder, is)) - return true; + if (decoder_stream_decode(plugin, decoder, is)) + return true; - *tried_r = g_slist_prepend(*tried_r, deconst_plugin(plugin)); - } + *tried_r = g_slist_prepend(*tried_r, deconst_plugin(plugin)); + } - return false; + return false; } /** @@ -265,11 +265,11 @@ decoder_run_stream_suffix(struct decoder *decoder, struct input_stream *is, static bool decoder_run_stream_fallback(struct decoder *decoder, struct input_stream *is) { - const struct decoder_plugin *plugin; + const struct decoder_plugin *plugin; - plugin = decoder_plugin_from_name("mad"); - return plugin != NULL && plugin->stream_decode != NULL && - decoder_stream_decode(plugin, decoder, is); + plugin = decoder_plugin_from_name("mad"); + return plugin != NULL && plugin->stream_decode != NULL && + decoder_stream_decode(plugin, decoder, is); } /** @@ -278,40 +278,40 @@ decoder_run_stream_fallback(struct decoder *decoder, struct input_stream *is) static bool decoder_run_stream(struct decoder *decoder, const char *uri) { - struct decoder_control *dc = decoder->dc; - struct input_stream *input_stream; - bool success; + struct decoder_control *dc = decoder->dc; + struct input_stream *input_stream; + bool success; - decoder_unlock(dc); + decoder_unlock(dc); - input_stream = decoder_input_stream_open(dc, uri); - if (input_stream == NULL) { - decoder_lock(dc); - return false; - } + input_stream = decoder_input_stream_open(dc, uri); + if (input_stream == NULL) { + decoder_lock(dc); + return false; + } - decoder_lock(dc); + decoder_lock(dc); - GSList *tried = NULL; + GSList *tried = NULL; - success = dc->command == DECODE_COMMAND_STOP || - /* first we try mime types: */ - decoder_run_stream_mime_type(decoder, input_stream, &tried) || - /* if that fails, try suffix matching the URL: */ - decoder_run_stream_suffix(decoder, input_stream, uri, - &tried) || - /* fallback to mp3: this is needed for bastard streams - that don't have a suffix or set the mimeType */ - (tried == NULL && - decoder_run_stream_fallback(decoder, input_stream)); + success = dc->command == DECODE_COMMAND_STOP || + /* first we try mime types: */ + decoder_run_stream_mime_type(decoder, input_stream, &tried) || + /* if that fails, try suffix matching the URL: */ + decoder_run_stream_suffix(decoder, input_stream, uri, + &tried) || + /* fallback to mp3: this is needed for bastard streams + that don't have a suffix or set the mimeType */ + (tried == NULL && + decoder_run_stream_fallback(decoder, input_stream)); - g_slist_free(tried); + g_slist_free(tried); - decoder_unlock(dc); - input_stream_close(input_stream); - decoder_lock(dc); + decoder_unlock(dc); + input_stream_close(input_stream); + decoder_lock(dc); - return success; + return success; } /** @@ -321,9 +321,9 @@ decoder_run_stream(struct decoder *decoder, const char *uri) static void decoder_load_replay_gain(struct decoder *decoder, const char *path_fs) { - struct replay_gain_info info; - if (replay_gain_ape_read(path_fs, &info)) - decoder_replay_gain(decoder, &info); + struct replay_gain_info info; + if (replay_gain_ape_read(path_fs, &info)) + decoder_replay_gain(decoder, &info); } /** @@ -332,174 +332,174 @@ decoder_load_replay_gain(struct decoder *decoder, const char *path_fs) static bool decoder_run_file(struct decoder *decoder, const char *path_fs) { - struct decoder_control *dc = decoder->dc; - const char *suffix = uri_get_suffix(path_fs); - const struct decoder_plugin *plugin = NULL; + struct decoder_control *dc = decoder->dc; + const char *suffix = uri_get_suffix(path_fs); + const struct decoder_plugin *plugin = NULL; - if (suffix == NULL) - return false; + if (suffix == NULL) + return false; - decoder_unlock(dc); + decoder_unlock(dc); - decoder_load_replay_gain(decoder, path_fs); + decoder_load_replay_gain(decoder, path_fs); - while ((plugin = decoder_plugin_from_suffix(suffix, plugin)) != NULL) { - if (plugin->file_decode != NULL) { - decoder_lock(dc); + while ((plugin = decoder_plugin_from_suffix(suffix, plugin)) != NULL) { + if (plugin->file_decode != NULL) { + decoder_lock(dc); - if (decoder_file_decode(plugin, decoder, path_fs)) - return true; + if (decoder_file_decode(plugin, decoder, path_fs)) + return true; - decoder_unlock(dc); - } else if (plugin->stream_decode != NULL) { - struct input_stream *input_stream; - bool success; + decoder_unlock(dc); + } else if (plugin->stream_decode != NULL) { + struct input_stream *input_stream; + bool success; - input_stream = decoder_input_stream_open(dc, path_fs); - if (input_stream == NULL) - continue; + input_stream = decoder_input_stream_open(dc, path_fs); + if (input_stream == NULL) + continue; - decoder_lock(dc); + decoder_lock(dc); - success = decoder_stream_decode(plugin, decoder, - input_stream); + success = decoder_stream_decode(plugin, decoder, + input_stream); - decoder_unlock(dc); + decoder_unlock(dc); - input_stream_close(input_stream); + input_stream_close(input_stream); - if (success) { - decoder_lock(dc); - return true; - } - } - } + if (success) { + decoder_lock(dc); + return true; + } + } + } - decoder_lock(dc); - return false; + decoder_lock(dc); + return false; } static void decoder_run_song(struct decoder_control *dc, - const struct song *song, const char *uri) + const struct song *song, const char *uri) { - struct decoder decoder = { - .dc = dc, - .initial_seek_pending = dc->start_ms > 0, - .initial_seek_running = false, - }; - int ret; + struct decoder decoder = { + .dc = dc, + .initial_seek_pending = dc->start_ms > 0, + .initial_seek_running = false, + }; + int ret; - decoder.timestamp = 0.0; - decoder.seeking = false; - decoder.song_tag = song->tag != NULL && song_is_file(song) - ? tag_dup(song->tag) : NULL; - decoder.stream_tag = NULL; - decoder.decoder_tag = NULL; + decoder.timestamp = 0.0; + decoder.seeking = false; + decoder.song_tag = song->tag != NULL && song_is_file(song) + ? tag_dup(song->tag) : NULL; + decoder.stream_tag = NULL; + decoder.decoder_tag = NULL; - dc->state = DECODE_STATE_START; + dc->state = DECODE_STATE_START; - decoder_command_finished_locked(dc); + decoder_command_finished_locked(dc); - pcm_convert_init(&decoder.conv_state); + pcm_convert_init(&decoder.conv_state); - ret = song_is_file(song) - ? decoder_run_file(&decoder, uri) - : decoder_run_stream(&decoder, uri); + ret = song_is_file(song) + ? decoder_run_file(&decoder, uri) + : decoder_run_stream(&decoder, uri); - decoder_unlock(dc); + decoder_unlock(dc); - pcm_convert_deinit(&decoder.conv_state); + pcm_convert_deinit(&decoder.conv_state); - if (decoder.song_tag != NULL) - tag_free(decoder.song_tag); + if (decoder.song_tag != NULL) + tag_free(decoder.song_tag); - if (decoder.stream_tag != NULL) - tag_free(decoder.stream_tag); + if (decoder.stream_tag != NULL) + tag_free(decoder.stream_tag); - if (decoder.decoder_tag != NULL) - tag_free(decoder.decoder_tag); + if (decoder.decoder_tag != NULL) + tag_free(decoder.decoder_tag); - decoder_lock(dc); + decoder_lock(dc); - dc->state = ret ? DECODE_STATE_STOP : DECODE_STATE_ERROR; + dc->state = ret ? DECODE_STATE_STOP : DECODE_STATE_ERROR; } static void decoder_run(struct decoder_control *dc) { - const struct song *song = dc->song; - char *uri; + const struct song *song = dc->song; + char *uri; - assert(song != NULL); + assert(song != NULL); - if (song_is_file(song)) - uri = map_song_fs(song); - else - uri = song_get_uri(song); + if (song_is_file(song)) + uri = map_song_fs(song); + else + uri = song_get_uri(song); - if (uri == NULL) { - dc->state = DECODE_STATE_ERROR; - decoder_command_finished_locked(dc); - return; - } + if (uri == NULL) { + dc->state = DECODE_STATE_ERROR; + decoder_command_finished_locked(dc); + return; + } - decoder_run_song(dc, song, uri); - g_free(uri); + decoder_run_song(dc, song, uri); + g_free(uri); } static gpointer decoder_task(gpointer arg) { - struct decoder_control *dc = arg; + struct decoder_control *dc = arg; - decoder_lock(dc); + decoder_lock(dc); - do { - assert(dc->state == DECODE_STATE_STOP || - dc->state == DECODE_STATE_ERROR); + do { + assert(dc->state == DECODE_STATE_STOP || + dc->state == DECODE_STATE_ERROR); - switch (dc->command) { - case DECODE_COMMAND_START: - g_debug("clearing mixramp tags"); - dc_mixramp_start(dc, NULL); - dc_mixramp_prev_end(dc, dc->mixramp_end); - dc->mixramp_end = NULL; /* Don't free, it's copied above. */ - dc->replay_gain_prev_db = dc->replay_gain_db; - dc->replay_gain_db = 0; + switch (dc->command) { + case DECODE_COMMAND_START: + g_debug("clearing mixramp tags"); + dc_mixramp_start(dc, NULL); + dc_mixramp_prev_end(dc, dc->mixramp_end); + dc->mixramp_end = NULL; /* Don't free, it's copied above. */ + dc->replay_gain_prev_db = dc->replay_gain_db; + dc->replay_gain_db = 0; /* fall through */ - case DECODE_COMMAND_SEEK: - decoder_run(dc); - break; + case DECODE_COMMAND_SEEK: + decoder_run(dc); + break; - case DECODE_COMMAND_STOP: - decoder_command_finished_locked(dc); - break; + case DECODE_COMMAND_STOP: + decoder_command_finished_locked(dc); + break; - case DECODE_COMMAND_NONE: - decoder_wait(dc); - break; - } - } while (dc->command != DECODE_COMMAND_NONE || !dc->quit); + case DECODE_COMMAND_NONE: + decoder_wait(dc); + break; + } + } while (dc->command != DECODE_COMMAND_NONE || !dc->quit); - decoder_unlock(dc); + decoder_unlock(dc); - return NULL; + return NULL; } void decoder_thread_start(struct decoder_control *dc) { - GError *e = NULL; + GError *e = NULL; - assert(dc->thread == NULL); + assert(dc->thread == NULL); - dc->quit = false; + dc->quit = false; - dc->thread = g_thread_create(decoder_task, dc, true, &e); - if (dc->thread == NULL) - MPD_ERROR("Failed to spawn decoder task: %s", e->message); + dc->thread = g_thread_create(decoder_task, dc, true, &e); + if (dc->thread == NULL) + MPD_ERROR("Failed to spawn decoder task: %s", e->message); } -- cgit v1.2.3