src/mpdclient.c

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