src/libmpd-playlist.c

   1 /*
   2  *Copyright (C) 2004-2007 Qball Cow <Qball@qballcow.nl>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, 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, 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 mpd_Song * mpd_playlist_get_current_song(MpdObj *mi)
 188 {
 189         if(!mpd_check_connected(mi))
 190         {
 191                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 192                 return NULL;
 193         }
 194
 195         if(mpd_status_check(mi) != MPD_OK)
 196         {
 197                 debug_printf(DEBUG_ERROR, "Failed to check status\n");
 198                 return NULL;
 199         }
 200
 201         if(mi->CurrentSong != NULL && mi->CurrentSong->id != mi->status->songid)
 202         {
 203                 debug_printf(DEBUG_WARNING, "Current song not up2date, updating\n");
 204                 mpd_freeSong(mi->CurrentSong);
 205                 mi->CurrentSong = NULL;
 206         }
 207         /* only update song when playing/pasing */
 208         if(mi->CurrentSong == NULL &&
 209                         (mpd_player_get_state(mi) != MPD_PLAYER_STOP && mpd_player_get_state(mi) != MPD_PLAYER_UNKNOWN))
 210         {
 211                 /* TODO: this to use the geT_current_song_id function */
 212                 mi->CurrentSong = mpd_playlist_get_song(mi, mpd_player_get_current_song_id(mi));
 213                 if(mi->CurrentSong == NULL)
 214                 {
 215                         debug_printf(DEBUG_ERROR, "Failed to grab song\n");
 216                         return NULL;
 217                 }
 218         }
 219         return mi->CurrentSong;
 220 }
 221
 222 int mpd_playlist_clear(MpdObj *mi)
 223 {
 224         if(!mpd_check_connected(mi))
 225         {
 226                 debug_printf(DEBUG_WARNING,"not connected\n");
 227                 return MPD_NOT_CONNECTED;
 228         }
 229         if(mpd_lock_conn(mi))
 230         {
 231                 debug_printf(DEBUG_WARNING,"lock failed\n");
 232                 return MPD_LOCK_FAILED;
 233         }
 234
 235         mpd_sendClearCommand(mi->connection);
 236         mpd_finishCommand(mi->connection);
 237         /* hack to make it update correctly when replacing 1 song */
 238         mi->CurrentState.songid = -1;
 239         /* unlock */
 240         mpd_unlock_conn(mi);
 241         mpd_status_update(mi);
 242         return FALSE;
 243 }
 244
 245 int mpd_playlist_shuffle(MpdObj *mi)
 246 {
 247         if(!mpd_check_connected(mi))
 248         {
 249                 debug_printf(DEBUG_WARNING,"not connected\n");
 250                 return MPD_NOT_CONNECTED;
 251         }
 252         if(mpd_lock_conn(mi))
 253         {
 254                 debug_printf(DEBUG_ERROR,"lock failed\n");
 255                 return MPD_LOCK_FAILED;
 256         }
 257
 258         mpd_sendShuffleCommand(mi->connection);
 259         mpd_finishCommand(mi->connection);
 260
 261         /* unlock */
 262         mpd_unlock_conn(mi);
 263         return FALSE;
 264
 265 }
 266
 267
 268 int mpd_playlist_move_id(MpdObj *mi, int old_id, int new_id)
 269 {
 270         if(!mpd_check_connected(mi))
 271         {
 272                 debug_printf(DEBUG_WARNING,"not connected\n");
 273                 return MPD_NOT_CONNECTED;
 274         }
 275         if(mpd_lock_conn(mi))
 276         {
 277                 debug_printf(DEBUG_ERROR,"lock failed\n");
 278                 return MPD_LOCK_FAILED;
 279         }
 280
 281         mpd_sendMoveIdCommand(mi->connection,old_id, new_id);
 282         mpd_finishCommand(mi->connection);
 283
 284         /* unlock */
 285         mpd_unlock_conn(mi);
 286         return MPD_OK;
 287 }
 288
 289 int mpd_playlist_move_pos(MpdObj *mi, int old_pos, int new_pos)
 290 {
 291         if(!mpd_check_connected(mi))
 292         {
 293                 debug_printf(DEBUG_WARNING,"not connected\n");
 294                 return MPD_NOT_CONNECTED;
 295         }
 296         if(mpd_lock_conn(mi))
 297         {
 298                 debug_printf(DEBUG_ERROR,"lock failed\n");
 299                 return MPD_LOCK_FAILED;
 300         }
 301
 302         mpd_sendMoveCommand(mi->connection,old_pos, new_pos);
 303         mpd_finishCommand(mi->connection);
 304
 305         /* unlock */
 306         mpd_unlock_conn(mi);
 307         return MPD_OK;
 308 }
 309
 310 MpdData * mpd_playlist_get_changes(MpdObj *mi,int old_playlist_id)
 311 {
 312         MpdData *data = NULL;
 313         mpd_InfoEntity *ent = NULL;
 314         if(!mpd_check_connected(mi))
 315         {
 316                 debug_printf(DEBUG_WARNING,"not connected\n");
 317                 return NULL;
 318         }
 319         if(mpd_lock_conn(mi))
 320         {
 321                 debug_printf(DEBUG_WARNING,"lock failed\n");
 322                 return NULL;
 323         }
 324
 325         if(old_playlist_id == -1)
 326         {
 327                 debug_printf(DEBUG_INFO,"get fresh playlist\n");
 328                 mpd_sendPlChangesCommand (mi->connection, 0);
 329 /*              mpd_sendPlaylistIdCommand(mi->connection, -1); */
 330         }
 331         else
 332         {
 333                 mpd_sendPlChangesCommand (mi->connection, old_playlist_id);
 334         }
 335
 336         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 337         {
 338                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 339                 {
 340                         data = mpd_new_data_struct_append(data);
 341                         data->type = MPD_DATA_TYPE_SONG;
 342                         data->song = ent->info.song;
 343                         ent->info.song = NULL;
 344                 }
 345                 mpd_freeInfoEntity(ent);
 346         }
 347         mpd_finishCommand(mi->connection);
 348
 349         /* unlock */
 350         if(mpd_unlock_conn(mi))
 351         {
 352                 debug_printf(DEBUG_WARNING,"mpd_playlist_get_changes: unlock failed.\n");
 353                 mpd_data_free(data);
 354                 return NULL;
 355         }
 356         if(data == NULL)
 357         {
 358                 return NULL;
 359         }
 360         return mpd_data_get_first(data);
 361 }
 362
 363
 364
 365 MpdData * mpd_playlist_get_changes_posid(MpdObj *mi,int old_playlist_id)
 366 {
 367         MpdData *data = NULL;
 368         mpd_InfoEntity *ent = NULL;
 369         debug_printf(DEBUG_INFO, "Fetching using new plchangesposid command");
 370         if(!mpd_check_connected(mi))
 371         {
 372                 debug_printf(DEBUG_WARNING,"not connected\n");
 373                 return NULL;
 374         }
 375         if(mpd_lock_conn(mi))
 376         {
 377                 debug_printf(DEBUG_WARNING,"lock failed\n");
 378                 return NULL;
 379         }
 380
 381         if(old_playlist_id == -1)
 382         {
 383                 debug_printf(DEBUG_INFO,"get fresh playlist\n");
 384                 mpd_sendPlChangesPosIdCommand (mi->connection, 0);
 385 /*              mpd_sendPlaylistIdCommand(mi->connection, -1); */
 386         }
 387         else
 388         {
 389                 mpd_sendPlChangesPosIdCommand (mi->connection, old_playlist_id);
 390         }
 391
 392         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 393         {
 394                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 395                 {
 396                         data = mpd_new_data_struct_append(data);
 397                         data->type = MPD_DATA_TYPE_SONG;
 398                         data->song = ent->info.song;
 399                         ent->info.song = NULL;
 400                 }
 401                 mpd_freeInfoEntity(ent);
 402         }
 403         mpd_finishCommand(mi->connection);
 404
 405         /* unlock */
 406         if(mpd_unlock_conn(mi))
 407         {
 408                 debug_printf(DEBUG_WARNING,"mpd_playlist_get_changes: unlock failed.\n");
 409                 mpd_data_free(data);
 410                 return NULL;
 411         }
 412         if(data == NULL)
 413         {
 414                 return NULL;
 415         }
 416         return mpd_data_get_first(data);
 417 }
 418
 419 int mpd_playlist_queue_add(MpdObj *mi,char *path)
 420 {
 421         if(!mpd_check_connected(mi))
 422         {
 423                 debug_printf(DEBUG_WARNING,"not connected\n");
 424                 return MPD_NOT_CONNECTED;
 425         }
 426         if(path == NULL)
 427         {
 428                 debug_printf(DEBUG_ERROR, "path != NULL Failed");
 429                 return MPD_ARGS_ERROR;
 430         }
 431
 432         if(mi->queue == NULL)
 433         {
 434                 mi->queue = mpd_new_queue_struct();
 435                 mi->queue->first = mi->queue;
 436                 mi->queue->next = NULL;
 437                 mi->queue->prev = NULL;
 438         }
 439         else
 440         {
 441                 mi->queue->next = mpd_new_queue_struct();
 442                 mi->queue->next->first = mi->queue->first;
 443                 mi->queue->next->prev = mi->queue;
 444                 mi->queue = mi->queue->next;
 445                 mi->queue->next = NULL;
 446         }
 447         mi->queue->type = MPD_QUEUE_ADD;
 448         mi->queue->path = strdup(path);
 449         return MPD_OK;
 450 }
 451
 452 int mpd_playlist_queue_load(MpdObj *mi,char *path)
 453 {
 454         if(!mpd_check_connected(mi))
 455         {
 456                 debug_printf(DEBUG_WARNING,"not connected\n");
 457                 return MPD_NOT_CONNECTED;
 458         }
 459         if(path == NULL)
 460         {
 461                 debug_printf(DEBUG_ERROR, "path != NULL Failed");
 462                 return MPD_ARGS_ERROR;
 463         }
 464
 465         if(mi->queue == NULL)
 466         {
 467                 mi->queue = mpd_new_queue_struct();
 468                 mi->queue->first = mi->queue;
 469                 mi->queue->next = NULL;
 470                 mi->queue->prev = NULL;
 471         }
 472         else
 473         {
 474                 mi->queue->next = mpd_new_queue_struct();
 475                 mi->queue->next->first = mi->queue->first;
 476                 mi->queue->next->prev = mi->queue;
 477                 mi->queue = mi->queue->next;
 478                 mi->queue->next = NULL;
 479         }
 480         mi->queue->type = MPD_QUEUE_LOAD;
 481         mi->queue->path = strdup(path);
 482         return MPD_OK;
 483 }
 484
 485
 486 int mpd_playlist_queue_commit(MpdObj *mi)
 487 {
 488         if(mi->queue == NULL)
 489         {
 490                 debug_printf(DEBUG_WARNING,"mi->queue is empty");
 491                 return MPD_PLAYLIST_QUEUE_EMPTY;
 492         }
 493         if(!mpd_check_connected(mi))
 494         {
 495                 debug_printf(DEBUG_WARNING,"not connected\n");
 496                 return MPD_NOT_CONNECTED;
 497         }
 498         if(mpd_lock_conn(mi))
 499         {
 500                 debug_printf(DEBUG_WARNING,"lock failed\n");
 501                 return  MPD_LOCK_FAILED;
 502         }
 503         mpd_sendCommandListBegin(mi->connection);
 504         /* get first item */
 505         mi->queue = mi->queue->first;
 506         while(mi->queue != NULL)
 507         {
 508                 if(mi->queue->type == MPD_QUEUE_ADD)
 509                 {
 510                         if(mi->queue->path != NULL)
 511                         {
 512                                 mpd_sendAddCommand(mi->connection, mi->queue->path);
 513                         }
 514                 }
 515                 else if(mi->queue->type == MPD_QUEUE_LOAD)
 516                 {
 517                         if(mi->queue->path != NULL)
 518                         {
 519                                 mpd_sendLoadCommand(mi->connection, mi->queue->path);
 520                         }
 521                 }
 522                 else if (mi->queue->type == MPD_QUEUE_DELETE_ID)
 523                 {
 524                         if(mi->queue->id >= 0)
 525                         {
 526                                 mpd_sendDeleteIdCommand(mi->connection, mi->queue->id);
 527                         }
 528                 }
 529                 else if (mi->queue->type == MPD_QUEUE_DELETE_POS)
 530                 {
 531                         if(mi->queue->id >= 0)
 532                         {
 533                                 mpd_sendDeleteCommand(mi->connection, mi->queue->id);
 534                         }
 535                 }
 536
 537                 mpd_queue_get_next(mi);
 538         }
 539         mpd_sendCommandListEnd(mi->connection);
 540         mpd_finishCommand(mi->connection);
 541         mpd_unlock_conn(mi);
 542         mpd_status_update(mi);
 543         return MPD_OK;
 544 }
 545 int mpd_playlist_queue_delete_id(MpdObj *mi,int id)
 546 {
 547         if(!mpd_check_connected(mi))
 548         {
 549                 debug_printf(DEBUG_WARNING,"not connected\n");
 550                 return MPD_NOT_CONNECTED;
 551         }
 552
 553         if(mi->queue == NULL)
 554         {
 555                 mi->queue = mpd_new_queue_struct();
 556                 mi->queue->first = mi->queue;
 557                 mi->queue->next = NULL;
 558                 mi->queue->prev = NULL;
 559         }
 560         else
 561         {
 562                 mi->queue->next = mpd_new_queue_struct();
 563                 mi->queue->next->first = mi->queue->first;
 564                 mi->queue->next->prev = mi->queue;
 565                 mi->queue = mi->queue->next;
 566                 mi->queue->next = NULL;
 567         }
 568         mi->queue->type = MPD_QUEUE_DELETE_ID;
 569         mi->queue->id = id;
 570         mi->queue->path = NULL;
 571         return MPD_OK;
 572 }
 573
 574 int mpd_playlist_queue_delete_pos(MpdObj *mi,int songpos)
 575 {
 576         if(!mpd_check_connected(mi))
 577         {
 578                 debug_printf(DEBUG_WARNING,"mpd_playlist_add: not connected\n");
 579                 return MPD_NOT_CONNECTED;
 580         }
 581
 582         if(mi->queue == NULL)
 583         {
 584                 mi->queue = mpd_new_queue_struct();
 585                 mi->queue->first = mi->queue;
 586                 mi->queue->next = NULL;
 587                 mi->queue->prev = NULL;
 588         }
 589         else
 590         {
 591                 mi->queue->next = mpd_new_queue_struct();
 592                 mi->queue->next->first = mi->queue->first;
 593                 mi->queue->next->prev = mi->queue;
 594                 mi->queue = mi->queue->next;
 595                 mi->queue->next = NULL;
 596         }
 597         mi->queue->type = MPD_QUEUE_DELETE_POS;
 598         mi->queue->id = songpos;
 599         mi->queue->path = NULL;
 600         return MPD_OK;
 601 }
 602
 603 int mpd_playlist_add_get_id(MpdObj *mi, char *path)
 604 {
 605         int songid = -1;
 606         if(mi == NULL || path == NULL)
 607         {
 608                 debug_printf(DEBUG_ERROR, "mi == NULL || path == NULL failed");
 609                 return MPD_ARGS_ERROR;
 610         }
 611         if(!mpd_check_connected(mi))
 612         {
 613                 debug_printf(DEBUG_WARNING,"mpd_playlist_add: not connected\n");
 614                 return MPD_NOT_CONNECTED;
 615         }
 616         if(mpd_lock_conn(mi))
 617         {
 618                 debug_printf(DEBUG_WARNING,"lock failed\n");
 619                 return MPD_LOCK_FAILED;
 620         }
 621         songid = mpd_sendAddIdCommand(mi->connection, path);
 622         mpd_finishCommand(mi->connection);
 623
 624         mpd_unlock_conn(mi);
 625         return songid;
 626 }
 627
 628 void mpd_playlist_search_start(MpdObj *mi, int exact)
 629 {
 630         /*
 631          * Check argument
 632          */
 633         if(mi == NULL || exact > 1 || exact < 0)
 634         {
 635                 debug_printf(DEBUG_ERROR, "Argument error");
 636                 return ;
 637         }
 638         if(!mpd_check_connected(mi))
 639         {
 640                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 641                 return ;
 642         }
 643         if(!mpd_server_check_version(mi, 0,12,1))
 644         {
 645                 debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.2 or higher");
 646                 return ;
 647         }
 648         /* lock, so we can work on mi->connection */
 649         if(mpd_lock_conn(mi) != MPD_OK)
 650         {
 651                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 652                 return ;
 653         }
 654         mpd_startPlaylistSearch(mi->connection, exact);
 655         /* Set search type */
 656         mi->search_type = (exact)? MPD_SEARCH_TYPE_PLAYLIST_FIND:MPD_SEARCH_TYPE_PLAYLIST_SEARCH;
 657         /* unlock, let the error handler handle any possible error.
 658          */
 659         mpd_unlock_conn(mi);
 660         return;
 661 }
 662
 663 void mpd_playlist_search_add_constraint(MpdObj *mi, mpd_TagItems field,const char *value)
 664 {
 665         mpd_database_search_add_constraint(mi, field, value);
 666 }
 667 MpdData * mpd_playlist_search_commit(MpdObj *mi)
 668 {
 669         mpd_InfoEntity *ent = NULL;
 670         MpdData *data = NULL;
 671         if(!mpd_check_connected(mi))
 672         {
 673                 debug_printf(DEBUG_WARNING,"not connected\n");
 674                 return NULL;
 675         }
 676         if(mi->search_type < MPD_SEARCH_TYPE_PLAYLIST_FIND )
 677         {
 678                 debug_printf(DEBUG_ERROR, "no or wrong search in progress to commit");
 679                 return NULL;
 680         }
 681         if(mpd_lock_conn(mi))
 682         {
 683                 debug_printf(DEBUG_ERROR,"lock failed\n");
 684                 return NULL;
 685         }
 686         mpd_commitSearch(mi->connection);
 687         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 688         {
 689                 if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 690                 {
 691                         data = mpd_new_data_struct_append(data);
 692                         data->type = MPD_DATA_TYPE_SONG;
 693                         data->song = ent->info.song;
 694                         ent->info.song = NULL;
 695                 }
 696                 mpd_freeInfoEntity(ent);
 697         }
 698         mpd_finishCommand(mi->connection);
 699         /*
 700          * reset search type
 701          */
 702         mi->search_type = MPD_SEARCH_TYPE_NONE;
 703         mi->search_field = MPD_TAG_ITEM_ARTIST;
 704         /* unlock */
 705         if(mpd_unlock_conn(mi))
 706         {
 707                 debug_printf(DEBUG_ERROR, "Failed to unlock connection");
 708                 if(data)mpd_data_free(data);
 709                 return NULL;
 710         }
 711         if(data == NULL)
 712         {
 713                 return NULL;
 714         }
 715         return mpd_data_get_first(data);
 716 }
 717