src/mpdclient.c

   1 /*
   2  * $Id$
   3  *
   4  * (c) 2004 by Kalle Wallin <kaw@linux.se>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <time.h>
  25 #include <string.h>
  26 #include <glib.h>
  27
  28 #include "config.h"
  29 #include "ncmpc.h"
  30 #include "support.h"
  31 #include "mpdclient.h"
  32 #include "options.h"
  33
  34 #undef  ENABLE_FANCY_PLAYLIST_MANAGMENT_CMD_ADD /* broken with song id's */
  35 #define ENABLE_FANCY_PLAYLIST_MANAGMENT_CMD_DELETE
  36 #define ENABLE_FANCY_PLAYLIST_MANAGMENT_CMD_MOVE
  37 #define ENABLE_SONG_ID
  38 #define ENABLE_PLCHANGES
  39
  40 #define MPD_ERROR(c) (c==NULL || c->connection==NULL || c->connection->error)
  41
  42
  43 /* Error callbacks */
  44 static gint
  45 error_cb(mpdclient_t *c, gint error, gchar *msg)
  46 {
  47   GList *list = c->error_callbacks;
  48
  49   if( list==NULL )
  50     fprintf(stderr, "error [%d]: %s\n", (error & 0xFF), msg);
  51
  52   while(list)
  53     {
  54       mpdc_error_cb_t cb = list->data;
  55       if( cb )
  56         cb(c, error, msg);
  57       list=list->next;
  58     }
  59   mpd_clearError(c->connection);
  60   return error;
  61 }
  62
  63 #ifdef DEBUG
  64 #include "strfsong.h"
  65
  66 static gchar *
  67 get_song_name(mpd_Song *song)
  68 {
  69   static gchar name[256];
  70
  71   strfsong(name, 256, "[%artist% - ]%title%|%file%", song);
  72   return name;
  73 }
  74
  75 #endif
  76
  77 /****************************************************************************/
  78 /*** mpdclient functions ****************************************************/
  79 /****************************************************************************/
  80
  81 gint
  82 mpdclient_finish_command(mpdclient_t *c)
  83 {
  84   mpd_finishCommand(c->connection);
  85
  86   if( c->connection->error )
  87     {
  88       gchar *msg = locale_to_utf8(c->connection->errorStr);
  89       gint error = c->connection->error;
  90
  91       if( error == MPD_ERROR_ACK )
  92         error = error | (c->connection->errorCode << 8);
  93
  94       error_cb(c, error, msg);
  95       g_free(msg);
  96       return error;
  97     }
  98
  99   return 0;
 100 }
 101
 102 mpdclient_t *
 103 mpdclient_new(void)
 104 {
 105   mpdclient_t *c;
 106
 107   c = g_malloc0(sizeof(mpdclient_t));
 108
 109   return c;
 110 }
 111
 112 mpdclient_t *
 113 mpdclient_free(mpdclient_t *c)
 114 {
 115   mpdclient_disconnect(c);
 116   g_list_free(c->error_callbacks);
 117   g_list_free(c->playlist_callbacks);
 118   g_list_free(c->browse_callbacks);
 119   g_free(c);
 120
 121   return NULL;
 122 }
 123
 124 gint
 125 mpdclient_disconnect(mpdclient_t *c)
 126 {
 127   if( c->connection )
 128     mpd_closeConnection(c->connection);
 129   c->connection = NULL;
 130
 131   if( c->status )
 132     mpd_freeStatus(c->status);
 133   c->status = NULL;
 134
 135   if( c->playlist.list )
 136     mpdclient_playlist_free(&c->playlist);
 137
 138   if( c->song )
 139     c->song = NULL;
 140
 141   return 0;
 142 }
 143
 144 gint
 145 mpdclient_connect(mpdclient_t *c,
 146                   gchar *host,
 147                   gint port,
 148                   gfloat timeout,
 149                   gchar *password)
 150 {
 151   gint retval = 0;
 152
 153   /* close any open connection */
 154   if( c->connection )
 155     mpdclient_disconnect(c);
 156
 157   /* connect to MPD */
 158   c->connection = mpd_newConnection(host, port, timeout);
 159   if( c->connection->error )
 160     return error_cb(c, c->connection->error, c->connection->errorStr);
 161
 162   /* send password */
 163   if( password )
 164     {
 165       mpd_sendPasswordCommand(c->connection, password);
 166       retval = mpdclient_finish_command(c);
 167     }
 168   c->need_update = TRUE;
 169
 170   return retval;
 171 }
 172
 173 gint
 174 mpdclient_update(mpdclient_t *c)
 175 {
 176   gint retval = 0;
 177
 178   if( MPD_ERROR(c) )
 179     return -1;
 180
 181   /* free the old status */
 182   if( c->status )
 183     mpd_freeStatus(c->status);
 184
 185   /* retreive new status */
 186   mpd_sendStatusCommand(c->connection);
 187   c->status = mpd_getStatus(c->connection);
 188   if( (retval=mpdclient_finish_command(c)) )
 189     return retval;
 190 #ifdef DEBUG
 191   if( c->status->error )
 192     D("status> %s\n", c->status->error);
 193 #endif
 194
 195   /* check if the playlist needs an update */
 196   if( c->playlist.id != c->status->playlist )
 197     {
 198       if( c->playlist.list )
 199         retval = mpdclient_playlist_update_changes(c);
 200       else
 201         retval = mpdclient_playlist_update(c);
 202     }
 203
 204   /* update the current song */
 205   if( !c->song || c->status->songid != c->song->id )
 206     {
 207       c->song = playlist_get_song(c, c->status->song);
 208     }
 209
 210   c->need_update = FALSE;
 211
 212   return retval;
 213 }
 214
 215
 216 /****************************************************************************/
 217 /*** MPD Commands  **********************************************************/
 218 /****************************************************************************/
 219
 220 gint
 221 mpdclient_cmd_play(mpdclient_t *c, gint index)
 222 {
 223 #ifdef ENABLE_SONG_ID
 224   mpd_Song *song = playlist_get_song(c, index);
 225
 226   D("Play id:%d\n", song ? song->id : -1);
 227   if( song )
 228     mpd_sendPlayIdCommand(c->connection, song->id);
 229   else
 230     mpd_sendPlayIdCommand(c->connection, MPD_PLAY_AT_BEGINNING);
 231 #else
 232   mpd_sendPlayCommand(c->connection, index);
 233 #endif
 234   c->need_update = TRUE;
 235   return mpdclient_finish_command(c);
 236 }
 237
 238 gint
 239 mpdclient_cmd_pause(mpdclient_t *c, gint value)
 240 {
 241   mpd_sendPauseCommand(c->connection, value);
 242   return mpdclient_finish_command(c);
 243 }
 244
 245 gint
 246 mpdclient_cmd_stop(mpdclient_t *c)
 247 {
 248   mpd_sendStopCommand(c->connection);
 249   return mpdclient_finish_command(c);
 250 }
 251
 252 gint
 253 mpdclient_cmd_next(mpdclient_t *c)
 254 {
 255   mpd_sendNextCommand(c->connection);
 256   c->need_update = TRUE;
 257   return mpdclient_finish_command(c);
 258 }
 259
 260 gint
 261 mpdclient_cmd_prev(mpdclient_t *c)
 262 {
 263   mpd_sendPrevCommand(c->connection);
 264   c->need_update = TRUE;
 265   return mpdclient_finish_command(c);
 266 }
 267
 268 gint
 269 mpdclient_cmd_seek(mpdclient_t *c, gint id, gint pos)
 270 {
 271   D("Seek id:%d\n", id);
 272   mpd_sendSeekIdCommand(c->connection, id, pos);
 273   return mpdclient_finish_command(c);
 274 }
 275
 276 gint
 277 mpdclient_cmd_shuffle(mpdclient_t *c)
 278 {
 279   mpd_sendShuffleCommand(c->connection);
 280   c->need_update = TRUE;
 281   return mpdclient_finish_command(c);
 282 }
 283
 284 gint
 285 mpdclient_cmd_clear(mpdclient_t *c)
 286 {
 287   gint retval = 0;
 288
 289   mpd_sendClearCommand(c->connection);
 290   retval = mpdclient_finish_command(c);
 291   /* call playlist updated callback */
 292   mpdclient_playlist_callback(c, PLAYLIST_EVENT_CLEAR, NULL);
 293   c->need_update = TRUE;
 294   return retval;
 295 }
 296
 297 gint
 298 mpdclient_cmd_repeat(mpdclient_t *c, gint value)
 299 {
 300   mpd_sendRepeatCommand(c->connection, value);
 301   return mpdclient_finish_command(c);
 302 }
 303
 304 gint
 305 mpdclient_cmd_random(mpdclient_t *c, gint value)
 306 {
 307   mpd_sendRandomCommand(c->connection, value);
 308   return mpdclient_finish_command(c);
 309 }
 310
 311 gint
 312 mpdclient_cmd_crossfade(mpdclient_t *c, gint value)
 313 {
 314   mpd_sendCrossfadeCommand(c->connection, value);
 315   return mpdclient_finish_command(c);
 316 }
 317
 318 gint
 319 mpdclient_cmd_db_update_utf8(mpdclient_t *c, gchar *path)
 320 {
 321   mpd_sendUpdateCommand(c->connection, path ? path : "");
 322   return mpdclient_finish_command(c);
 323 }
 324
 325 gint
 326 mpdclient_cmd_volume(mpdclient_t *c, gint value)
 327 {
 328   mpd_sendSetvolCommand(c->connection, value);
 329   return mpdclient_finish_command(c);
 330 }
 331
 332 gint
 333 mpdclient_cmd_add_path_utf8(mpdclient_t *c, gchar *path_utf8)
 334 {
 335   mpd_sendAddCommand(c->connection, path_utf8);
 336   return mpdclient_finish_command(c);
 337 }
 338
 339 gint
 340 mpdclient_cmd_add_path(mpdclient_t *c, gchar *path)
 341 {
 342   gint retval;
 343   gchar *path_utf8 = locale_to_utf8(path);
 344
 345   retval=mpdclient_cmd_add_path_utf8(c, path_utf8);
 346   g_free(path_utf8);
 347   return retval;
 348 }
 349
 350 gint
 351 mpdclient_cmd_add(mpdclient_t *c, mpd_Song *song)
 352 {
 353   gint retval = 0;
 354
 355   if( !song || !song->file )
 356     return -1;
 357
 358   /* send the add command to mpd */
 359   mpd_sendAddCommand(c->connection, song->file);
 360   if( (retval=mpdclient_finish_command(c)) )
 361     return retval;
 362
 363 #ifdef ENABLE_FANCY_PLAYLIST_MANAGMENT_CMD_ADD
 364   /* add the song to playlist */
 365   c->playlist.list = g_list_append(c->playlist.list, mpd_songDup(song));
 366   c->playlist.length++;
 367
 368   /* increment the playlist id, so we dont retrives a new playlist */
 369   c->playlist.id++;
 370
 371   /* call playlist updated callback */
 372   mpdclient_playlist_callback(c, PLAYLIST_EVENT_ADD, (gpointer) song);
 373 #else
 374   c->need_update = TRUE;
 375 #endif
 376
 377   return 0;
 378 }
 379
 380 gint
 381 mpdclient_cmd_delete(mpdclient_t *c, gint index)
 382 {
 383   gint retval = 0;
 384   mpd_Song *song = playlist_get_song(c, index);
 385
 386   if( !song )
 387     return -1;
 388
 389   /* send the delete command to mpd */
 390 #ifdef ENABLE_SONG_ID
 391   D("Delete id:%d\n", song->id);
 392   mpd_sendDeleteIdCommand(c->connection, song->id);
 393 #else
 394   mpd_sendDeleteCommand(c->connection, index);
 395 #endif
 396   if( (retval=mpdclient_finish_command(c)) )
 397     return retval;
 398
 399 #ifdef ENABLE_FANCY_PLAYLIST_MANAGMENT_CMD_DELETE
 400   /* increment the playlist id, so we dont retrive a new playlist */
 401   c->playlist.id++;
 402
 403   /* remove the song from the playlist */
 404   c->playlist.list = g_list_remove(c->playlist.list, (gpointer) song);
 405   c->playlist.length = g_list_length(c->playlist.list);
 406
 407   /* call playlist updated callback */
 408   mpdclient_playlist_callback(c, PLAYLIST_EVENT_DELETE, (gpointer) song);
 409
 410   /* remove references to the song */
 411   if( c->song == song )
 412     {
 413       c->song = NULL;
 414       c->need_update = TRUE;
 415     }
 416
 417   /* free song */
 418   mpd_freeSong(song);
 419
 420 #else
 421   c->need_update = TRUE;
 422 #endif
 423
 424   return 0;
 425 }
 426
 427 gint
 428 mpdclient_cmd_move(mpdclient_t *c, gint old_index, gint new_index)
 429 {
 430   gint n, index1, index2;
 431   GList *item1, *item2;
 432   gpointer data1, data2;
 433   mpd_Song *song1, *song2;
 434
 435   if( old_index==new_index || new_index<0 || new_index>=c->playlist.length )
 436     return -1;
 437
 438   song1 = playlist_get_song(c, old_index);
 439   song2 = playlist_get_song(c, new_index);
 440
 441   /* send the move command to mpd */
 442 #ifdef ENABLE_SONG_ID
 443   D("Swaping id:%d with id:%d\n", song1->id, song2->id);
 444   mpd_sendSwapIdCommand(c->connection, song1->id, song2->id);
 445 #else
 446   D("Moving index %d to id:%d\n", old_index, new_index);
 447   mpd_sendMoveCommand(c->connection, old_index, new_index);
 448 #endif
 449   if( (n=mpdclient_finish_command(c)) )
 450     return n;
 451
 452 #ifdef ENABLE_FANCY_PLAYLIST_MANAGMENT_CMD_MOVE
 453   /* update the songs position field */
 454   n = song1->pos;
 455   song1->pos = song2->pos;
 456   song2->pos = n;
 457   index1 = MIN(old_index, new_index);
 458   index2 = MAX(old_index, new_index);
 459   /* retreive the list items */
 460   item1 = g_list_nth(c->playlist.list, index1);
 461   item2 = g_list_nth(c->playlist.list, index2);
 462   /* retrieve the songs */
 463   data1 = item1->data;
 464   data2 = item2->data;
 465
 466   /* move the second item */
 467   c->playlist.list = g_list_remove(c->playlist.list, data2);
 468   c->playlist.list = g_list_insert_before(c->playlist.list, item1, data2);
 469
 470   /* move the first item */
 471   if( index2-index1 >1 )
 472     {
 473       item2 = g_list_nth(c->playlist.list, index2);
 474       c->playlist.list = g_list_remove(c->playlist.list, data1);
 475       c->playlist.list = g_list_insert_before(c->playlist.list, item2, data1);
 476     }
 477
 478   /* increment the playlist id, so we dont retrives a new playlist */
 479   c->playlist.id++;
 480
 481 #else
 482   c->need_update = TRUE;
 483 #endif
 484
 485   /* call playlist updated callback */
 486   mpdclient_playlist_callback(c, PLAYLIST_EVENT_MOVE, (gpointer) &new_index);
 487
 488   return 0;
 489 }
 490
 491 gint
 492 mpdclient_cmd_save_playlist_utf8(mpdclient_t *c, gchar *filename_utf8)
 493 {
 494   gint retval = 0;
 495
 496   mpd_sendSaveCommand(c->connection, filename_utf8);
 497   if( (retval=mpdclient_finish_command(c)) == 0 )
 498     mpdclient_browse_callback(c, BROWSE_PLAYLIST_SAVED, NULL);
 499   return retval;
 500 }
 501
 502 gint
 503 mpdclient_cmd_save_playlist(mpdclient_t *c, gchar *filename)
 504 {
 505   gint retval = 0;
 506   gchar *filename_utf8 = locale_to_utf8(filename);
 507
 508   retval = mpdclient_cmd_save_playlist_utf8(c, filename);
 509   g_free(filename_utf8);
 510   return retval;
 511 }
 512
 513 gint
 514 mpdclient_cmd_load_playlist_utf8(mpdclient_t *c, gchar *filename_utf8)
 515 {
 516   mpd_sendLoadCommand(c->connection, filename_utf8);
 517   c->need_update = TRUE;
 518   return mpdclient_finish_command(c);
 519 }
 520
 521 gint
 522 mpdclient_cmd_delete_playlist_utf8(mpdclient_t *c, gchar *filename_utf8)
 523 {
 524   gint retval = 0;
 525
 526   mpd_sendRmCommand(c->connection, filename_utf8);
 527   if( (retval=mpdclient_finish_command(c)) == 0 )
 528     mpdclient_browse_callback(c, BROWSE_PLAYLIST_DELETED, NULL);
 529   return retval;
 530 }
 531
 532 gint
 533 mpdclient_cmd_delete_playlist(mpdclient_t *c, gchar *filename)
 534 {
 535   gint retval = 0;
 536   gchar *filename_utf8 = locale_to_utf8(filename);
 537
 538   retval = mpdclient_cmd_delete_playlist_utf8(c, filename_utf8);
 539   g_free(filename_utf8);
 540   return retval;
 541 }
 542
 543
 544 /****************************************************************************/
 545 /*** Callback managment functions *******************************************/
 546 /****************************************************************************/
 547 static void
 548 do_list_callbacks(mpdclient_t *c, GList *list, gint event, gpointer data)
 549 {
 550   while(list)
 551     {
 552       mpdc_list_cb_t fn = list->data;
 553
 554       fn(c, event, data);
 555       list=list->next;
 556     }
 557 }
 558
 559 void
 560 mpdclient_playlist_callback(mpdclient_t *c, int event, gpointer data)
 561 {
 562   do_list_callbacks(c, c->playlist_callbacks, event, data);
 563 }
 564
 565 void
 566 mpdclient_install_playlist_callback(mpdclient_t *c,mpdc_list_cb_t cb)
 567 {
 568   c->playlist_callbacks = g_list_append(c->playlist_callbacks, cb);
 569 }
 570
 571 void
 572 mpdclient_remove_playlist_callback(mpdclient_t *c, mpdc_list_cb_t cb)
 573 {
 574   c->playlist_callbacks = g_list_remove(c->playlist_callbacks, cb);
 575 }
 576
 577 void
 578 mpdclient_browse_callback(mpdclient_t *c, int event, gpointer data)
 579 {
 580   do_list_callbacks(c, c->browse_callbacks, event, data);
 581 }
 582
 583
 584 void
 585 mpdclient_install_browse_callback(mpdclient_t *c,mpdc_list_cb_t cb)
 586 {
 587   c->browse_callbacks = g_list_append(c->browse_callbacks, cb);
 588 }
 589
 590 void
 591 mpdclient_remove_browse_callback(mpdclient_t *c, mpdc_list_cb_t cb)
 592 {
 593   c->browse_callbacks = g_list_remove(c->browse_callbacks, cb);
 594 }
 595
 596 void
 597 mpdclient_install_error_callback(mpdclient_t *c, mpdc_error_cb_t cb)
 598 {
 599   c->error_callbacks = g_list_append(c->error_callbacks, cb);
 600 }
 601
 602 void
 603 mpdclient_remove_error_callback(mpdclient_t *c, mpdc_error_cb_t cb)
 604 {
 605   c->error_callbacks = g_list_remove(c->error_callbacks, cb);
 606 }
 607
 608 /****************************************************************************/
 609 /*** Playlist managment functions *******************************************/
 610 /****************************************************************************/
 611
 612 gint
 613 mpdclient_playlist_free(mpdclient_playlist_t *playlist)
 614 {
 615   GList *list = g_list_first(playlist->list);
 616
 617   while(list)
 618     {
 619       mpd_Song *song = (mpd_Song *) list->data;
 620       mpd_freeSong(song);
 621       list=list->next;
 622     }
 623   g_list_free(playlist->list);
 624   memset(playlist, 0, sizeof(mpdclient_playlist_t));
 625   return 0;
 626 }
 627
 628 /* update playlist */
 629 gint
 630 mpdclient_playlist_update(mpdclient_t *c)
 631 {
 632   mpd_InfoEntity *entity;
 633
 634   D("mpdclient_playlist_update() [%lld]\n", c->status->playlist);
 635
 636   if( MPD_ERROR(c) )
 637     return -1;
 638
 639   if( c->playlist.list )
 640     mpdclient_playlist_free(&c->playlist);
 641
 642   mpd_sendPlaylistInfoCommand(c->connection,-1);
 643   while( (entity=mpd_getNextInfoEntity(c->connection)) )
 644     {
 645       if(entity->type==MPD_INFO_ENTITY_TYPE_SONG)
 646         {
 647           mpd_Song *song = mpd_songDup(entity->info.song);
 648
 649           c->playlist.list = g_list_append(c->playlist.list, (gpointer) song);
 650           c->playlist.length++;
 651         }
 652       mpd_freeInfoEntity(entity);
 653     }
 654   c->playlist.id = c->status->playlist;
 655   c->song = NULL;
 656   c->playlist.updated = TRUE;
 657
 658   /* call playlist updated callbacks */
 659   mpdclient_playlist_callback(c, PLAYLIST_EVENT_UPDATED, NULL);
 660
 661   return mpdclient_finish_command(c);
 662 }
 663
 664 #ifdef ENABLE_PLCHANGES
 665
 666 gint
 667 mpdclient_compare_songs(gconstpointer a, gconstpointer b)
 668 {
 669   mpd_Song *song1 = (mpd_Song *) a;
 670   mpd_Song *song2 = (mpd_Song *) b;
 671
 672   return song1->pos - song2->pos;
 673 }
 674
 675
 676
 677 /* update playlist (plchanges) */
 678
 679 gint
 680 mpdclient_playlist_update_changes(mpdclient_t *c)
 681 {
 682   mpd_InfoEntity *entity;
 683
 684   D("mpdclient_playlist_update_changes() [%lld -> %lld]\n",
 685     c->status->playlist, c->playlist.id);
 686
 687   if( MPD_ERROR(c) )
 688     return -1;
 689
 690   mpd_sendPlChangesCommand(c->connection, c->playlist.id);
 691
 692   while( (entity=mpd_getNextInfoEntity(c->connection)) != NULL   )
 693     {
 694
 695       if(entity->type==MPD_INFO_ENTITY_TYPE_SONG)
 696         {
 697           mpd_Song *song = entity->info.song;
 698           GList *item;
 699
 700           item =  playlist_lookup(c, song->id);
 701
 702 #ifdef DEBUG
 703           if( item )
 704             D("Changing index:%d, pos:%d, id:%d => %s\n",
 705               g_list_position(c->playlist.list, item),
 706               song->pos, song->id, get_song_name(song));
 707           else
 708             D("Unable to find pos:%d, id:%d => %s\n",
 709               song->pos, song->id, get_song_name(song));
 710 #endif
 711
 712           if( item && item->data)
 713             {
 714               GList *old;
 715               gint index = g_list_position(c->playlist.list, item);
 716
 717               /* remove previous song at song->pos */
 718               while( song->pos != (index=g_list_position(c->playlist.list, item))
 719                      &&
 720                      (old=g_list_nth(c->playlist.list, song->pos)) )
 721                 {
 722                   D("Removing item with index %d id:%d (%d)\n",
 723                     song->pos, old ? ((mpd_Song *) old->data)->id : -1, index);
 724                   if( item->data == c->song )
 725                     c->song = NULL;
 726                   mpd_freeSong((mpd_Song *) old->data);
 727                   old->data = NULL;
 728                   c->playlist.list = g_list_delete_link(c->playlist.list, old);
 729                   c->playlist.length = g_list_length(c->playlist.list);
 730                 }
 731
 732               /* Update playlist entry */
 733               mpd_freeSong((mpd_Song *) item->data);
 734               item->data = mpd_songDup(song);
 735               if( c->song && c->song->id == song->id )
 736                 c->song = item->data;
 737
 738             }
 739           else
 740             {
 741               /* Add a new  playlist entry */
 742               D("Adding pos:%d, id;%d - %s\n",
 743                 song->pos, song->id, get_song_name(song));
 744               c->playlist.list = g_list_append(c->playlist.list,
 745                                                (gpointer) mpd_songDup(song));
 746               c->playlist.length++;
 747             }
 748         }
 749       mpd_freeInfoEntity(entity);
 750     }
 751   mpd_finishCommand(c->connection);
 752
 753   while( g_list_length(c->playlist.list) > c->status->playlistLength )
 754     {
 755       GList *item = g_list_last(c->playlist.list);
 756
 757       /* Remove the last playlist entry */
 758       mpd_freeSong((mpd_Song *) item->data);
 759       c->playlist.list = g_list_delete_link(c->playlist.list, item);
 760       c->playlist.length--;
 761       D("Removed the last playlist entry\n");
 762     }
 763
 764   c->playlist.id = c->status->playlist;
 765   c->playlist.updated = TRUE;
 766
 767   mpdclient_playlist_callback(c, PLAYLIST_EVENT_UPDATED, NULL);
 768
 769   return 0;
 770 }
 771 #else
 772 gint
 773 mpdclient_playlist_update_changes(mpdclient_t *c)
 774 {
 775   return mpdclient_playlist_update(c);
 776 }
 777 #endif
 778
 779 mpd_Song *
 780 playlist_get_song(mpdclient_t *c, gint index)
 781 {
 782   return (mpd_Song *) g_list_nth_data(c->playlist.list, index);
 783 }
 784
 785 GList *
 786 playlist_lookup(mpdclient_t *c, int id)
 787 {
 788   GList *list = g_list_first(c->playlist.list);
 789
 790   while( list )
 791     {
 792       mpd_Song *song = (mpd_Song *) list->data;
 793       if( song->id == id )
 794         return list;
 795       list=list->next;
 796     }
 797   return NULL;
 798 }
 799
 800 mpd_Song *
 801 playlist_lookup_song(mpdclient_t *c, gint id)
 802 {
 803   GList *list = c->playlist.list;
 804
 805   while( list )
 806     {
 807       mpd_Song *song = (mpd_Song *) list->data;
 808       if( song->id == id )
 809         return song;
 810       list=list->next;
 811     }
 812   return NULL;
 813 }
 814
 815 gint
 816 playlist_get_index(mpdclient_t *c, mpd_Song *song)
 817 {
 818   return g_list_index(c->playlist.list, song);
 819 }
 820
 821 gint
 822 playlist_get_index_from_id(mpdclient_t *c, gint id)
 823 {
 824   return g_list_index(c->playlist.list, playlist_lookup_song(c, id));
 825 }
 826
 827 gint
 828 playlist_get_index_from_file(mpdclient_t *c, gchar *filename)
 829 {
 830   GList *list = c->playlist.list;
 831   gint i=0;
 832
 833   while( list )
 834     {
 835       mpd_Song *song = (mpd_Song *) list->data;
 836       if( strcmp(song->file, filename ) == 0 )
 837         return i;
 838       list=list->next;
 839       i++;
 840     }
 841   return -1;
 842 }
 843
 844
 845 /****************************************************************************/
 846 /*** Filelist functions *****************************************************/
 847 /****************************************************************************/
 848
 849 mpdclient_filelist_t *
 850 mpdclient_filelist_free(mpdclient_filelist_t *filelist)
 851 {
 852   GList *list = g_list_first(filelist->list);
 853
 854   D("mpdclient_filelist_free()\n");
 855   while( list!=NULL )
 856     {
 857       filelist_entry_t *entry = list->data;
 858
 859       if( entry->entity )
 860         mpd_freeInfoEntity(entry->entity);
 861       g_free(entry);
 862       list=list->next;
 863     }
 864   g_list_free(filelist->list);
 865   g_free(filelist->path);
 866   filelist->path = NULL;
 867   filelist->list = NULL;
 868   filelist->length = 0;
 869   g_free(filelist);
 870
 871   return NULL;
 872 }
 873
 874
 875 mpdclient_filelist_t *
 876 mpdclient_filelist_get(mpdclient_t *c, gchar *path)
 877 {
 878   mpdclient_filelist_t *filelist;
 879   mpd_InfoEntity *entity;
 880   gchar *path_utf8 = locale_to_utf8(path);
 881
 882   D("mpdclient_filelist_get(%s)\n", path);
 883   mpd_sendLsInfoCommand(c->connection, path_utf8);
 884   filelist = g_malloc0(sizeof(mpdclient_filelist_t));
 885   if( path && path[0] && strcmp(path, "/") )
 886     {
 887       /* add a dummy entry for ./.. */
 888       filelist_entry_t *entry = g_malloc0(sizeof(filelist_entry_t));
 889       entry->entity = NULL;
 890       filelist->list = g_list_append(filelist->list, (gpointer) entry);
 891       filelist->length++;
 892     }
 893
 894   while( (entity=mpd_getNextInfoEntity(c->connection)) )
 895     {
 896       filelist_entry_t *entry = g_malloc0(sizeof(filelist_entry_t));
 897
 898       entry->entity = entity;
 899       filelist->list = g_list_append(filelist->list, (gpointer) entry);
 900       filelist->length++;
 901     }
 902
 903   if( mpdclient_finish_command(c) )
 904     {
 905       g_free(path_utf8);
 906       return mpdclient_filelist_free(filelist);
 907     }
 908
 909   g_free(path_utf8);
 910   filelist->path = g_strdup(path);
 911   filelist->updated = TRUE;
 912
 913   return filelist;
 914 }
 915
 916 mpdclient_filelist_t *
 917 mpdclient_filelist_update(mpdclient_t *c, mpdclient_filelist_t *filelist)
 918 {
 919   if( filelist != NULL )
 920     {
 921       gchar *path = g_strdup(filelist->path);
 922
 923       filelist = mpdclient_filelist_free(filelist);
 924       filelist = mpdclient_filelist_get(c, path);
 925       g_free(path);
 926       return filelist;
 927     }
 928   return NULL;
 929 }
 930
 931 filelist_entry_t *
 932 mpdclient_filelist_find_song(mpdclient_filelist_t *fl, mpd_Song *song)
 933 {
 934   GList *list = g_list_first(fl->list);
 935
 936   while( list && song)
 937     {
 938       filelist_entry_t *entry = list->data;
 939       mpd_InfoEntity *entity  = entry->entity;
 940
 941       if( entity && entity->type==MPD_INFO_ENTITY_TYPE_SONG )
 942         {
 943           mpd_Song *song2 = entity->info.song;
 944
 945           if( strcmp(song->file, song2->file) == 0 )
 946             {
 947               return entry;
 948             }
 949         }
 950       list = list->next;
 951     }
 952   return NULL;
 953 }
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963