mpd/test/dump_playlist.cxx

254 lines
5.6 KiB
C++
Raw Normal View History

/*
2011-01-29 10:13:54 +01:00
* Copyright (C) 2003-2011 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
2013-01-02 19:52:57 +01:00
#include "TagSave.hxx"
2013-07-28 13:25:12 +02:00
#include "Song.hxx"
#include "Directory.hxx"
2013-01-07 09:38:02 +01:00
#include "input_stream.h"
#include "conf.h"
2013-07-28 13:18:48 +02:00
#include "DecoderAPI.hxx"
2013-01-30 17:18:48 +01:00
#include "DecoderList.hxx"
#include "InputInit.hxx"
2013-01-10 10:33:20 +01:00
#include "IOThread.hxx"
2013-01-26 01:04:02 +01:00
#include "PlaylistRegistry.hxx"
2013-01-27 17:38:09 +01:00
#include "PlaylistPlugin.hxx"
#include "fs/Path.hxx"
2013-01-02 19:52:57 +01:00
#include <glib.h>
#include <unistd.h>
#include <stdlib.h>
Directory::Directory() {}
Directory::~Directory() {}
static void
2013-08-04 23:48:01 +02:00
my_log_func(const gchar *log_domain, gcc_unused GLogLevelFlags log_level,
const gchar *message, gcc_unused gpointer user_data)
{
if (log_domain != NULL)
g_printerr("%s: %s\n", log_domain, message);
else
g_printerr("%s\n", message);
}
void
2013-08-04 23:48:01 +02:00
decoder_initialized(gcc_unused struct decoder *decoder,
gcc_unused const AudioFormat audio_format,
gcc_unused bool seekable,
gcc_unused float total_time)
{
}
enum decoder_command
2013-08-04 23:48:01 +02:00
decoder_get_command(gcc_unused struct decoder *decoder)
{
return DECODE_COMMAND_NONE;
}
void
2013-08-04 23:48:01 +02:00
decoder_command_finished(gcc_unused struct decoder *decoder)
{
}
double
2013-08-04 23:48:01 +02:00
decoder_seek_where(gcc_unused struct decoder *decoder)
{
return 1.0;
}
void
2013-08-04 23:48:01 +02:00
decoder_seek_error(gcc_unused struct decoder *decoder)
{
}
size_t
2013-08-04 23:48:01 +02:00
decoder_read(gcc_unused struct decoder *decoder,
struct input_stream *is,
void *buffer, size_t length)
{
return input_stream_lock_read(is, buffer, length, NULL);
}
void
2013-08-04 23:48:01 +02:00
decoder_timestamp(gcc_unused struct decoder *decoder,
gcc_unused double t)
{
}
enum decoder_command
2013-08-04 23:48:01 +02:00
decoder_data(gcc_unused struct decoder *decoder,
gcc_unused struct input_stream *is,
const void *data, size_t datalen,
2013-08-04 23:48:01 +02:00
gcc_unused uint16_t kbit_rate)
{
2013-08-04 23:48:01 +02:00
gcc_unused ssize_t nbytes = write(1, data, datalen);
return DECODE_COMMAND_NONE;
}
enum decoder_command
2013-08-04 23:48:01 +02:00
decoder_tag(gcc_unused struct decoder *decoder,
gcc_unused struct input_stream *is,
gcc_unused Tag &&tag)
{
return DECODE_COMMAND_NONE;
}
void
2013-08-04 23:48:01 +02:00
decoder_replay_gain(gcc_unused struct decoder *decoder,
const struct replay_gain_info *replay_gain_info)
{
const struct replay_gain_tuple *tuple =
&replay_gain_info->tuples[REPLAY_GAIN_ALBUM];
if (replay_gain_tuple_defined(tuple))
g_printerr("replay_gain[album]: gain=%f peak=%f\n",
tuple->gain, tuple->peak);
tuple = &replay_gain_info->tuples[REPLAY_GAIN_TRACK];
if (replay_gain_tuple_defined(tuple))
g_printerr("replay_gain[track]: gain=%f peak=%f\n",
tuple->gain, tuple->peak);
}
void
2013-08-04 23:48:01 +02:00
decoder_mixramp(gcc_unused struct decoder *decoder,
char *mixramp_start, char *mixramp_end)
{
g_free(mixramp_start);
g_free(mixramp_end);
}
int main(int argc, char **argv)
{
const char *uri;
struct input_stream *is = NULL;
GError *error = NULL;
struct playlist_provider *playlist;
2013-07-28 13:25:12 +02:00
Song *song;
if (argc != 3) {
g_printerr("Usage: dump_playlist CONFIG URI\n");
return 1;
}
const Path config_path = Path::FromFS(argv[1]);
uri = argv[2];
/* initialize GLib */
#if !GLIB_CHECK_VERSION(2,32,0)
g_thread_init(NULL);
#endif
g_log_set_default_handler(my_log_func, NULL);
/* initialize MPD */
config_global_init();
if (!ReadConfigFile(config_path, &error)) {
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 */
Mutex mutex;
Cond cond;
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) {
2009-10-13 18:01:06 +02:00
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)
2013-07-30 20:11:57 +02:00
tag_save(stdout, *song->tag);
2013-07-28 13:25:12 +02:00
song->Free();
}
/* deinitialize everything */
playlist_plugin_close(playlist);
if (is != NULL)
input_stream_close(is);
decoder_plugin_deinit_all();
playlist_list_global_finish();
input_stream_global_finish();
io_thread_deinit();
config_global_finish();
return 0;
}