int main(int argc, char **argv)
{
if (argc != 3) {
g_printerr("Usage: read_conf FILE SETTING\n");
return 1;
}
const char *path = argv[1];
const char *name = argv[2];
g_log_set_default_handler(my_log_func, NULL);
config_global_init();
GError *error = NULL;
bool success = config_read_file(path, &error);
if (!success) {
g_printerr("%s:", error->message);
g_error_free(error);
return 1;
}
const char *value = config_get_string(name, NULL);
int ret;
if (value != NULL) {
g_print("%s\n", value);
ret = 0;
} else {
g_printerr("No such setting: %s\n", name);
ret = 2;
}
config_global_finish();
return ret;
}
int main(int argc, char **argv)
{
GError *error = NULL;
struct input_stream *is;
int ret;
if (argc != 2) {
g_printerr("Usage: run_input URI\n");
return 1;
}
/* initialize GLib */
g_thread_init(NULL);
g_log_set_default_handler(my_log_func, NULL);
/* initialize MPD */
tag_pool_init();
config_global_init();
#ifdef ENABLE_ARCHIVE
archive_plugin_init_all();
#endif
if (!input_stream_global_init(&error)) {
g_warning("%s", error->message);
g_error_free(error);
return 2;
}
/* open the stream and dump it */
is = input_stream_open(argv[1], &error);
if (is != NULL) {
ret = dump_input_stream(is);
input_stream_close(is);
} else {
if (error != NULL) {
g_warning("%s", error->message);
g_error_free(error);
} else
g_printerr("input_stream_open() failed\n");
ret = 2;
}
/* deinitialize everything */
input_stream_global_finish();
#ifdef ENABLE_ARCHIVE
archive_plugin_deinit_all();
#endif
config_global_finish();
tag_pool_deinit();
return ret;
}
int main(int argc, char *argv[])
{
struct options options;
clock_t start;
bool create_db;
GError *error = NULL;
bool success;
daemonize_close_stdin();
#ifdef HAVE_LOCALE_H
/* initialize locale */
setlocale(LC_CTYPE,"");
#endif
g_set_application_name("Music Player Daemon");
/* enable GLib's thread safety code */
g_thread_init(NULL);
winsock_init();
idle_init();
dirvec_init();
songvec_init();
tag_pool_init();
config_global_init();
success = parse_cmdline(argc, argv, &options, &error);
if (!success) {
g_warning("%s", error->message);
g_error_free(error);
return EXIT_FAILURE;
}
glue_daemonize_init(&options);
stats_global_init();
tag_lib_init();
log_init(options.verbose, options.log_stderr);
success = listen_global_init(&error);
if (!success) {
g_warning("%s", error->message);
g_error_free(error);
return EXIT_FAILURE;
}
daemonize_set_user();
main_task = g_thread_self();
main_loop = g_main_loop_new(NULL, FALSE);
main_cond = g_cond_new();
event_pipe_init();
event_pipe_register(PIPE_EVENT_IDLE, idle_event_emitted);
path_global_init();
glue_mapper_init();
initPermissions();
playlist_global_init();
spl_global_init();
#ifdef ENABLE_ARCHIVE
archive_plugin_init_all();
#endif
decoder_plugin_init_all();
update_global_init();
create_db = !glue_db_init_and_load();
glue_sticker_init();
command_init();
initialize_decoder_and_player();
volume_init();
initAudioConfig();
audio_output_all_init();
client_manager_init();
replay_gain_global_init();
if (!input_stream_global_init(&error)) {
g_warning("%s", error->message);
g_error_free(error);
return EXIT_FAILURE;
}
playlist_list_global_init();
daemonize(options.daemon);
setup_log_output(options.log_stderr);
initSigHandlers();
initZeroconf();
player_create();
if (create_db) {
/* the database failed to load: recreate the
database */
unsigned job = update_enqueue(NULL, true);
if (job == 0)
g_error("directory update failed");
}
glue_state_file_init();
success = config_get_bool(CONF_AUTO_UPDATE, false);
#ifdef ENABLE_INOTIFY
if (success && mapper_has_music_directory())
mpd_inotify_init();
#else
if (success)
g_warning("inotify: auto_update was disabled. enable during compilation phase");
#endif
config_global_check();
/* enable all audio outputs (if not already done by
playlist_state_restore() */
pc_update_audio();
/* run the main loop */
g_main_loop_run(main_loop);
/* cleanup */
g_main_loop_unref(main_loop);
#ifdef ENABLE_INOTIFY
mpd_inotify_finish();
#endif
state_file_finish();
pc_kill();
finishZeroconf();
client_manager_deinit();
listen_global_finish();
playlist_global_finish();
start = clock();
db_finish();
g_debug("db_finish took %f seconds",
((float)(clock()-start))/CLOCKS_PER_SEC);
#ifdef ENABLE_SQLITE
sticker_global_finish();
#endif
g_cond_free(main_cond);
event_pipe_deinit();
playlist_list_global_finish();
input_stream_global_finish();
audio_output_all_finish();
volume_finish();
mapper_finish();
path_global_finish();
finishPermissions();
pc_deinit();
command_finish();
update_global_finish();
decoder_plugin_deinit_all();
#ifdef ENABLE_ARCHIVE
archive_plugin_deinit_all();
#endif
config_global_finish();
tag_pool_deinit();
songvec_deinit();
dirvec_deinit();
idle_deinit();
stats_global_finish();
daemonize_finish();
#ifdef WIN32
WSACleanup();
#endif
close_log_files();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
struct audio_output ao;
struct audio_format audio_format;
struct audio_format_string af_string;
bool success;
GError *error = NULL;
char buffer[4096];
ssize_t nbytes;
size_t frame_size, length = 0, play_length, consumed;
if (argc < 3 || argc > 4) {
g_printerr("Usage: run_output CONFIG NAME [FORMAT] <IN\n");
return 1;
}
audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2);
g_thread_init(NULL);
/* read configuration file (mpd.conf) */
config_global_init();
success = config_read_file(argv[1], &error);
if (!success) {
g_printerr("%s:", error->message);
g_error_free(error);
return 1;
}
/* initialize the audio output */
if (!load_audio_output(&ao, argv[2]))
return 1;
/* parse the audio format */
if (argc > 3) {
success = audio_format_parse(&audio_format, argv[3],
false, &error);
if (!success) {
g_printerr("Failed to parse audio format: %s\n",
error->message);
g_error_free(error);
return 1;
}
}
/* open the audio output */
success = ao_plugin_open(ao.plugin, ao.data, &audio_format, &error);
if (!success) {
g_printerr("Failed to open audio output: %s\n",
error->message);
g_error_free(error);
return 1;
}
g_printerr("audio_format=%s\n",
audio_format_to_string(&audio_format, &af_string));
frame_size = audio_format_frame_size(&audio_format);
/* play */
while (true) {
if (length < sizeof(buffer)) {
nbytes = read(0, buffer + length, sizeof(buffer) - length);
if (nbytes <= 0)
break;
length += (size_t)nbytes;
}
play_length = (length / frame_size) * frame_size;
if (play_length > 0) {
consumed = ao_plugin_play(ao.plugin, ao.data,
buffer, play_length,
&error);
if (consumed == 0) {
g_printerr("Failed to play: %s\n",
error->message);
g_error_free(error);
return 1;
}
assert(consumed <= length);
assert(consumed % frame_size == 0);
length -= consumed;
memmove(buffer, buffer + consumed, length);
}
}
/* cleanup and exit */
ao_plugin_close(ao.plugin, ao.data);
ao_plugin_finish(ao.plugin, ao.data);
g_mutex_free(ao.mutex);
config_global_finish();
return 0;
}
int main(int argc, char **argv)
{
struct audio_format audio_format;
struct audio_format_string af_string;
bool success;
GError *error = NULL;
struct filter *filter;
const struct audio_format *out_audio_format;
char buffer[4096];
size_t frame_size;
if (argc < 3 || argc > 4) {
g_printerr("Usage: run_filter CONFIG NAME [FORMAT] <IN\n");
return 1;
}
audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2);
/* initialize GLib */
g_thread_init(NULL);
g_log_set_default_handler(my_log_func, NULL);
/* read configuration file (mpd.conf) */
config_global_init();
success = config_read_file(argv[1], &error);
if (!success) {
g_printerr("%s:", error->message);
g_error_free(error);
return 1;
}
/* parse the audio format */
if (argc > 3) {
success = audio_format_parse(&audio_format, argv[3],
false, &error);
if (!success) {
g_printerr("Failed to parse audio format: %s\n",
error->message);
g_error_free(error);
return 1;
}
}
/* initialize the filter */
filter = load_filter(argv[2]);
if (filter == NULL)
return 1;
/* open the filter */
out_audio_format = filter_open(filter, &audio_format, &error);
if (out_audio_format == NULL) {
g_printerr("Failed to open filter: %s\n", error->message);
g_error_free(error);
filter_free(filter);
return 1;
}
g_printerr("audio_format=%s\n",
audio_format_to_string(out_audio_format, &af_string));
frame_size = audio_format_frame_size(&audio_format);
/* play */
while (true) {
ssize_t nbytes;
size_t length;
const void *dest;
nbytes = read(0, buffer, sizeof(buffer));
if (nbytes <= 0)
break;
dest = filter_filter(filter, buffer, (size_t)nbytes,
&length, &error);
if (dest == NULL) {
g_printerr("Filter failed: %s\n", error->message);
filter_close(filter);
filter_free(filter);
return 1;
}
nbytes = write(1, dest, length);
if (nbytes < 0) {
g_printerr("Failed to write: %s\n", strerror(errno));
filter_close(filter);
filter_free(filter);
return 1;
}
}
/* cleanup and exit */
filter_close(filter);
filter_free(filter);
config_global_finish();
return 0;
}
int main(int argc, char **argv)
{
const char *uri;
struct input_stream *is = NULL;
bool success;
GError *error = NULL;
struct playlist_provider *playlist;
struct song *song;
if (argc != 3) {
g_printerr("Usage: dump_playlist CONFIG URI\n");
return 1;
}
uri = argv[2];
/* initialize GLib */
g_thread_init(NULL);
g_log_set_default_handler(my_log_func, NULL);
/* initialize MPD */
config_global_init();
success = config_read_file(argv[1], &error);
if (!success) {
g_printerr("%s\n", error->message);
g_error_free(error);
return 1;
}
io_thread_init();
if (!io_thread_start(&error)) {
g_warning("%s", error->message);
g_error_free(error);
return EXIT_FAILURE;
}
if (!input_stream_global_init(&error)) {
g_warning("%s", error->message);
g_error_free(error);
return 2;
}
playlist_list_global_init();
decoder_plugin_init_all();
/* open the playlist */
GMutex *mutex = g_mutex_new();
GCond *cond = g_cond_new();
playlist = playlist_list_open_uri(uri, mutex, cond);
if (playlist == NULL) {
/* open the stream and wait until it becomes ready */
is = input_stream_open(uri, mutex, cond, &error);
if (is == NULL) {
if (error != NULL) {
g_warning("%s", error->message);
g_error_free(error);
} else
g_printerr("input_stream_open() failed\n");
return 2;
}
input_stream_lock_wait_ready(is);
/* open the playlist */
playlist = playlist_list_open_stream(is, uri);
if (playlist == NULL) {
input_stream_close(is);
g_printerr("Failed to open playlist\n");
return 2;
}
}
/* dump the playlist */
while ((song = playlist_plugin_read(playlist)) != NULL) {
g_print("%s\n", song->uri);
if (song->end_ms > 0)
g_print("range: %u:%02u..%u:%02u\n",
song->start_ms / 60000,
(song->start_ms / 1000) % 60,
song->end_ms / 60000,
(song->end_ms / 1000) % 60);
else if (song->start_ms > 0)
g_print("range: %u:%02u..\n",
song->start_ms / 60000,
(song->start_ms / 1000) % 60);
if (song->tag != NULL)
tag_save(stdout, song->tag);
song_free(song);
}
/* deinitialize everything */
playlist_plugin_close(playlist);
if (is != NULL)
input_stream_close(is);
g_cond_free(cond);
g_mutex_free(mutex);
decoder_plugin_deinit_all();
playlist_list_global_finish();
input_stream_global_finish();
io_thread_deinit();
config_global_finish();
return 0;
}
