diff -r fb5042644071 debian/patches/00list

--- a/debian/patches/00list	Mon May 19 00:17:05 2008 -0400

+++ b/debian/patches/00list	Mon May 19 01:12:49 2008 -0400

@@ -1,2 +1,4 @@

 01verbose-compilation

 02compile-with-gcc-4.3

+03mpd-client

+04mpd-client-config-init

diff -r fb5042644071 debian/patches/03mpd-client.dpatch

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000

+++ b/debian/patches/03mpd-client.dpatch	Mon May 19 01:12:49 2008 -0400

@@ -0,0 +1,3597 @@

+#! /bin/sh /usr/share/dpatch/dpatch-run

+## mpd-client.dpatch by Fabien Niñoles <fabien@tzone.org>

+##

+## All lines beginning with `## DP:' are a description of the patch.

+## DP: Add mpd to imms clients.

+

+@DPATCH@

+

+diff -r 171db9560cb5 clients/mpd/immsmpd.cc

+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000

++++ b/clients/mpd/immsmpd.cc	Mon May 19 00:21:51 2008 -0400

+@@ -0,0 +1,282 @@

++#include "immsutil.h"

++#include "clientstub.h"

++

++#include <glib.h>

++#include <signal.h>

++

++#include "mpdinterface.h"

++#include <list>

++

++

++using std::endl;

++using std::list;

++using namespace mpd_interface;

++

++// interface for communication with IMMS server

++// comes from clientstub.h

++struct MPDOps;

++typedef IMMSClient<MPDOps> MPDClient;

++

++int poll_time = 250; // miliseconds

++const double reconnect_interval = 1.0; // seconds

++GMainLoop *loop = nullptr;

++GSource* ts;

++

++MPDClient imms;

++Player mpd;

++list<int> playqueue;

++const list<int>::size_type pq_capacity = 1;

++

++

++// that's the main function - it's called regularly and handles all the

++// IMMS and MPD communication and decides what to do when anything happens

++gboolean do_events(void *unused);

++

++// determines whether the currently playing song has been selected

++// specifically by the user

++bool next_jumped(); 

++

++void notify_song_ended(const Song& song, double elapsed_time, bool jumped);

++

++// resets the elapsed_timer and sets the jumped flag, too

++void notify_song_started(const Song& song, double& elapsed_time,

++    bool& jumped);

++

++void update_playqueue();

++bool playqueue_contains(int song);

++

++void quit(int signum);

++

++

++struct MPDOps

++{

++    // IMMS server's suggestion of the next song

++    static void set_next(int next)

++    {

++      if(playqueue.size() < pq_capacity) {

++	if(mpd.song(current).path() == mpd.song(next).path() ||

++	    mpd.song(previous).path() == mpd.song(next).path() ||

++	    playqueue_contains(next) || next >= mpd.playlist_length()) {

++          update_playqueue();

++	}

++	else {

++	  playqueue.push_back(next);

++	}

++      }

++    }

++    // no idea, works just peach as it is

++    // asked mag about it, waiting for an answer

++    // TODO if he doesn't answer, dig it out

++    static void reset_selection() { }

++    // path of the song at the given pos for IMMS server

++    static string get_item(int index) {return mpd.song(index).path(); }

++    // size of the playlist for the IMMS server

++    static int get_length() { return mpd.playlist_length(); }

++}; 

++

++int main(int argc, char **argv)

++{

++  // glib initialization

++  loop = g_main_loop_new(nullptr, FALSE);

++

++  signal(SIGINT,  quit);

++  signal(SIGTERM, quit);

++  signal(SIGPIPE, SIG_IGN);

++

++  ts = g_timeout_source_new(poll_time);

++  g_source_attach(ts, nullptr);

++  g_source_set_callback(ts, (GSourceFunc)do_events, nullptr, nullptr);

++  // end of glib init

++

++  g_main_loop_run(loop);

++

++  LOG(INFO) << "Exitting." << endl;

++  return 0;

++}

++

++gboolean do_events(void *unused)

++{

++  static const double time_inc = double(poll_time)/1000.0;

++    // the time that ACTUALLY elapsed when playing the song (in seconds)

++  static double elapsed_time = 0; 

++  static bool jumped = false;

++  static double reconnect_timeout = 0;

++

++  try {

++    if(!mpd.connected()) {

++      if(reconnect_timeout < time_inc) {

++	LOG(INFO) << "Not connected to MPD. Attempting to connect..."

++	  << endl;

++	reconnect_timeout = reconnect_interval;

++	mpd.connect();

++	LOG(INFO) << "Connected to MPD." << endl;

++	reconnect_timeout = 0;

++      }

++      else {

++	reconnect_timeout -= time_inc;

++	return TRUE;

++      }

++    }

++    if(imms.check_connection()) imms.setup(0);

++    if(!imms.isok()) return TRUE;

++

++    mpd.refresh();

++

++    if(mpd.playlist_changed()) {

++      imms.playlist_changed(mpd.playlist_length());

++      playqueue.clear();

++    }

++    if(mpd.radnom()) update_playqueue();

++

++    if(mpd.status_changed()) {

++      if(mpd.status(current) == stopped) {

++	notify_song_ended(mpd.song(current), elapsed_time, jumped);

++      }

++      else if(mpd.status(previous) == stopped &&

++	  mpd.status(current)==playing) {

++	notify_song_started(mpd.song(current), elapsed_time, jumped);

++	

++	// clear the song_changed() flag

++	if(mpd.song_changed()) mpd.refresh(); 

++      }

++    }

++    if(mpd.status(current) == playing) {

++      elapsed_time += time_inc;

++      if(mpd.song_changed()) {

++	notify_song_ended(mpd.song(previous), elapsed_time, jumped);

++

++	if(!mpd.radnom() || playqueue.empty()) {

++	  notify_song_started(mpd.song(current), elapsed_time, jumped);

++	}

++	else {

++	  mpd.play_song(playqueue.front());

++	  notify_song_started(mpd.song(playqueue.front()), elapsed_time,

++	      jumped);

++	  playqueue.erase(playqueue.begin());

++	  update_playqueue();

++	  // this could otherwise incorrectly set song_changed() flag

++	  mpd.refresh(); 

++	}

++      }

++      else {

++	// fix the real timer if it's inconsistent with what player

++	// says is the elapsed time of the current song

++	if(elapsed_time - double(mpd.song(current).elapsed()) >= 3.0) {

++	  if(mpd.song(current).elapsed() == 0) {

++	    Song tmp_ended = mpd.song(current);

++	    tmp_ended.set_length(int(elapsed_time) * 2);

++	    notify_song_ended(tmp_ended, elapsed_time, jumped);

++	    notify_song_started(mpd.song(current), elapsed_time, jumped);

++	    jumped = false;

++	  }

++	  elapsed_time = mpd.song(current).elapsed();

++	}

++      }

++    }

++  }

++  catch (connection_err) {

++    if(reconnect_timeout >= reconnect_interval) {

++	  LOG(INFO) << "Connecting to MPD was unsuccessful. "

++	    "Next attempt in " << reconnect_interval << " second"

++	    << (reconnect_interval == 1.0 ? "":"s") << "." << endl;

++    }

++    else {

++      LOG(INFO) << "Disconnected from MPD." << endl;

++    }

++  }

++  catch (mpd_err ex) {

++    LOG(ERROR) << "Error: " << ex.message() << endl;

++    g_main_quit(loop);

++    loop = nullptr;

++    exit(1);

++  }

++  return TRUE;

++}

++

++// determines whether the song has been played whole

++bool played_whole(double elapsed_time, int length)

++{

++  static const double abs_limit = 20.0;

++  static const double coeficient = 0.08;

++

++  double rel_limit = double(length) * coeficient;

++

++  double limit = (abs_limit < rel_limit) ? abs_limit : rel_limit;

++  return double(length)-elapsed_time < limit; 

++}

++// determines whether the song has been skipped early

++// (thus being set as not a prefed one)

++bool bad(double elapsed_time, int length)

++{

++  static const double abs_limit = 30.0;

++  static const double coeficient = 0.13;

++

++  double rel_limit = double(length) * coeficient;

++

++  double limit = (rel_limit < abs_limit) ? rel_limit : abs_limit;

++  return elapsed_time < limit;

++}

++bool next_jumped()

++{

++  if(mpd.radnom()) return false;

++

++  if(mpd.song(current).pos() == mpd.song(previous).pos()+1)

++    return false;

++  if(mpd.song(current).pos() == 0 &&

++      mpd.song(previous).pos() == mpd.playlist_length()-1)

++    return false;

++

++  return true;

++}

++void notify_song_ended(const Song& song, double elapsed_time, bool jumped)

++{

++  if(song.length() == Song::invalid_time) return;

++

++  imms.end_song(played_whole(elapsed_time, song.length()), jumped,

++      bad(elapsed_time, song.length()) );

++}

++

++void notify_song_started(const Song& song, double& elapsed_timer,

++    bool& jumped)

++{

++  imms.start_song(song.pos(), song.path());

++  elapsed_timer = 0;

++  jumped = next_jumped();

++  mpd.song_changed(); // clear the change notification

++}

++

++void update_playqueue()

++{

++  static const int timeout_value = 3;

++  static int timeout = 0;

++

++  if(timeout == 0)

++  {

++    if(playqueue.size() < pq_capacity) {

++      list<int>::size_type i;

++      for(i = pq_capacity - playqueue.size(); i!=0; i--) {

++	imms.select_next();

++      }

++      timeout = timeout_value;

++    }

++  }

++  else --timeout;

++}

++

++bool playqueue_contains(int song)

++{

++  list<int>::const_iterator i;

++  for(i = playqueue.begin(); i!= playqueue.end(); i++) {

++    if (*i == song) return true;

++  }

++  return false;

++}

++

++void quit(int signum)

++{

++  if (loop) g_main_quit(loop);

++  loop = nullptr;

++  signal(signum, SIG_DFL);

++}

++

++

+diff -r 171db9560cb5 clients/mpd/libmpdclient.c

+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000

++++ b/clients/mpd/libmpdclient.c	Mon May 19 00:21:51 2008 -0400

+@@ -0,0 +1,1955 @@

++/* libmpdclient

++   (c)2003-2006 by Warren Dukes (warren.dukes@gmail.com)

++   This project's homepage is: http://www.musicpd.org

++

++   Redistribution and use in source and binary forms, with or without

++   modification, are permitted provided that the following conditions

++   are met:

++

++   - Redistributions of source code must retain the above copyright

++   notice, this list of conditions and the following disclaimer.

++

++   - Redistributions in binary form must reproduce the above copyright

++   notice, this list of conditions and the following disclaimer in the

++   documentation and/or other materials provided with the distribution.

++

++   - Neither the name of the Music Player Daemon nor the names of its

++   contributors may be used to endorse or promote products derived from

++   this software without specific prior written permission.

++

++   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

++   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

++   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

++   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR

++   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

++   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

++   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

++   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

++   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

++   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

++   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

++*/

++

++#include "libmpdclient.h"

++

++#include <errno.h>

++#include <ctype.h>

++#include <sys/types.h>

++#include <stdio.h>

++#include <sys/param.h>

++#include <string.h>

++#include <unistd.h>

++#include <stdlib.h>

++#include <fcntl.h>

++#include <limits.h>

++

++#ifdef WIN32

++#  include <ws2tcpip.h>

++#  include <winsock.h>

++#else

++#  include <netinet/in.h>

++#  include <arpa/inet.h>

++#  include <sys/socket.h>

++#  include <netdb.h>

++#endif

++

++/* (bits+1)/3 (plus the sign character) */

++#define INTLEN      ((sizeof(int)       * CHAR_BIT + 1) / 3 + 1)

++#define LONGLONGLEN ((sizeof(long long) * CHAR_BIT + 1) / 3 + 1)

++

++#define COMMAND_LIST    1

++#define COMMAND_LIST_OK 2

++

++#ifndef MPD_NO_GAI

++#  ifdef AI_ADDRCONFIG

++#    define MPD_HAVE_GAI

++#  endif

++#endif

++

++#ifndef MSG_DONTWAIT

++#  define MSG_DONTWAIT 0

++#endif

++

++#ifdef WIN32

++#  define SELECT_ERRNO_IGNORE   (errno == WSAEINTR || errno == WSAEINPROGRESS)

++#  define SENDRECV_ERRNO_IGNORE SELECT_ERRNO_IGNORE

++#else

++#  define SELECT_ERRNO_IGNORE   (errno == EINTR)

++#  define SENDRECV_ERRNO_IGNORE (errno == EINTR || errno == EAGAIN)

++#  define winsock_dll_error(c)  0

++#  define closesocket(s)        close(s)

++#  define WSACleanup()          do { /* nothing */ } while (0)

++#endif

++

++#ifdef WIN32

++static int winsock_dll_error(mpd_Connection *connection)

++{

++	WSADATA wsaData;

++	if ((WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0 ||

++			LOBYTE(wsaData.wVersion) != 2 ||

++			HIBYTE(wsaData.wVersion) != 2 ) {

++		strcpy(connection->errorStr,

++		       "Could not find usable WinSock DLL.");

++		connection->error = MPD_ERROR_SYSTEM;

++		return 1;

++	}

++	return 0;

++}

++

++static int do_connect_fail(mpd_Connection *connection,

++                           const struct sockaddr *serv_addr, int addrlen)

++{

++	int iMode = 1; /* 0 = blocking, else non-blocking */

++	ioctlsocket(connection->sock, FIONBIO, (u_long FAR*) &iMode);

++	return (connect(connection->sock,serv_addr,addrlen) == SOCKET_ERROR

++			&& WSAGetLastError() != WSAEWOULDBLOCK);

++}

++#else /* !WIN32 (sane operating systems) */

++static int do_connect_fail(mpd_Connection *connection,

++                           const struct sockaddr *serv_addr, int addrlen)

++{

++	int flags = fcntl(connection->sock, F_GETFL, 0);

++	fcntl(connection->sock, F_SETFL, flags | O_NONBLOCK);

++	return (connect(connection->sock,serv_addr,addrlen)<0 &&

++				errno!=EINPROGRESS);

++}

++#endif /* !WIN32 */

++

++#ifdef MPD_HAVE_GAI

++static int mpd_connect(mpd_Connection * connection, const char * host, int port,

++                       float timeout)

++{

++	int error;

++	char service[INTLEN+1];

++	struct addrinfo hints;

++	struct addrinfo *res = NULL;

++	struct addrinfo *addrinfo = NULL;

++

++	/**

++	 * Setup hints

++	 */

++	hints.ai_flags     = AI_ADDRCONFIG;

++	hints.ai_family    = PF_UNSPEC;

++	hints.ai_socktype  = SOCK_STREAM;

++	hints.ai_protocol  = IPPROTO_TCP;

++	hints.ai_addrlen   = 0;

++	hints.ai_addr      = NULL;

++	hints.ai_canonname = NULL;

++	hints.ai_next      = NULL;

++

++	snprintf(service, sizeof(service), "%i", port);

++

++	error = getaddrinfo(host, service, &hints, &addrinfo);

++

++	if (error) {

++		snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH,

++		         "host \"%s\" not found: %s",

++		         host, gai_strerror(error));

++		connection->error = MPD_ERROR_UNKHOST;

++		return -1;

++	}

++

++	for (res = addrinfo; res; res = res->ai_next) {

++		/* create socket */

++		connection->sock = socket(res->ai_family, SOCK_STREAM,

++		                          res->ai_protocol);

++		if (connection->sock < 0) {

++			snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH,

++			         "problems creating socket: %s",

++			         strerror(errno));

++			connection->error = MPD_ERROR_SYSTEM;

++			freeaddrinfo(addrinfo);

++			return -1;

++		}

++

++		mpd_setConnectionTimeout(connection, timeout);

++

++		/* connect stuff */

++ 		if (do_connect_fail(connection,

++		                    res->ai_addr, res->ai_addrlen)) {

++ 			/* try the next address family */

++ 			closesocket(connection->sock);

++ 			connection->sock = -1;

++ 			continue;

++		}

++	}

++

++	freeaddrinfo(addrinfo);

++

++	if (connection->sock < 0) {

++		snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH,

++		         "problems connecting to \"%s\" on port %i: %s",

++		         host, port, strerror(errno));

++		connection->error = MPD_ERROR_CONNPORT;

++

++		return -1;

++	}

++

++	return 0;

++}

++#else /* !MPD_HAVE_GAI */

++static int mpd_connect(mpd_Connection * connection, const char * host, int port,

++                       float timeout)

++{

++	struct hostent * he;

++	struct sockaddr * dest;

++	int destlen;

++	struct sockaddr_in sin;

++

++	if(!(he=gethostbyname(host))) {

++		snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH,

++				"host \"%s\" not found",host);

++		connection->error = MPD_ERROR_UNKHOST;

++		return -1;

++	}

++

++	memset(&sin,0,sizeof(struct sockaddr_in));

++	/*dest.sin_family = he->h_addrtype;*/

++	sin.sin_family = AF_INET;

++	sin.sin_port = htons(port);

++

++	switch(he->h_addrtype) {

++	case AF_INET:

++		memcpy((char *)&sin.sin_addr.s_addr,(char *)he->h_addr,

++				he->h_length);

++		dest = (struct sockaddr *)&sin;

++		destlen = sizeof(struct sockaddr_in);

++		break;

++	default:

++		strcpy(connection->errorStr,"address type is not IPv4");