示例#1
0
文件: command.c 项目: daaang/mpc
int
cmd_volume(int argc, char **argv, struct mpd_connection *conn)
{
	struct int_value_change ch;

	if (argc == 1) {
		if (!parse_int_value_change(argv[0], &ch))
			DIE("\"%s\" is not an integer\n", argv[0]);
	} else {
		struct mpd_status *status = getStatus(conn);

		if (mpd_status_get_volume(status) >= 0)
			printf("volume:%3i%c\n",
			       mpd_status_get_volume(status), '%');
		else
			printf("volume: n/a\n");

		mpd_status_free(status);
		return 0;
	}

	if (ch.is_relative) {
#if LIBMPDCLIENT_CHECK_VERSION(2,9,0)
		if (mpd_connection_cmp_server_version(conn, 0, 18, 0) >= 0) {
			/* MPD 0.18 knows the "volume" command for
			   relative changes */
			if (!mpd_run_change_volume(conn, ch.value))
				printErrorAndExit(conn);
			return 1;
		}
#endif

		struct mpd_status *status = getStatus(conn);
		int old_volume = mpd_status_get_volume(status);
		mpd_status_free(status);

		ch.value += old_volume;
		if (ch.value < 0)
			ch.value = 0;
		else if (ch.value > 100)
			ch.value = 100;

		if (ch.value == old_volume)
			return 1;
	}

	if (!mpd_run_set_volume(conn, ch.value))
		printErrorAndExit(conn);
	return 1;
}
示例#2
0
文件: mpd_client.c 项目: HyShai/ympd
int mpd_put_state(char *buffer, int *current_song_id, unsigned *queue_version)
{
    struct mpd_status *status;
    int len;

    status = mpd_run_status(mpd.conn);
    if (!status) {
        fprintf(stderr, "MPD mpd_run_status: %s\n", mpd_connection_get_error_message(mpd.conn));
        mpd.conn_state = MPD_FAILURE;
        return 0;
    }

    len = snprintf(buffer, MAX_SIZE,
        "{\"type\":\"state\", \"data\":{"
        " \"state\":%d, \"volume\":%d, \"repeat\":%d,"
        " \"single\":%d, \"consume\":%d, \"random\":%d, "
        " \"songpos\": %d, \"elapsedTime\": %d, \"totalTime\":%d, "
        " \"currentsongid\": %d"
        "}}", 
        mpd_status_get_state(status),
        mpd_status_get_volume(status), 
        mpd_status_get_repeat(status),
        mpd_status_get_single(status),
        mpd_status_get_consume(status),
        mpd_status_get_random(status),
        mpd_status_get_song_pos(status),
        mpd_status_get_elapsed_time(status),
        mpd_status_get_total_time(status),
        mpd_status_get_song_id(status));

    *current_song_id = mpd_status_get_song_id(status);
    *queue_version = mpd_status_get_queue_version(status);
    mpd_status_free(status);
    return len;
}
示例#3
0
文件: mpdinfo.c 项目: jepugs/mpdinfo
int main(int argc, const char* const argv[])
{
    if (argc > 2 || (argc == 2 && strncmp(argv[1], "-h", 2) == 0)) {
        usage();
        return 0;
    }

    conn = mpd_connection_new(NULL, 0, 0);
    if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
        mpd_connection_free(conn);
        fputs("Could not connect to MPD.\n", stderr);
        return 0;
    }
    stat = mpd_run_status(conn);
    if (!(song = mpd_run_current_song(conn))) {
        fputs("No song playing.\n", stderr);
        return 0;
    }

    if (argc == 1)
        print_info(DEFAULT_FMT);
    else
        print_info(argv[1]);

    if (song)
        mpd_song_free(song);
    mpd_status_free(stat);
    mpd_connection_free(conn);

    return 0;
}
示例#4
0
文件: command.cpp 项目: reynhout/pms
/*
 * Retrieves status about the state of MPD.
 */
bool
Control::get_status()
{
	mpd_status *	status;
	mpd_stats *	stats;

	EXIT_IDLE;

	pms->log(MSG_DEBUG, 0, "Retrieving MPD status from server.\n");

	if ((status = mpd_run_status(conn->h())) == NULL) {
		/* FIXME: error handling? */
		pms->log(MSG_DEBUG, 0, "mpd_run_status returned NULL pointer.\n");
		delete _song;
		_song = NULL;
		st->song = MPD_SONG_NO_NUM;
		st->songid = MPD_SONG_NO_ID;
		return false;
	}

	st->assign_status(status);
	mpd_status_free(status);

	if ((stats = mpd_run_stats(conn->h())) == NULL) {
		/* FIXME ? */
		pms->log(MSG_DEBUG, 0, "mpd_run_stats returned NULL pointer.\n");
		return false;
	}

	st->assign_stats(stats);
	mpd_stats_free(stats);

	return true;
}
示例#5
0
文件: command.c 项目: somecommand/mpc
int cmd_play ( int argc, char ** argv, struct mpd_connection *conn )
{
	int song;
	int i;

	if(0==argc) song = -1;
	else {
		struct mpd_status *status;

		for(i=0;i<argc-1;i++)
			printf("skipping: %s\n",argv[i]);

                if(!parse_songnum(argv[i], &song))
			DIE("error parsing song numbers from: %s\n",argv[i]);

		song--;

		/* This is necessary, otherwise mpc will output the wrong playlist number */
		status = getStatus(conn);
		i = mpd_status_get_queue_length(status);
		mpd_status_free(status);
		if(song >= i)
			DIE("song number greater than playlist length.\n");
	}

	if (song >= 0)
		mpd_run_play_pos(conn, song);
	else
		mpd_run_play(conn);

	return 1;
}
示例#6
0
文件: songs.c 项目: viibridges/mpc_d
void
songlist_update_checking(void)
{
  struct mpd_status *status;
  int queue_len, song_id;

  status = getStatus(conn);
  queue_len = mpd_status_get_queue_length(status);
  song_id = mpd_status_get_song_pos(status) + 1;
  mpd_status_free(status);

  if(songlist->current != song_id)
	{
	  songlist->current = song_id;
	  signal_all_wins();
	}

  if(songlist->update_signal == 1 ||
  	 songlist->total != queue_len)
  	{
  	  songlist->update_signal = 0;
	  songlist->total = queue_len;
  	  songlist_update();
  	  signal_all_wins();
  	}

  /** for some unexcepted cases songlist->begin
	  may be greater than songlist->length;
	  if this happens, we reset the begin's value */
  if(songlist->begin > songlist->length)
	songlist->begin = 1;
}
示例#7
0
文件: songs.c 项目: viibridges/mpc_d
void
songlist_simple_bar(void)
{
  int crt_time, crt_time_perc, total_time,
	fill_len, rest_len, i;
  struct mpd_status *status;

  WINDOW *win = specific_win(SIMPLE_PROC_BAR);
  const int bar_length = win->_maxx + 1;
  
  status = getStatus(conn);
  crt_time = mpd_status_get_elapsed_time(status);
  total_time = mpd_status_get_total_time(status);
  mpd_status_free(status);

  crt_time_perc = (total_time == 0 ? 0 : 100 * crt_time / total_time);    
  fill_len = crt_time_perc * bar_length / 100;
  rest_len = bar_length - fill_len;

  wattron(win, my_color_pairs[2]);  
  for(i = 0; i < fill_len; wprintw(win, "*"), i++);
  wattroff(win, my_color_pairs[2]);  

  for(i = 0; i < rest_len; wprintw(win, "*"), i++);
}
示例#8
0
void mpd_put_state(void)
{
    struct mpd_status *status;
    int len;
    unsigned queue_len;
    int song_pos, next_song_pos;

    status = mpd_run_status(mpd.conn);
    
    if (!status) {
        syslog(LOG_ERR, "%s mpd_run_status: %s\n", __func__, mpd_connection_get_error_message(mpd.conn));
        mpd.conn_state = MPD_FAILURE;
        return;
    }

    mpd.song_pos = mpd_status_get_song_pos(status);
    mpd.next_song_pos = song_pos+1; //TODO: mpd_status_get_next_song_pos(status);
    mpd.queue_len = mpd_status_get_queue_length(status);
    mpd.volume = mpd_status_get_volume(status);
    mpd.state = mpd_status_get_state(status);
    mpd.repeat = mpd_status_get_repeat(status);
    mpd.single = mpd_status_get_single(status);
    mpd.consume = mpd_status_get_consume(status);
    mpd.random = mpd_status_get_random(status);
    mpd.elapsed_time = mpd_status_get_elapsed_time(status);
    mpd.total_time = mpd_status_get_total_time(status);
    mpd.song_id = mpd_status_get_song_id(status);

//    printf("%d\n", mpd.song_id);

    mpd_status_free(status);
}
示例#9
0
文件: mpd.c 项目: cmende/mpd2irc
static void mpd_update(void)
{
	enum mpd_state prev = MPD_STATE_UNKNOWN;

	if (mpd.status) {
		prev = mpd_status_get_state(mpd.status);
		mpd_status_free(mpd.status);
	}

	mpd.status = mpd_run_status(mpd.conn);
	if (!mpd_response_finish(mpd.conn)) {
		mpd_report_error();
		return;
	}

	if (mpd_status_get_state(mpd.status) == MPD_STATE_PLAY &&
			prev != MPD_STATE_PAUSE) {
		if (mpd.song)
			mpd_song_free(mpd.song);
		mpd.song = mpd_run_current_song(mpd.conn);
		if (!mpd_response_finish(mpd.conn)) {
			mpd_report_error();
			return;
		}

		if (prefs.announce)
			mpd_announce_song();
	}
}
示例#10
0
文件: command.c 项目: daaang/mpc
static int
bool_cmd(int argc, char **argv, struct mpd_connection *conn,
	 bool (*get_mode)(const struct mpd_status *status),
	 bool (*run_set_mode)(struct mpd_connection *conn, bool mode))
{
	bool mode;

	if (argc == 1) {
		int mode_i = get_boolean(argv[0]);
		if (mode_i < 0)
			return -1;

		mode = (bool)mode_i;
	} else {
		struct mpd_status *status;
		status = getStatus(conn);
		mode = !get_mode(status);
		mpd_status_free(status);
	}

	if (!run_set_mode(conn, mode))
		printErrorAndExit(conn);

	return 1;
}
示例#11
0
文件: lmc.c 项目: L0op/RuneAudioNext
static enum mpd_state
lmc_current(struct mpd_song **song_r, unsigned *elapsed_r)
{
	struct mpd_status *status;
	enum mpd_state state;
	struct mpd_song *song;

	assert(g_mpd != NULL);

	mpd_command_list_begin(g_mpd, true);
	mpd_send_status(g_mpd);
	mpd_send_current_song(g_mpd);
	mpd_command_list_end(g_mpd);

	status = mpd_recv_status(g_mpd);
	if (!status) {
		lmc_failure();
		return MPD_STATE_UNKNOWN;
	}

	state = mpd_status_get_state(status);
	*elapsed_r = mpd_status_get_elapsed_time(status);

	mpd_status_free(status);

	if (state != MPD_STATE_PLAY) {
		if (!mpd_response_finish(g_mpd)) {
			lmc_failure();
			return MPD_STATE_UNKNOWN;
		}

		return state;
	}

	if (!mpd_response_next(g_mpd)) {
		lmc_failure();
		return MPD_STATE_UNKNOWN;
	}

	song = mpd_recv_song(g_mpd);
	if (song == NULL) {
		if (!mpd_response_finish(g_mpd)) {
			lmc_failure();
			return MPD_STATE_UNKNOWN;
		}

		return MPD_STATE_UNKNOWN;
	}

	if (!mpd_response_finish(g_mpd)) {
		mpd_song_free(song);
		lmc_failure();
		return MPD_STATE_UNKNOWN;
	}

	*song_r = song;
	return MPD_STATE_PLAY;
}
示例#12
0
unsigned mpd_get_queue_length()
{
    struct mpd_status *status = mpd_run_status(mpd.conn);
    if (status == NULL)
        return 0;
    const unsigned length = mpd_status_get_queue_length(status);
    mpd_status_free(status);
    return length;
}
示例#13
0
文件: command.c 项目: daaang/mpc
/**
 * Wait until the song changes or until playback is started/stopped.
 */
static void
wait_current(struct mpd_connection *c)
{
	struct mpd_status *status = getStatus(c);

	const int old_song = get_active_song(status);
	mpd_status_free(status);

	int new_song;
	do {
		enum mpd_idle idle = mpd_run_idle_mask(c, MPD_IDLE_PLAYER);
		if (idle == 0)
			printErrorAndExit(c);

		status = getStatus(c);
		new_song = get_active_song(status);
		mpd_status_free(status);
	} while (new_song == old_song);
}
示例#14
0
文件: command.c 项目: somecommand/mpc
int cmd_volume ( int argc, char ** argv, struct mpd_connection *conn )
{
        struct int_value_change ch;
	struct mpd_status *status;

	if(argc==1) {
                if(!parse_int_value_change(argv[0], &ch))
			DIE("\"%s\" is not an integer\n", argv[0]);
	} else {
		status = getStatus(conn);

		if (mpd_status_get_volume(status) >= 0)
			printf("volume:%3i%c\n",
			       mpd_status_get_volume(status), '%');
		else
			printf("volume: n/a\n");

		mpd_status_free(status);

		return 0;
	}

	if (ch.is_relative) {
		int old_volume;

		status = getStatus(conn);
		old_volume = mpd_status_get_volume(status);
		mpd_status_free(status);

		ch.value += old_volume;
		if (ch.value < 0)
			ch.value = 0;
		else if (ch.value > 100)
			ch.value = 100;

		if (ch.value == old_volume)
			return 1;
	}

	if (!mpd_run_set_volume(conn, ch.value))
		printErrorAndExit(conn);
	return 1;
}
示例#15
0
/*
 * pgmpc_reset
 *
 * Cleanup existing mpd context.
 */
static void
pgmpc_reset(void)
{
	if (mpd_conn)
		mpd_connection_free(mpd_conn);
	if (mpd_status)
		mpd_status_free(mpd_status);
	mpd_conn = NULL;
	mpd_status = NULL;
}
示例#16
0
文件: mpd.c 项目: cmende/mpd2irc
void mpd_say_status(void)
{
	gchar *state;
	gchar *artist, *title;

	if (!mpd.conn) {
		irc_say("Not connected to MPD");
		return;
	}

	if (mpd.status)
		mpd_status_free(mpd.status);

	mpd_run_noidle(mpd.conn);
	mpd.status = mpd_run_status(mpd.conn);
	if (!mpd_response_finish(mpd.conn)) {
		mpd_report_error();
		return;
	}
	mpd_send_idle_mask(mpd.conn, MPD_IDLE_PLAYER);

	switch (mpd_status_get_state(mpd.status)) {
		case MPD_STATE_STOP:
			state = g_strdup("stopped"); break;
		case MPD_STATE_PLAY:
			state = g_strdup("playing"); break;
		case MPD_STATE_PAUSE:
			state = g_strdup("paused"); break;
		default:
			state = g_strdup("unknown"); break;
	}

	if (mpd.song) {
		artist = g_strdup(mpd_song_get_tag(mpd.song, MPD_TAG_ARTIST,
					0));
		title = g_strdup(mpd_song_get_tag(mpd.song, MPD_TAG_TITLE, 0));
	} else {
		artist = g_strdup("");
		title = g_strdup("");
	}

	irc_say("[%s] %s - %s (%i:%02i/%i:%02i) | repeat: %sabled | "
			"random: %sabled | announce: %sabled",
			state, artist, title,
			mpd_status_get_elapsed_time(mpd.status) / 60,
			mpd_status_get_elapsed_time(mpd.status) % 60,
			mpd_status_get_total_time(mpd.status) / 60,
			mpd_status_get_total_time(mpd.status) % 60,
			(mpd_status_get_repeat(mpd.status) ? "en" : "dis"),
			(mpd_status_get_random(mpd.status) ? "en" : "dis"),
			(prefs.announce ? "en" : "dis"));
	g_free(state);
	g_free(artist);
	g_free(title);
}
示例#17
0
unsigned mpd_get_queue_length()
{
    unsigned length = 0;
    struct mpd_status *status = mpd_run_status(mpd.conn);
    if (status != NULL) {
        length = mpd_status_get_queue_length(status);
        mpd_status_free(status);
    }
    mpd_response_finish(mpd.conn);
    return length;
}
示例#18
0
文件: client.c 项目: cykerway/ncmpcr
int del_client(CLIENT_OBJECT *cli) {

    mpd_stats_free(cli->stats);
    if (cli->song)
        mpd_song_free(cli->song);
    mpd_status_free(cli->status);
    mpd_connection_free(cli->conn);

    free(cli);
    return 0;
}
示例#19
0
文件: songs.c 项目: viibridges/mpc_d
void
songlist_scroll_to_current(void)
{
  struct mpd_status *status;
  int song_id;
  status = getStatus(conn);
  song_id = mpd_status_get_song_pos(status) + 1;
  mpd_status_free(status);

  songlist_scroll_to(song_id);
}
示例#20
0
文件: dwmst.c 项目: Theta91/dwmst
char *
get_mpd(void) {
	struct mpd_connection *con;
	struct mpd_status *status;
	struct mpd_song *song;
	int status_type;
	char *res;
	const char *artist = NULL, *title = NULL;

	con = mpd_connection_new(NULL, 0, 30000);
	if(mpd_connection_get_error(con)) {
		mpd_connection_free(con);
		return NO_MPD;
	}

	mpd_command_list_begin(con, true);
	mpd_send_status(con);
	mpd_send_current_song(con);
	mpd_command_list_end(con);

	status = mpd_recv_status(con);
	if(!status) {
		mpd_connection_free(con);
		return NO_MPD;
	}
	mpd_response_next(con);
	song = mpd_recv_song(con);
	title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
	if(!title)
		title = mpd_song_get_uri(song);
	artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);

	status_type = mpd_status_get_state(status);
	switch(status_type) {
		case(MPD_STATE_PLAY):
			res = smprintf(MPD, "Playing", artist, title);
			break;
		case(MPD_STATE_PAUSE):
			res = smprintf(MPD, "Paused", artist, title);
			break;
		case(MPD_STATE_STOP):
			res = smprintf(MPD, "Stopped", artist, title);
			break;
		default:
			res = NO_MPD;
			break;
	}
	mpd_song_free(song);
	mpd_response_finish(con);
	mpd_status_free(status);
	mpd_connection_free(con);
	return res;
}
示例#21
0
static int lmpdstatus_gc(lua_State *L)
{
	struct mpd_status **status;

	status = luaL_checkudata(L, 1, MPD_STATUS_T);

	if (*status != NULL)
		mpd_status_free(*status);
	*status = NULL;

	return 0;
}
示例#22
0
文件: command.c 项目: somecommand/mpc
/**
 * Wait until the song changes or until playback is started/stopped.
 */
static void
wait_current(struct mpd_connection *c)
{
	if (mpd_connection_cmp_server_version(c, 0, 14, 0) < 0)
		fprintf(stderr, "warning: MPD 0.14 required for this command\n");

	struct mpd_status *status = getStatus(c);

	const int old_song = get_active_song(status);
	mpd_status_free(status);

	int new_song;
	do {
		enum mpd_idle idle = mpd_run_idle_mask(c, MPD_IDLE_PLAYER);
		if (idle == 0)
			printErrorAndExit(c);

		status = getStatus(c);
		new_song = get_active_song(status);
		mpd_status_free(status);
	} while (new_song == old_song);
}
示例#23
0
文件: command.c 项目: somecommand/mpc
int
cmd_crop(mpd_unused int argc, mpd_unused char **argv, struct mpd_connection *conn)
{
	struct mpd_status *status = getStatus( conn );
	int length = mpd_status_get_queue_length(status) - 1;

	if (length < 0) {

		mpd_status_free(status);
		DIE( "A playlist longer than 1 song in length is required to crop.\n" );

	} else if (mpd_status_get_state(status) == MPD_STATE_PLAY ||
		   mpd_status_get_state(status) == MPD_STATE_PAUSE) {
		if (!mpd_command_list_begin(conn, false))
			printErrorAndExit(conn);

		while( length >= 0 )
		{
			if (length != mpd_status_get_song_pos(status)) {
				mpd_send_delete(conn, length);
			}
			length--;
		}

		mpd_status_free(status);

		if (!mpd_command_list_end(conn) || !mpd_response_finish(conn))
			printErrorAndExit(conn);

		return ( 0 );

	} else {

		mpd_status_free(status);
		DIE( "You need to be playing to crop the playlist\n" );

	}
}
示例#24
0
文件: client.c 项目: cykerway/ncmpcr
int update_client(CLIENT_OBJECT *cli) {

    mpd_status_free(cli->status);
    cli->status = mpd_run_status(cli->conn);

    if (cli->song)
        mpd_song_free(cli->song);
    cli->song = mpd_run_current_song(cli->conn);

    mpd_stats_free(cli->stats);
    cli->stats = mpd_run_stats(cli->conn);

    return 0;
}
示例#25
0
int mpd_crop()
{
    struct mpd_status *status = mpd_run_status(mpd.conn);
    if (status == 0)
        return 0;
    int length = mpd_status_get_queue_length(status) - 1;

    if (length < 0) {
        mpd_status_free(status);
        syslog(LOG_INFO, "%s: A playlist longer than 1 song in length is required to crop.\n", __func__);
    } else if (mpd_status_get_state(status) == MPD_STATE_PLAY ||
            mpd_status_get_state(status) == MPD_STATE_PAUSE) {
        if (!mpd_command_list_begin(mpd.conn, false)) {
            syslog(LOG_ERR, "%s: mpd_command_list_begin failed\n", __func__);
            return 0;
        }

        for (; length >= 0; --length)
            if (length != mpd_status_get_song_pos(status))
                mpd_send_delete(mpd.conn, length);

        mpd_status_free(status);

        if (!mpd_command_list_end(mpd.conn) || !mpd_response_finish(mpd.conn)) {
            syslog(LOG_ERR, "%s: mpd_command_list_end || mpd_response_finish failed\n", __func__);
            return 0;
        }

        return 0;
    } else {
        mpd_status_free(status);
        syslog(LOG_INFO, "%s: You need to be playing to crop the playlist\n", __func__);
        return 0;
    }
    return 1;
}
示例#26
0
文件: command.c 项目: somecommand/mpc
int cmd_insert (int argc, char ** argv, struct mpd_connection *conn )
{
	int ret;
	struct mpd_status *status = getStatus(conn);

	const int from = mpd_status_get_queue_length(status);

	ret = cmd_add(argc, argv, conn);
	const int cur_pos = mpd_status_get_song_pos(status);
	mpd_status_free(status);
	if (ret != 0) {
		return ret;
	}
	return mpd_run_move_range(conn, from, from+argc,
		cur_pos+1);
}
int
main(int argc, char **argv)
{
    int t;
    bool firsttime = true;
    pid=getpid();
    _debug = (bool) getenv("MADAUDIO_DEBUG");
    if(!_debug)
        daemon(0, 0);
    int flags = LOG_NDELAY | LOG_PID;
    if(_debug)
        flags |= LOG_PERROR;
    openlog("madaudio-unsuspend", flags, LOG_DAEMON);

    struct mpd_connection *conn;
    for(t=1000; t > 0; t++) {
        conn = mpd_connection_new(MADAUDIO_SOCKET, 0, 0);
        if(conn && mpd_connection_get_error(conn)==MPD_ERROR_SUCCESS)
            break;
        debug("can't connect to mpd, retry", pid);
        usleep(1000);
    };
    debug("connected...");
    while(true)
    {
        struct mpd_status * status = mpd_run_status(conn);
        check(conn);
        if(!status)
            err(1, "madaudio-unsuspend[%d]: Can't get status\n");
        enum mpd_state state = mpd_status_get_state(status);
        if(state != oldstate)
        {
            if(state == MPD_STATE_PLAY)
                lock_autosuspend();
            else
            {
                if(!firsttime)
                    unlock_autosuspend();
            }
        };
        oldstate = state;
        firsttime = false;
        mpd_status_free(status);
        mpd_run_idle_mask(conn, MPD_IDLE_PLAYER);
        check(conn);
    }
}
示例#28
0
int cmd_mixrampdb ( int argc, char ** argv, struct mpd_connection *conn )
{
	if(argc==1) {
		float db;
		if(!parse_float(argv[0], &db))
			DIE("\"%s\" is not a floating point number\n",argv[0]);

		mpd_run_mixrampdb(conn, db);
                my_finishCommand(conn);
	}
	else {
		struct mpd_status *status = getStatus(conn);

		printf("mixrampdb: %f\n", mpd_status_get_mixrampdb(status));

		mpd_status_free(status);
	}
	return 0;
}
示例#29
0
int cmd_crossfade ( int argc, char ** argv, struct mpd_connection *conn )
{
	if(argc==1) {
		int seconds;
                if(!parse_int(argv[0], &seconds) || seconds<0)
			DIE("\"%s\" is not 0 or positive integer\n",argv[0]);

		if (!mpd_run_crossfade(conn, seconds))
			printErrorAndExit(conn);
	}
	else {
		struct mpd_status *status;
		status = getStatus(conn);

		printf("crossfade: %i\n", mpd_status_get_crossfade(status));

		mpd_status_free(status);
	}
	return 0;
}
示例#30
0
int mpd_insert (char *song_path )
{
    struct mpd_status *status = mpd_run_status(mpd.conn);
    if (status == NULL)
        return 0;
    const unsigned from = mpd_status_get_queue_length(status);
    const int cur_pos = mpd_status_get_song_pos(status);
    mpd_status_free(status);

    if (mpd_run_add(mpd.conn, song_path) != true)
        return 0;

    /* check the new queue length to find out how many songs were
     *        appended  */
    const unsigned end = mpd_get_queue_length();
    if (end == from)
        return 0;

    /* move those songs to right after the current one */
    return mpd_run_move_range(mpd.conn, from, end, cur_pos + 1);
}