src/libmpd-playlist.c

   1 /* libmpd (high level libmpdclient library)
   2  * Copyright (C) 2004-2009 Qball Cow <qball@sarine.nl>
   3  * Project homepage: http://gmpcwiki.sarine.nl/
   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 <stdio.h>
  21 #include <stdlib.h>
  22 #define __USE_GNU
  23
  24 #include <string.h>
  25 #include <stdarg.h>
  26 #include <config.h>
  27 #include "debug_printf.h"
  28 #include "libmpd.h"
  29 #include "libmpd-internal.h"
  30
  31
  32 int mpd_playlist_get_playlist_length(MpdObj *mi)
  33 {
  34         if(!mpd_check_connected(mi))
  35         {
  36                 debug_printf(DEBUG_WARNING,"not connected\n");
  37                 return MPD_NOT_CONNECTED;
  38         }
  39         if(mpd_status_check(mi) != MPD_OK)
  40         {
  41                 debug_printf(DEBUG_ERROR,"Failed grabbing status\n");
  42                 return MPD_STATUS_FAILED;
  43         }
  44         return mi->status->playlistLength;
  45 }
  46
  47 long long mpd_playlist_get_old_playlist_id(MpdObj *mi)
  48 {
  49         return mi->OldState.playlistid;
  50 }
  51
  52 long long mpd_playlist_get_playlist_id(MpdObj *mi)
  53 {
  54         if(!mpd_check_connected(mi))
  55         {
  56                 debug_printf(DEBUG_WARNING,"not connected\n");
  57                 return MPD_NOT_CONNECTED;
  58         }
  59         if(mpd_status_check(mi) != MPD_OK)
  60         {
  61                 debug_printf(DEBUG_WARNING,"Failed grabbing status\n");
  62                 return MPD_STATUS_FAILED;
  63         }
  64         return mi->status->playlist;
  65 }
  66 int mpd_playlist_add(MpdObj *mi,const char *path)
  67 {
  68         int retv = mpd_playlist_queue_add(mi, path);
  69         if(retv != MPD_OK) return retv;
  70         return mpd_playlist_queue_commit(mi);
  71 }
  72
  73 int mpd_playlist_delete_id(MpdObj *mi, int songid)
  74 {
  75         int retv = mpd_playlist_queue_delete_id(mi, songid);
  76         if(retv != MPD_OK) return retv;
  77         return mpd_playlist_queue_commit(mi);
  78 }
  79
  80 int mpd_playlist_delete_pos(MpdObj *mi, int songpos)
  81 {
  82         int retv = mpd_playlist_queue_delete_pos(mi, songpos);
  83         if(retv != MPD_OK) return retv;
  84         return mpd_playlist_queue_commit(mi);
  85 }
  86 /*******************************************************************************
  87  * PLAYLIST
  88  */
  89 mpd_Song * mpd_playlist_get_song(MpdObj *mi, int songid)
  90 {
  91         mpd_Song *song = NULL;
  92         mpd_InfoEntity *ent = NULL;
  93         if(songid < 0){
  94                 debug_printf(DEBUG_ERROR, "songid < 0 Failed");
  95                 return NULL;
  96         }
  97         if(!mpd_check_connected(mi))
  98         {
  99                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 100                 return NULL;
 101         }
 102
 103         if(mpd_lock_conn(mi))
 104         {
 105                 return NULL;
 106         }
 107         debug_printf(DEBUG_INFO, "Trying to grab song with id: %i\n", songid);
 108         mpd_sendPlaylistIdCommand(mi->connection, songid);
 109         ent = mpd_getNextInfoEntity(mi->connection);
 110         mpd_finishCommand(mi->connection);
 111
 112         if(mpd_unlock_conn(mi))
 113         {
 114                 if(ent) mpd_freeInfoEntity(ent);
 115                 return NULL;
 116         }
 117
 118         if(ent == NULL)
 119         {
 120                 debug_printf(DEBUG_ERROR, "Failed to grab song from mpd\n");
 121                 return NULL;
 122         }
 123
 124         if(ent->type != MPD_INFO_ENTITY_TYPE_SONG)
 125         {
 126                 mpd_freeInfoEntity(ent);
 127                 debug_printf(DEBUG_ERROR, "Failed to grab correct song type from mpd\n");
 128                 return NULL;
 129         }
 130         song = ent->info.song;
 131         ent->info.song = NULL;
 132
 133         mpd_freeInfoEntity(ent);
 134
 135         return song;
 136 }
 137
 138 mpd_Song * mpd_playlist_get_song_from_pos(MpdObj *mi, int songpos)
 139 {
 140         mpd_Song *song = NULL;
 141         mpd_InfoEntity *ent = NULL;
 142         if(songpos < 0){
 143                 debug_printf(DEBUG_ERROR, "songpos < 0 Failed");
 144                 return NULL;
 145         }
 146         if(!mpd_check_connected(mi))
 147         {
 148                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 149                 return NULL;
 150         }
 151
 152         if(mpd_lock_conn(mi))
 153         {
 154                 return NULL;
 155         }
 156         debug_printf(DEBUG_INFO, "Trying to grab song with id: %i\n", songpos);
 157         mpd_sendPlaylistInfoCommand(mi->connection, songpos);
 158         ent = mpd_getNextInfoEntity(mi->connection);
 159         mpd_finishCommand(mi->connection);
 160
 161         if(mpd_unlock_conn(mi))
 162         {
 163                 /*TODO free entity. for now this can never happen */
 164                 return NULL;
 165         }
 166
 167         if(ent == NULL)
 168         {
 169                 debug_printf(DEBUG_ERROR, "Failed to grab song from mpd\n");
 170                 return NULL;
 171         }
 172
 173         if(ent->type != MPD_INFO_ENTITY_TYPE_SONG)
 174         {
 175                 mpd_freeInfoEntity(ent);
 176                 debug_printf(DEBUG_ERROR, "Failed to grab corect song type from mpd\n");
 177                 return NULL;
 178         }
 179         song = ent->info.song;
 180         ent->info.song = NULL;
 181
 182         mpd_freeInfoEntity(ent);
 183
 184         return song;
 185 }
 186
 187 MpdData * mpd_playlist_get_song_from_pos_range(MpdObj *mi, int start, int stop)
 188 {
 189     MpdData *data = NULL;
 190     int i;
 191         mpd_InfoEntity *ent = NULL;
 192         if(!mpd_check_connected(mi))
 193         {
 194                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 195                 return NULL;
 196         }
 197         if(mpd_status_check(mi) != MPD_OK)
 198         {
 199                 debug_printf(DEBUG_ERROR,"Failed grabbing status\n");
 200                 return NULL;
 201         }
 202
 203         if(mpd_lock_conn(mi))
 204         {
 205                 return NULL;
 206         }
 207     /* Don't check outside playlist length */
 208     if(!(stop < mi->status->playlistLength)) {
 209         stop = mi->status->playlistLength -1;
 210     }
 211     mpd_sendCommandListBegin(mi->connection);
 212     for(i=start; i <= stop; i++){
 213         mpd_sendPlaylistInfoCommand(mi->connection, i);
 214     }
 215         mpd_sendCommandListEnd(mi->connection);
 216         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 217         {
 218                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 219                 {
 220                         data = mpd_new_data_struct_append(data);
 221                         data->type = MPD_DATA_TYPE_SONG;
 222                         data->song = ent->info.song;
 223                         ent->info.song = NULL;
 224                 }
 225                 mpd_freeInfoEntity(ent);
 226         }
 227         mpd_finishCommand(mi->connection);
 228
 229         if(mpd_unlock_conn(mi))
 230         {
 231                 /*TODO free entity. for now this can never happen */
 232                 return NULL;
 233         }
 234     return data;
 235 }
 236
 237 mpd_Song * mpd_playlist_get_current_song(MpdObj *mi)
 238 {
 239         if(!mpd_check_connected(mi))
 240         {
 241                 debug_printf(DEBUG_WARNING, "Not Connected\n");
 242                 return NULL;
 243         }
 244
 245         if(mpd_status_check(mi) != MPD_OK)
 246         {
 247                 debug_printf(DEBUG_ERROR, "Failed to check status\n");
 248                 return NULL;
 249         }
 250
 251         if(mi->CurrentSong != NULL && mi->CurrentSong->id != mi->status->songid)
 252         {
 253                 debug_printf(DEBUG_WARNING, "Current song not up2date, updating\n");
 254                 mpd_freeSong(mi->CurrentSong);
 255                 mi->CurrentSong = NULL;
 256         }
 257         /* only update song when playing/pasing */
 258         if(mi->CurrentSong == NULL &&
 259                         (mpd_player_get_state(mi) != MPD_PLAYER_STOP && mpd_player_get_state(mi) != MPD_PLAYER_UNKNOWN))
 260         {
 261                 /* TODO: this to use the geT_current_song_id function */
 262                 mi->CurrentSong = mpd_playlist_get_song(mi, mpd_player_get_current_song_id(mi));
 263                 if(mi->CurrentSong == NULL)
 264                 {
 265                         debug_printf(DEBUG_ERROR, "Failed to grab song\n");
 266                         return NULL;
 267                 }
 268         }
 269         return mi->CurrentSong;
 270 }
 271
 272 int mpd_playlist_clear(MpdObj *mi)
 273 {
 274         if(!mpd_check_connected(mi))
 275         {
 276                 debug_printf(DEBUG_WARNING,"not connected\n");
 277                 return MPD_NOT_CONNECTED;
 278         }
 279         if(mpd_lock_conn(mi))
 280         {
 281                 debug_printf(DEBUG_WARNING,"lock failed\n");
 282                 return MPD_LOCK_FAILED;
 283         }
 284
 285         mpd_sendClearCommand(mi->connection);
 286         mpd_finishCommand(mi->connection);
 287         /* hack to make it update correctly when replacing 1 song */
 288         mi->CurrentState.songid = -1;
 289         /* unlock */
 290         mpd_unlock_conn(mi);
 291         mpd_status_update(mi);
 292         return FALSE;
 293 }
 294
 295 int mpd_playlist_shuffle(MpdObj *mi)
 296 {
 297         if(!mpd_check_connected(mi))
 298         {
 299                 debug_printf(DEBUG_WARNING,"not connected\n");
 300                 return MPD_NOT_CONNECTED;
 301         }
 302         if(mpd_lock_conn(mi))
 303         {
 304                 debug_printf(DEBUG_ERROR,"lock failed\n");
 305                 return MPD_LOCK_FAILED;
 306         }
 307
 308         mpd_sendShuffleCommand(mi->connection);
 309         mpd_finishCommand(mi->connection);
 310
 311         /* unlock */
 312         mpd_unlock_conn(mi);
 313         return FALSE;
 314
 315 }
 316
 317
 318 int mpd_playlist_move_id(MpdObj *mi, int old_id, int new_id)
 319 {
 320         if(!mpd_check_connected(mi))
 321         {
 322                 debug_printf(DEBUG_WARNING,"not connected\n");
 323                 return MPD_NOT_CONNECTED;
 324         }
 325         if(mpd_lock_conn(mi))
 326         {
 327                 debug_printf(DEBUG_ERROR,"lock failed\n");
 328                 return MPD_LOCK_FAILED;
 329         }
 330
 331         mpd_sendMoveIdCommand(mi->connection,old_id, new_id);
 332         mpd_finishCommand(mi->connection);
 333
 334         /* unlock */
 335         mpd_unlock_conn(mi);
 336         return MPD_OK;
 337 }
 338
 339 int mpd_playlist_set_priority(MpdObj *mi, int song_id, int priority)
 340 {
 341     if(!mpd_check_connected(mi))
 342     {
 343         debug_printf(DEBUG_WARNING,"not connected\n");
 344         return MPD_NOT_CONNECTED;
 345     }
 346     if(mpd_server_check_command_allowed(mi, "prioid") != MPD_SERVER_COMMAND_ALLOWED)
 347     {
 348         return MPD_SERVER_NOT_SUPPORTED;
 349     }
 350     if(mpd_lock_conn(mi))
 351     {
 352         debug_printf(DEBUG_ERROR,"lock failed\n");
 353         return MPD_LOCK_FAILED;
 354     }
 355
 356     mpd_sendSetPrioId(mi->connection,priority, song_id);
 357     mpd_finishCommand(mi->connection);
 358
 359     /* unlock */
 360     mpd_unlock_conn(mi);
 361     return MPD_OK;
 362 }
 363
 364 int mpd_playlist_move_pos(MpdObj *mi, int old_pos, int new_pos)
 365 {
 366         if(!mpd_check_connected(mi))
 367         {
 368                 debug_printf(DEBUG_WARNING,"not connected\n");
 369                 return MPD_NOT_CONNECTED;
 370         }
 371         if(mpd_lock_conn(mi))
 372         {
 373                 debug_printf(DEBUG_ERROR,"lock failed\n");
 374                 return MPD_LOCK_FAILED;
 375         }
 376
 377         mpd_sendMoveCommand(mi->connection,old_pos, new_pos);
 378         mpd_finishCommand(mi->connection);
 379
 380         /* unlock */
 381         mpd_unlock_conn(mi);
 382         return MPD_OK;
 383 }
 384
 385 MpdData * mpd_playlist_get_changes(MpdObj *mi,int old_playlist_id)
 386 {
 387         MpdData *data = NULL;
 388         mpd_InfoEntity *ent = NULL;
 389         if(!mpd_check_connected(mi))
 390         {
 391                 debug_printf(DEBUG_WARNING,"not connected\n");
 392                 return NULL;
 393         }
 394         if(mpd_lock_conn(mi))
 395         {
 396                 debug_printf(DEBUG_WARNING,"lock failed\n");
 397                 return NULL;
 398         }
 399
 400         if(old_playlist_id == -1)
 401         {
 402                 debug_printf(DEBUG_INFO,"get fresh playlist\n");
 403                 mpd_sendPlChangesCommand (mi->connection, 0);
 404 /*              mpd_sendPlaylistIdCommand(mi->connection, -1); */
 405         }
 406         else
 407         {
 408                 mpd_sendPlChangesCommand (mi->connection, old_playlist_id);
 409         }
 410
 411         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 412         {
 413                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 414                 {
 415                         data = mpd_new_data_struct_append(data);
 416                         data->type = MPD_DATA_TYPE_SONG;
 417                         data->song = ent->info.song;
 418                         ent->info.song = NULL;
 419                 }
 420                 mpd_freeInfoEntity(ent);
 421         }
 422         mpd_finishCommand(mi->connection);
 423
 424         /* unlock */
 425         if(mpd_unlock_conn(mi))
 426         {
 427                 debug_printf(DEBUG_WARNING,"mpd_playlist_get_changes: unlock failed.\n");
 428                 mpd_data_free(data);
 429                 return NULL;
 430         }
 431         if(data == NULL)
 432         {
 433                 return NULL;
 434         }
 435         return mpd_data_get_first(data);
 436 }
 437
 438
 439
 440 MpdData * mpd_playlist_get_changes_posid(MpdObj *mi,int old_playlist_id)
 441 {
 442         MpdData *data = NULL;
 443         mpd_InfoEntity *ent = NULL;
 444         debug_printf(DEBUG_INFO, "Fetching using new plchangesposid command");
 445         if(!mpd_check_connected(mi))
 446         {
 447                 debug_printf(DEBUG_WARNING,"not connected\n");
 448                 return NULL;
 449         }
 450         if(mpd_lock_conn(mi))
 451         {
 452                 debug_printf(DEBUG_WARNING,"lock failed\n");
 453                 return NULL;
 454         }
 455
 456         if(old_playlist_id == -1)
 457         {
 458                 debug_printf(DEBUG_INFO,"get fresh playlist\n");
 459                 mpd_sendPlChangesPosIdCommand (mi->connection, 0);
 460 /*              mpd_sendPlaylistIdCommand(mi->connection, -1); */
 461         }
 462         else
 463         {
 464                 mpd_sendPlChangesPosIdCommand (mi->connection, old_playlist_id);
 465         }
 466
 467         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 468         {
 469                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 470                 {
 471                         data = mpd_new_data_struct_append(data);
 472                         data->type = MPD_DATA_TYPE_SONG;
 473                         data->song = ent->info.song;
 474                         ent->info.song = NULL;
 475                 }
 476                 mpd_freeInfoEntity(ent);
 477         }
 478         mpd_finishCommand(mi->connection);
 479
 480         /* unlock */
 481         if(mpd_unlock_conn(mi))
 482         {
 483                 debug_printf(DEBUG_WARNING,"mpd_playlist_get_changes: unlock failed.\n");
 484                 mpd_data_free(data);
 485                 return NULL;
 486         }
 487         if(data == NULL)
 488         {
 489                 return NULL;
 490         }
 491         return mpd_data_get_first(data);
 492 }
 493
 494 int mpd_playlist_queue_add(MpdObj *mi,const char *path)
 495 {
 496         if(!mpd_check_connected(mi))
 497         {
 498                 debug_printf(DEBUG_WARNING,"not connected\n");
 499                 return MPD_NOT_CONNECTED;
 500         }
 501         if(path == NULL)
 502         {
 503                 debug_printf(DEBUG_ERROR, "path != NULL Failed");
 504                 return MPD_ARGS_ERROR;
 505         }
 506
 507         if(mi->queue == NULL)
 508         {
 509                 mi->queue = mpd_new_queue_struct();
 510                 mi->queue->first = mi->queue;
 511                 mi->queue->next = NULL;
 512                 mi->queue->prev = NULL;
 513         }
 514         else
 515         {
 516                 mi->queue->next = mpd_new_queue_struct();
 517                 mi->queue->next->first = mi->queue->first;
 518                 mi->queue->next->prev = mi->queue;
 519                 mi->queue = mi->queue->next;
 520                 mi->queue->next = NULL;
 521         }
 522         mi->queue->type = MPD_QUEUE_ADD;
 523         mi->queue->path = strdup(path);
 524         return MPD_OK;
 525 }
 526
 527 int mpd_playlist_queue_load(MpdObj *mi,const char *path)
 528 {
 529         if(!mpd_check_connected(mi))
 530         {
 531                 debug_printf(DEBUG_WARNING,"not connected\n");
 532                 return MPD_NOT_CONNECTED;
 533         }
 534         if(path == NULL)
 535         {
 536                 debug_printf(DEBUG_ERROR, "path != NULL Failed");
 537                 return MPD_ARGS_ERROR;
 538         }
 539
 540         if(mi->queue == NULL)
 541         {
 542                 mi->queue = mpd_new_queue_struct();
 543                 mi->queue->first = mi->queue;
 544                 mi->queue->next = NULL;
 545                 mi->queue->prev = NULL;
 546         }
 547         else
 548         {
 549                 mi->queue->next = mpd_new_queue_struct();
 550                 mi->queue->next->first = mi->queue->first;
 551                 mi->queue->next->prev = mi->queue;
 552                 mi->queue = mi->queue->next;
 553                 mi->queue->next = NULL;
 554         }
 555         mi->queue->type = MPD_QUEUE_LOAD;
 556         mi->queue->path = strdup(path);
 557         return MPD_OK;
 558 }
 559
 560
 561 int mpd_playlist_queue_commit(MpdObj *mi)
 562 {
 563         if(!mpd_check_connected(mi))
 564         {
 565                 debug_printf(DEBUG_WARNING,"not connected\n");
 566                 return MPD_NOT_CONNECTED;
 567         }
 568         if(mi->queue == NULL)
 569         {
 570                 debug_printf(DEBUG_WARNING,"mi->queue is empty");
 571                 return MPD_PLAYLIST_QUEUE_EMPTY;
 572         }
 573         if(mpd_lock_conn(mi))
 574         {
 575                 debug_printf(DEBUG_WARNING,"lock failed\n");
 576                 return  MPD_LOCK_FAILED;
 577         }
 578         mpd_sendCommandListBegin(mi->connection);
 579         /* get first item */
 580         mi->queue = mi->queue->first;
 581         while(mi->queue != NULL)
 582         {
 583                 if(mi->queue->type == MPD_QUEUE_ADD)
 584                 {
 585                         if(mi->queue->path != NULL)
 586                         {
 587                                 mpd_sendAddCommand(mi->connection, mi->queue->path);
 588                         }
 589                 }
 590                 else if(mi->queue->type == MPD_QUEUE_LOAD)
 591                 {
 592                         if(mi->queue->path != NULL)
 593                         {
 594                                 mpd_sendLoadCommand(mi->connection, mi->queue->path);
 595                         }
 596                 }
 597                 else if (mi->queue->type == MPD_QUEUE_DELETE_ID)
 598                 {
 599                         if(mi->queue->id >= 0)
 600                         {
 601                                 mpd_sendDeleteIdCommand(mi->connection, mi->queue->id);
 602                         }
 603                 }
 604                 else if (mi->queue->type == MPD_QUEUE_DELETE_POS)
 605                 {
 606                         if(mi->queue->id >= 0)
 607                         {
 608                                 mpd_sendDeleteCommand(mi->connection, mi->queue->id);
 609                         }
 610                 }
 611
 612                 mpd_queue_get_next(mi);
 613         }
 614         mpd_sendCommandListEnd(mi->connection);
 615         mpd_finishCommand(mi->connection);
 616
 617
 618
 619         mpd_unlock_conn(mi);
 620         mpd_status_update(mi);
 621         return MPD_OK;
 622 }
 623 int mpd_playlist_queue_delete_id(MpdObj *mi,int id)
 624 {
 625         if(!mpd_check_connected(mi))
 626         {
 627                 debug_printf(DEBUG_WARNING,"not connected\n");
 628                 return MPD_NOT_CONNECTED;
 629         }
 630
 631         if(mi->queue == NULL)
 632         {
 633                 mi->queue = mpd_new_queue_struct();
 634                 mi->queue->first = mi->queue;
 635                 mi->queue->next = NULL;
 636                 mi->queue->prev = NULL;
 637         }
 638         else
 639         {
 640                 mi->queue->next = mpd_new_queue_struct();
 641                 mi->queue->next->first = mi->queue->first;
 642                 mi->queue->next->prev = mi->queue;
 643                 mi->queue = mi->queue->next;
 644                 mi->queue->next = NULL;
 645         }
 646         mi->queue->type = MPD_QUEUE_DELETE_ID;
 647         mi->queue->id = id;
 648         mi->queue->path = NULL;
 649         return MPD_OK;
 650 }
 651
 652 int mpd_playlist_queue_delete_pos(MpdObj *mi,int songpos)
 653 {
 654         if(!mpd_check_connected(mi))
 655         {
 656                 debug_printf(DEBUG_WARNING,"mpd_playlist_add: not connected\n");
 657                 return MPD_NOT_CONNECTED;
 658         }
 659
 660         if(mi->queue == NULL)
 661         {
 662                 mi->queue = mpd_new_queue_struct();
 663                 mi->queue->first = mi->queue;
 664                 mi->queue->next = NULL;
 665                 mi->queue->prev = NULL;
 666         }
 667         else
 668         {
 669                 mi->queue->next = mpd_new_queue_struct();
 670                 mi->queue->next->first = mi->queue->first;
 671                 mi->queue->next->prev = mi->queue;
 672                 mi->queue = mi->queue->next;
 673                 mi->queue->next = NULL;
 674         }
 675         mi->queue->type = MPD_QUEUE_DELETE_POS;
 676         mi->queue->id = songpos;
 677         mi->queue->path = NULL;
 678         return MPD_OK;
 679 }
 680
 681 int mpd_playlist_add_get_id(MpdObj *mi,const char *path)
 682 {
 683         int songid = -1;
 684         if(mi == NULL || path == NULL)
 685         {
 686                 debug_printf(DEBUG_ERROR, "mi == NULL || path == NULL failed");
 687                 return MPD_ARGS_ERROR;
 688         }
 689         if(!mpd_check_connected(mi))
 690         {
 691                 debug_printf(DEBUG_WARNING,"mpd_playlist_add: not connected\n");
 692                 return MPD_NOT_CONNECTED;
 693         }
 694         if(mpd_lock_conn(mi))
 695         {
 696                 debug_printf(DEBUG_WARNING,"lock failed\n");
 697                 return MPD_LOCK_FAILED;
 698         }
 699         songid = mpd_sendAddIdCommand(mi->connection, path);
 700         mpd_finishCommand(mi->connection);
 701
 702         mpd_unlock_conn(mi);
 703         return songid;
 704 }
 705
 706 void mpd_playlist_search_start(MpdObj *mi, int exact)
 707 {
 708         /*
 709          * Check argument
 710          */
 711         if(mi == NULL || exact > 1 || exact < 0)
 712         {
 713                 debug_printf(DEBUG_ERROR, "Argument error");
 714                 return ;
 715         }
 716         if(!mpd_check_connected(mi))
 717         {
 718                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 719                 return ;
 720         }
 721         if(!mpd_server_check_version(mi, 0,12,1))
 722         {
 723                 debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.2 or higher");
 724                 return ;
 725         }
 726         /* lock, so we can work on mi->connection */
 727         if(mpd_lock_conn(mi) != MPD_OK)
 728         {
 729                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 730                 return ;
 731         }
 732         mpd_startPlaylistSearch(mi->connection, exact);
 733         /* Set search type */
 734         mi->search_type = (exact)? MPD_SEARCH_TYPE_PLAYLIST_FIND:MPD_SEARCH_TYPE_PLAYLIST_SEARCH;
 735         /* unlock, let the error handler handle any possible error.
 736          */
 737         mpd_unlock_conn(mi);
 738         return;
 739 }
 740
 741 void mpd_playlist_search_add_constraint(MpdObj *mi, mpd_TagItems field,const char *value)
 742 {
 743         mpd_database_search_add_constraint(mi, field, value);
 744 }
 745 MpdData * mpd_playlist_search_commit(MpdObj *mi)
 746 {
 747         mpd_InfoEntity *ent = NULL;
 748         MpdData *data = NULL;
 749         if(!mpd_check_connected(mi))
 750         {
 751                 debug_printf(DEBUG_WARNING,"not connected\n");
 752                 return NULL;
 753         }
 754         if(mi->search_type < MPD_SEARCH_TYPE_PLAYLIST_FIND )
 755         {
 756                 debug_printf(DEBUG_ERROR, "no or wrong search in progress to commit");
 757                 return NULL;
 758         }
 759         if(mpd_lock_conn(mi))
 760         {
 761                 debug_printf(DEBUG_ERROR,"lock failed\n");
 762                 return NULL;
 763         }
 764         mpd_commitSearch(mi->connection);
 765         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 766         {
 767                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 768                 {
 769                         data = mpd_new_data_struct_append(data);
 770                         data->type = MPD_DATA_TYPE_SONG;
 771                         data->song = ent->info.song;
 772                         ent->info.song = NULL;
 773                 }
 774                 mpd_freeInfoEntity(ent);
 775         }
 776         mpd_finishCommand(mi->connection);
 777         /*
 778          * reset search type
 779          */
 780         mi->search_type = MPD_SEARCH_TYPE_NONE;
 781         mi->search_field = MPD_TAG_ITEM_ARTIST;
 782         /* unlock */
 783         if(mpd_unlock_conn(mi))
 784         {
 785                 debug_printf(DEBUG_ERROR, "Failed to unlock connection");
 786                 if(data)mpd_data_free(data);
 787                 return NULL;
 788         }
 789         if(data == NULL)
 790         {
 791                 return NULL;
 792         }
 793         return mpd_data_get_first(data);
 794 }
 795
 796
 797 int mpd_playlist_load(MpdObj *mi, const char *path)
 798 {
 799     int retv = MPD_OK;
 800         if(!mpd_check_connected(mi))
 801         {
 802                 debug_printf(DEBUG_WARNING,"mpd_playlist_load: not connected\n");
 803                 return MPD_NOT_CONNECTED;
 804         }
 805         if(mpd_lock_conn(mi))
 806         {
 807                 debug_printf(DEBUG_ERROR,"lock failed\n");
 808                 return MPD_LOCK_FAILED;
 809         }
 810     mpd_sendLoadCommand(mi->connection,path);
 811         mpd_finishCommand(mi->connection);
 812     if(mi->connection->errorCode == MPD_ACK_ERROR_NO_EXIST)
 813     {
 814         debug_printf(DEBUG_WARNING, "mpd_playlist_load: failed to load playlist\n");
 815                 mpd_clearError(mi->connection);
 816         retv = MPD_PLAYLIST_LOAD_FAILED;
 817     }
 818
 819         if(mpd_unlock_conn(mi))
 820         {
 821                 debug_printf(DEBUG_ERROR, "Failed to unlock connection");
 822                 return MPD_LOCK_FAILED;
 823         }
 824     return retv;
 825 }