src/libmpd-status.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 #include <assert.h>
  23 #define __USE_GNU
  24
  25 #include <string.h>
  26 #include <stdarg.h>
  27 #include <config.h>
  28 #include "debug_printf.h"
  29 #include "libmpd.h"
  30 #include "libmpd-internal.h"
  31
  32 int mpd_stats_update_real(MpdObj *mi, ChangedStatusType* what_changed);
  33
  34 int mpd_status_queue_update(MpdObj *mi)
  35 {
  36
  37         if(!mpd_check_connected(mi))
  38         {
  39                 debug_printf(DEBUG_INFO,"Where not connected\n");
  40                 return MPD_NOT_CONNECTED;
  41         }
  42         if(mi->status != NULL)
  43         {
  44                 mpd_freeStatus(mi->status);
  45                 mi->status = NULL;
  46         }
  47         return MPD_OK;
  48 }
  49
  50
  51 int mpd_status_update(MpdObj *mi)
  52 {
  53         ChangedStatusType what_changed=0;
  54         if(!mpd_check_connected(mi))
  55         {
  56                 debug_printf(DEBUG_INFO,"Where not connected\n");
  57                 return MPD_NOT_CONNECTED;
  58         }
  59         if(mpd_lock_conn(mi))
  60         {
  61                 debug_printf(DEBUG_ERROR,"lock failed\n");
  62                 return MPD_LOCK_FAILED;
  63         }
  64
  65
  66
  67         if(mi->status != NULL)
  68         {
  69                 mpd_freeStatus(mi->status);
  70                 mi->status = NULL;
  71         }
  72         mpd_sendStatusCommand(mi->connection);
  73         mi->status = mpd_getStatus(mi->connection);
  74         if(mi->status == NULL)
  75         {
  76                 debug_printf(DEBUG_ERROR,"Failed to grab status from mpd\n");
  77                 mpd_unlock_conn(mi);
  78                 return MPD_STATUS_FAILED;
  79         }
  80         if(mpd_unlock_conn(mi))
  81         {
  82                 debug_printf(DEBUG_ERROR, "Failed to unlock");
  83                 return MPD_LOCK_FAILED;
  84         }
  85         /*
  86          * check for changes
  87          */
  88         /* first save the old status */
  89         memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState));
  90
  91         /* playlist change */
  92         if(mi->CurrentState.playlistid != mi->status->playlist)
  93         {
  94                 /* print debug message */
  95                 debug_printf(DEBUG_INFO, "Playlist has changed!");
  96
  97                 /* We can't trust the current song anymore. so we remove it */
  98                 /* tags might have been updated */
  99                 if(mi->CurrentSong != NULL)
 100                 {
 101                         mpd_freeSong(mi->CurrentSong);
 102                         mi->CurrentSong = NULL;
 103                 }
 104
 105                 /* set MPD_CST_PLAYLIST to be changed */
 106                 what_changed |= MPD_CST_PLAYLIST;
 107
 108         if(mi->CurrentState.playlistLength == mi->status->playlistLength)
 109         {
 110 //            what_changed |= MPD_CST_SONGID;
 111         }
 112                 /* save new id */
 113                 mi->CurrentState.playlistid = mi->status->playlist;
 114         }
 115
 116         if(mi->CurrentState.storedplaylistid != mi->status->storedplaylist)
 117         {
 118                 /* set MPD_CST_QUEUE to be changed */
 119                 what_changed |= MPD_CST_STORED_PLAYLIST;
 120
 121
 122                 /* save new id */
 123                 mi->CurrentState.storedplaylistid = mi->status->storedplaylist;
 124         }
 125
 126
 127         /* state change */
 128         if(mi->CurrentState.state != mi->status->state)
 129         {
 130                 what_changed |= MPD_CST_STATE;
 131                 mi->CurrentState.state = mi->status->state;
 132         }
 133
 134         if(mi->CurrentState.songid != mi->status->songid)
 135         {
 136                 /* print debug message */
 137                 debug_printf(DEBUG_INFO, "Songid has changed %i %i!", mi->OldState.songid, mi->status->songid);
 138
 139                 what_changed |= MPD_CST_SONGID;
 140                 /* save new songid */
 141                 mi->CurrentState.songid = mi->status->songid;
 142
 143         }
 144         if(mi->CurrentState.songpos != mi->status->song)
 145         {
 146                 /* print debug message */
 147                 debug_printf(DEBUG_INFO, "Songpos has changed %i %i!", mi->OldState.songpos, mi->status->song);
 148
 149                 what_changed |= MPD_CST_SONGPOS;
 150                 /* save new songid */
 151                 mi->CurrentState.songpos = mi->status->song;
 152
 153         }
 154
 155         if(mi->CurrentState.repeat != mi->status->repeat)
 156         {
 157                 what_changed |= MPD_CST_REPEAT;
 158                 mi->CurrentState.repeat = mi->status->repeat;
 159         }
 160         if(mi->CurrentState.random != mi->status->random)
 161         {
 162                 what_changed |= MPD_CST_RANDOM;
 163                 mi->CurrentState.random = mi->status->random;
 164         }
 165         if(mi->CurrentState.volume != mi->status->volume)
 166         {
 167                 what_changed |= MPD_CST_VOLUME;
 168                 mi->CurrentState.volume = mi->status->volume;
 169         }
 170         if(mi->CurrentState.xfade != mi->status->crossfade)
 171         {
 172                 what_changed |= MPD_CST_CROSSFADE;
 173                 mi->CurrentState.xfade = mi->status->crossfade;
 174         }
 175         if(mi->CurrentState.totaltime != mi->status->totalTime)
 176         {
 177                 what_changed |= MPD_CST_TOTAL_TIME;
 178                 mi->CurrentState.totaltime = mi->status->totalTime;
 179         }
 180         if(mi->CurrentState.elapsedtime != mi->status->elapsedTime)
 181         {
 182                 what_changed |= MPD_CST_ELAPSED_TIME;
 183                 mi->CurrentState.elapsedtime = mi->status->elapsedTime;
 184         }
 185
 186         /* Check if bitrate changed, happens with vbr encodings. */
 187         if(mi->CurrentState.bitrate != mi->status->bitRate)
 188         {
 189                 what_changed |= MPD_CST_BITRATE;
 190                 mi->CurrentState.bitrate = mi->status->bitRate;
 191         }
 192
 193         /* The following 3 probly only happen on a song change, or is it possible in one song/stream? */
 194         /* Check if the sample rate changed */
 195         if(mi->CurrentState.samplerate != mi->status->sampleRate)
 196         {
 197                 what_changed |= MPD_CST_AUDIOFORMAT;
 198                 mi->CurrentState.samplerate = mi->status->sampleRate;
 199         }
 200
 201         /* check if the sampling depth changed */
 202         if(mi->CurrentState.bits != mi->status->bits)
 203         {
 204                 what_changed |= MPD_CST_AUDIOFORMAT;
 205                 mi->CurrentState.bits = mi->status->bits;
 206         }
 207
 208         /* Check if the amount of audio channels changed */
 209         if(mi->CurrentState.channels != mi->status->channels)
 210         {
 211                 what_changed |= MPD_CST_AUDIOFORMAT;
 212                 mi->CurrentState.channels = mi->status->channels;
 213         }
 214
 215     if(mi->status->error)
 216     {
 217         what_changed |= MPD_CST_SERVER_ERROR;
 218         strcpy(mi->CurrentState.error,mi->status->error);
 219         mpd_sendClearErrorCommand(mi->connection);
 220         mpd_finishCommand(mi->connection);
 221     }
 222     else
 223     {
 224         mi->CurrentState.error[0] ='\0';
 225     }
 226
 227         /* Check if the updating changed,
 228          * If it stopped, also update the stats for the new db-time.
 229          */
 230         if(mi->CurrentState.updatingDb != mi->status->updatingDb )
 231         {
 232                 what_changed |= MPD_CST_UPDATING;
 233                 if(!mi->status->updatingDb)
 234                 {
 235                         mpd_stats_update_real(mi, &what_changed);
 236                 }
 237                 mi->CurrentState.updatingDb = mi->status->updatingDb;
 238         }
 239
 240
 241     mi->CurrentState.playlistLength = mi->status->playlistLength;
 242
 243
 244     /* Detect changed outputs */
 245     if(!mi->has_idle)
 246     {
 247         if(mi->num_outputs >0 )
 248         {
 249             mpd_OutputEntity *output = NULL;
 250             mpd_sendOutputsCommand(mi->connection);
 251             while (( output = mpd_getNextOutput(mi->connection)) != NULL)
 252             {
 253                 if(mi->output_states[output->id] != output->enabled)
 254                 {
 255                     mi->output_states[output->id] = output->enabled;
 256                     what_changed |= MPD_CST_OUTPUT;
 257                 }
 258                 mpd_freeOutputElement(output);
 259             }
 260             mpd_finishCommand(mi->connection);
 261         }
 262         else
 263         {
 264             /* if no outputs, lets fetch them */
 265             mpd_server_update_outputs(mi);
 266             if(mi->num_outputs == 0)
 267             {
 268                 assert("No outputs defined? that cannot be\n");
 269             }
 270             what_changed |= MPD_CST_OUTPUT;
 271         }
 272     }else {
 273         char *name;
 274         mpd_sendGetEventsCommand(mi->connection);
 275         while((name = mpd_getNextEvent(mi->connection))){
 276             printf("name: %s\n", name);
 277             if(strcmp(name, "output") == 0){
 278                 what_changed |= MPD_CST_OUTPUT;
 279             }else if (strcmp(name, "stored_playlist")==0) {
 280                 what_changed |= MPD_CST_STORED_PLAYLIST;
 281
 282             }
 283             free(name);
 284        }
 285        mpd_finishCommand(mi->connection);
 286     }
 287
 288
 289         /* Run the callback */
 290         if((mi->the_status_changed_callback != NULL) && what_changed)
 291         {
 292                 mi->the_status_changed_callback( mi, what_changed, mi->the_status_changed_signal_userdata );
 293         }
 294
 295         /* We could have lost connection again during signal handling... so before we return check again if we are connected */
 296         if(!mpd_check_connected(mi))
 297         {
 298                 return MPD_NOT_CONNECTED;
 299         }
 300         return MPD_OK;
 301 }
 302
 303 /* returns TRUE when status is availible, when not availible and connected it tries to grab it */
 304 int mpd_status_check(MpdObj *mi)
 305 {
 306         if(!mpd_check_connected(mi))
 307         {
 308                 debug_printf(DEBUG_INFO,"not connected\n");
 309                 return MPD_NOT_CONNECTED;
 310         }
 311         if(mi->status == NULL)
 312         {
 313                 /* try to update */
 314                 if(mpd_status_update(mi))
 315                 {
 316                         debug_printf(DEBUG_INFO, "failed to update status\n");
 317                         return MPD_STATUS_FAILED;
 318                 }
 319         }
 320         return MPD_OK;
 321 }
 322
 323
 324 int mpd_stats_get_total_songs(MpdObj *mi)
 325 {
 326         if(mi == NULL)
 327         {
 328                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 329                 return MPD_ARGS_ERROR;
 330         }
 331         if(mpd_stats_check(mi) != MPD_OK)
 332         {
 333                 debug_printf(DEBUG_ERROR,"Failed to get status\n");
 334                 return MPD_STATUS_FAILED;
 335         }
 336         return mi->stats->numberOfSongs;
 337 }
 338
 339 int mpd_stats_get_total_artists(MpdObj *mi)
 340 {
 341         if(mi == NULL)
 342         {
 343                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 344                 return MPD_ARGS_ERROR;
 345         }
 346         if(mpd_stats_check(mi) != MPD_OK)
 347         {
 348                 debug_printf(DEBUG_ERROR,"Failed to get status\n");
 349                 return MPD_STATS_FAILED;
 350         }
 351         return mi->stats->numberOfArtists;
 352 }
 353
 354 int mpd_stats_get_total_albums(MpdObj *mi)
 355 {
 356         if(mi == NULL)
 357         {
 358                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 359                 return MPD_ARGS_ERROR;
 360         }
 361         if(mpd_stats_check(mi) != MPD_OK)
 362         {
 363                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 364                 return MPD_STATS_FAILED;
 365         }
 366         return mi->stats->numberOfAlbums;
 367 }
 368
 369
 370 int mpd_stats_get_uptime(MpdObj *mi)
 371 {
 372         if(mi == NULL)
 373         {
 374                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 375                 return MPD_ARGS_ERROR;
 376         }
 377         if(mpd_stats_check(mi) != MPD_OK)
 378         {
 379                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 380                 return MPD_STATS_FAILED;
 381         }
 382         return mi->stats->uptime;
 383 }
 384
 385 int mpd_stats_get_playtime(MpdObj *mi)
 386 {
 387         if(mi == NULL)
 388         {
 389                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 390                 return MPD_ARGS_ERROR;
 391         }
 392         if(mpd_stats_check(mi) != MPD_OK)
 393         {
 394                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 395                 return MPD_STATS_FAILED;
 396         }
 397         return mi->stats->playTime;
 398 }
 399
 400 int mpd_stats_get_db_playtime(MpdObj *mi)
 401 {
 402         if(mi == NULL)
 403         {
 404                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 405                 return MPD_ARGS_ERROR;
 406         }
 407         if(mpd_stats_check(mi) != MPD_OK)
 408         {
 409                 debug_printf(DEBUG_WARNING,"Failed to get stats\n");
 410                 return MPD_STATS_FAILED;
 411         }
 412         return mi->stats->dbPlayTime;
 413 }
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431 int mpd_status_get_volume(MpdObj *mi)
 432 {
 433         if(mi == NULL)
 434         {
 435                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 436                 return MPD_ARGS_ERROR;
 437         }
 438         if(mpd_status_check(mi) != MPD_OK)
 439         {
 440                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 441                 return MPD_STATUS_FAILED;
 442         }
 443         return mi->status->volume;
 444 }
 445
 446
 447 int mpd_status_get_bitrate(MpdObj *mi)
 448 {
 449         if(mi == NULL)
 450         {
 451                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 452                 return MPD_ARGS_ERROR;
 453         }
 454         if(mpd_status_check(mi) != MPD_OK)
 455         {
 456                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 457                 return MPD_STATUS_FAILED;
 458         }
 459         return mi->CurrentState.bitrate;
 460 }
 461
 462 int mpd_status_get_channels(MpdObj *mi)
 463 {
 464         if(mi == NULL)
 465         {
 466                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 467                 return MPD_ARGS_ERROR;
 468         }
 469         if(mpd_status_check(mi) != MPD_OK)
 470         {
 471                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 472                 return MPD_STATUS_FAILED;
 473         }
 474         return mi->CurrentState.channels;
 475 }
 476
 477 unsigned int mpd_status_get_samplerate(MpdObj *mi)
 478 {
 479         if(mi == NULL)
 480         {
 481                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 482                 return MPD_ARGS_ERROR;
 483         }
 484         if(mpd_status_check(mi) != MPD_OK)
 485         {
 486                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 487                 return MPD_STATUS_FAILED;
 488         }
 489         return mi->CurrentState.samplerate;
 490 }
 491
 492 int mpd_status_get_bits(MpdObj *mi)
 493 {
 494         if(mi == NULL)
 495         {
 496                 debug_printf(DEBUG_WARNING,"failed to check mi == NULL\n");
 497                 return MPD_ARGS_ERROR;
 498         }
 499         if(mpd_status_check(mi) != MPD_OK)
 500         {
 501                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 502                 return MPD_STATUS_FAILED;
 503         }
 504         return mi->CurrentState.bits;
 505 }
 506
 507 char * mpd_status_get_mpd_error(MpdObj *mi)
 508 {
 509     if(mi->CurrentState.error[0] != '\0')
 510     {
 511         return strdup(mi->CurrentState.error);
 512     }
 513     return NULL;
 514 }
 515
 516 /* TODO: error checking might be nice? */
 517 int mpd_status_db_is_updating(MpdObj *mi)
 518 {
 519         return mi->CurrentState.updatingDb;
 520 }
 521
 522
 523 int mpd_status_get_total_song_time(MpdObj *mi)
 524 {
 525         if(!mpd_check_connected(mi))
 526         {
 527                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 528                 return MPD_ARGS_ERROR;
 529         }
 530         if(mpd_status_check(mi) != MPD_OK)
 531         {
 532                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 533                 return MPD_STATUS_FAILED;
 534         }
 535         return mi->status->totalTime;
 536 }
 537
 538
 539 int mpd_status_get_elapsed_song_time(MpdObj *mi)
 540 {
 541         if(!mpd_check_connected(mi))
 542         {
 543                 debug_printf(DEBUG_WARNING,"failed to check mi == NULL\n");
 544                 return MPD_NOT_CONNECTED;
 545         }
 546         if(mpd_status_check(mi) != MPD_OK)
 547         {
 548                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 549                 return MPD_STATUS_FAILED;
 550         }
 551         return mi->status->elapsedTime;
 552 }
 553
 554 int mpd_status_set_volume(MpdObj *mi,int volume)
 555 {
 556         if(!mpd_check_connected(mi))
 557         {
 558                 debug_printf(DEBUG_WARNING,"not connected\n");
 559                 return MPD_NOT_CONNECTED;
 560         }
 561         /* making sure volume is between 0 and 100 */
 562         volume = (volume < 0)? 0:(volume>100)? 100:volume;
 563
 564         if(mpd_lock_conn(mi))
 565         {
 566                 debug_printf(DEBUG_ERROR,"lock failed\n");
 567                 return MPD_LOCK_FAILED;
 568         }
 569
 570         /* send the command */
 571         mpd_sendSetvolCommand(mi->connection , volume);
 572         mpd_finishCommand(mi->connection);
 573         /* check for errors */
 574
 575         mpd_unlock_conn(mi);
 576         /* update status, because we changed it */
 577         mpd_status_queue_update(mi);
 578         /* return current volume */
 579         return mpd_status_get_volume(mi);
 580 }
 581
 582 int mpd_status_get_crossfade(MpdObj *mi)
 583 {
 584         if(!mpd_check_connected(mi))
 585         {
 586                 debug_printf(DEBUG_WARNING,"not connected\n");
 587                 return MPD_NOT_CONNECTED;
 588         }
 589         if(mpd_status_check(mi) != MPD_OK)
 590         {
 591                 debug_printf(DEBUG_WARNING,"Failed grabbing status\n");
 592                 return MPD_NOT_CONNECTED;
 593         }
 594         return mi->status->crossfade;
 595 }
 596
 597 int mpd_status_set_crossfade(MpdObj *mi,int crossfade_time)
 598 {
 599         if(!mpd_check_connected(mi))
 600         {
 601                 debug_printf(DEBUG_WARNING,"not connected\n");
 602                 return MPD_NOT_CONNECTED;
 603         }
 604         if(mpd_lock_conn(mi))
 605         {
 606                 debug_printf(DEBUG_ERROR,"lock failed\n");
 607                 return MPD_LOCK_FAILED;
 608         }
 609         mpd_sendCrossfadeCommand(mi->connection, crossfade_time);
 610         mpd_finishCommand(mi->connection);
 611
 612         mpd_unlock_conn(mi);
 613         mpd_status_queue_update(mi);
 614         return MPD_OK;
 615 }
 616
 617
 618 float mpd_status_set_volume_as_float(MpdObj *mi, float fvol)
 619 {
 620         int volume = mpd_status_set_volume(mi, (int)(fvol*100.0));
 621         if(volume > -1)
 622         {
 623                 return (float)volume/100.0;
 624         }
 625         return (float)volume;
 626 }
 627
 628 int mpd_stats_update(MpdObj *mi)
 629 {
 630         return mpd_stats_update_real(mi, NULL);
 631 }
 632
 633 int mpd_stats_update_real(MpdObj *mi, ChangedStatusType* what_changed)
 634 {
 635         ChangedStatusType what_changed_here = 0;
 636         if ( what_changed == NULL ) {
 637                 /* we need to save the current state, because we're called standalone */
 638                 memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState));
 639         }
 640
 641         if(!mpd_check_connected(mi))
 642         {
 643                 debug_printf(DEBUG_INFO,"Where not connected\n");
 644                 return MPD_NOT_CONNECTED;
 645         }
 646         if(mpd_lock_conn(mi))
 647         {
 648                 debug_printf(DEBUG_ERROR,"lock failed\n");
 649                 return MPD_LOCK_FAILED;
 650         }
 651
 652         if(mi->stats != NULL)
 653         {
 654                 mpd_freeStats(mi->stats);
 655         }
 656         mpd_sendStatsCommand(mi->connection);
 657         mi->stats = mpd_getStats(mi->connection);
 658         if(mi->stats == NULL)
 659         {
 660                 debug_printf(DEBUG_ERROR,"Failed to grab stats from mpd\n");
 661         }
 662         else if(mi->stats->dbUpdateTime != mi->OldState.dbUpdateTime)
 663         {
 664                 debug_printf(DEBUG_INFO, "database updated\n");
 665                 what_changed_here |= MPD_CST_DATABASE;
 666
 667                 mi->CurrentState.dbUpdateTime = mi->stats->dbUpdateTime;
 668         }
 669
 670         if (what_changed) {
 671                 (*what_changed) |= what_changed_here;
 672         } else {
 673                 if((mi->the_status_changed_callback != NULL) & what_changed_here)
 674                 {
 675                         mi->the_status_changed_callback(mi, what_changed_here, mi->the_status_changed_signal_userdata);
 676                 }
 677         }
 678
 679         if(mpd_unlock_conn(mi))
 680         {
 681                 debug_printf(DEBUG_ERROR, "unlock failed");
 682                 return MPD_LOCK_FAILED;
 683         }
 684         return MPD_OK;
 685 }
 686
 687
 688 int mpd_stats_check(MpdObj *mi)
 689 {
 690         if(!mpd_check_connected(mi))
 691         {
 692                 debug_printf(DEBUG_WARNING,"not connected\n");
 693                 return MPD_NOT_CONNECTED;
 694         }
 695         if(mi->stats == NULL)
 696         {
 697                 /* try to update */
 698                 if(mpd_stats_update(mi))
 699                 {
 700                         debug_printf(DEBUG_ERROR,"failed to update status\n");
 701                         return MPD_STATUS_FAILED;
 702                 }
 703         }
 704         return MPD_OK;
 705 }