src/libmpd-status.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 #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,"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,"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         int update_stats = 0;
 275         mpd_sendGetEventsCommand(mi->connection);
 276         while((name = mpd_getNextEvent(mi->connection))){
 277             if(strcmp(name, "output") == 0){
 278                 what_changed |= MPD_CST_OUTPUT;
 279             }else if (strcmp(name, "database") == 0) {
 280                 if((what_changed&MPD_CST_DATABASE) == 0)
 281                 {
 282                     update_stats = 1;
 283                 }
 284                 what_changed |= MPD_CST_DATABASE;
 285             }else if (strcmp(name, "stored_playlist")==0) {
 286                 what_changed |= MPD_CST_STORED_PLAYLIST;
 287             }else if (strcmp(name, "tag") == 0) {
 288                 what_changed |= MPD_CST_PLAYLIST;
 289             }else if (strcmp (name, "sticker") == 0) {
 290                 what_changed |= MPD_CST_STICKER;
 291             }
 292             free(name);
 293        }
 294        mpd_finishCommand(mi->connection);
 295        if(update_stats) {
 296            mpd_stats_update_real(mi, &what_changed);
 297        }
 298     }
 299
 300
 301         /* Run the callback */
 302         if((mi->the_status_changed_callback != NULL) && what_changed)
 303         {
 304                 mi->the_status_changed_callback( mi, what_changed, mi->the_status_changed_signal_userdata );
 305         }
 306
 307         /* We could have lost connection again during signal handling... so before we return check again if we are connected */
 308         if(!mpd_check_connected(mi))
 309         {
 310                 return MPD_NOT_CONNECTED;
 311         }
 312         return MPD_OK;
 313 }
 314
 315 /* returns TRUE when status is availible, when not availible and connected it tries to grab it */
 316 int mpd_status_check(MpdObj *mi)
 317 {
 318         if(!mpd_check_connected(mi))
 319         {
 320                 debug_printf(DEBUG_INFO,"not connected\n");
 321                 return MPD_NOT_CONNECTED;
 322         }
 323         if(mi->status == NULL)
 324         {
 325                 /* try to update */
 326                 if(mpd_status_update(mi))
 327                 {
 328                         debug_printf(DEBUG_INFO, "failed to update status\n");
 329                         return MPD_STATUS_FAILED;
 330                 }
 331         }
 332         return MPD_OK;
 333 }
 334
 335
 336 int mpd_stats_get_total_songs(MpdObj *mi)
 337 {
 338         if(mi == NULL)
 339         {
 340                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 341                 return MPD_ARGS_ERROR;
 342         }
 343         if(mpd_stats_check(mi) != MPD_OK)
 344         {
 345                 debug_printf(DEBUG_ERROR,"Failed to get status\n");
 346                 return MPD_STATUS_FAILED;
 347         }
 348         return mi->stats->numberOfSongs;
 349 }
 350
 351 int mpd_stats_get_total_artists(MpdObj *mi)
 352 {
 353         if(mi == NULL)
 354         {
 355                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 356                 return MPD_ARGS_ERROR;
 357         }
 358         if(mpd_stats_check(mi) != MPD_OK)
 359         {
 360                 debug_printf(DEBUG_ERROR,"Failed to get status\n");
 361                 return MPD_STATS_FAILED;
 362         }
 363         return mi->stats->numberOfArtists;
 364 }
 365
 366 int mpd_stats_get_total_albums(MpdObj *mi)
 367 {
 368         if(mi == NULL)
 369         {
 370                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 371                 return MPD_ARGS_ERROR;
 372         }
 373         if(mpd_stats_check(mi) != MPD_OK)
 374         {
 375                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 376                 return MPD_STATS_FAILED;
 377         }
 378         return mi->stats->numberOfAlbums;
 379 }
 380
 381
 382 int mpd_stats_get_uptime(MpdObj *mi)
 383 {
 384         if(mi == NULL)
 385         {
 386                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 387                 return MPD_ARGS_ERROR;
 388         }
 389         if(mpd_stats_check(mi) != MPD_OK)
 390         {
 391                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 392                 return MPD_STATS_FAILED;
 393         }
 394         return mi->stats->uptime;
 395 }
 396
 397 int mpd_stats_get_playtime(MpdObj *mi)
 398 {
 399         if(mi == NULL)
 400         {
 401                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 402                 return MPD_ARGS_ERROR;
 403         }
 404         if(mpd_stats_check(mi) != MPD_OK)
 405         {
 406                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 407                 return MPD_STATS_FAILED;
 408         }
 409         return mi->stats->playTime;
 410 }
 411
 412 int mpd_stats_get_db_playtime(MpdObj *mi)
 413 {
 414         if(mi == NULL)
 415         {
 416                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 417                 return MPD_ARGS_ERROR;
 418         }
 419         if(mpd_stats_check(mi) != MPD_OK)
 420         {
 421                 debug_printf(DEBUG_WARNING,"Failed to get stats\n");
 422                 return MPD_STATS_FAILED;
 423         }
 424         return mi->stats->dbPlayTime;
 425 }
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443 int mpd_status_get_volume(MpdObj *mi)
 444 {
 445         if(mi == NULL)
 446         {
 447                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 448                 return MPD_ARGS_ERROR;
 449         }
 450         if(mpd_status_check(mi) != MPD_OK)
 451         {
 452                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 453                 return MPD_STATUS_FAILED;
 454         }
 455         return mi->status->volume;
 456 }
 457
 458
 459 int mpd_status_get_bitrate(MpdObj *mi)
 460 {
 461         if(mi == NULL)
 462         {
 463                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 464                 return MPD_ARGS_ERROR;
 465         }
 466         if(mpd_status_check(mi) != MPD_OK)
 467         {
 468                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 469                 return MPD_STATUS_FAILED;
 470         }
 471         return mi->CurrentState.bitrate;
 472 }
 473
 474 int mpd_status_get_channels(MpdObj *mi)
 475 {
 476         if(mi == NULL)
 477         {
 478                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 479                 return MPD_ARGS_ERROR;
 480         }
 481         if(mpd_status_check(mi) != MPD_OK)
 482         {
 483                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 484                 return MPD_STATUS_FAILED;
 485         }
 486         return mi->CurrentState.channels;
 487 }
 488
 489 unsigned int mpd_status_get_samplerate(MpdObj *mi)
 490 {
 491         if(mi == NULL)
 492         {
 493                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 494                 return MPD_ARGS_ERROR;
 495         }
 496         if(mpd_status_check(mi) != MPD_OK)
 497         {
 498                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 499                 return MPD_STATUS_FAILED;
 500         }
 501         return mi->CurrentState.samplerate;
 502 }
 503
 504 int mpd_status_get_bits(MpdObj *mi)
 505 {
 506         if(mi == NULL)
 507         {
 508                 debug_printf(DEBUG_WARNING,"failed to check mi == NULL\n");
 509                 return MPD_ARGS_ERROR;
 510         }
 511         if(mpd_status_check(mi) != MPD_OK)
 512         {
 513                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 514                 return MPD_STATUS_FAILED;
 515         }
 516         return mi->CurrentState.bits;
 517 }
 518
 519 char * mpd_status_get_mpd_error(MpdObj *mi)
 520 {
 521     if(mi->CurrentState.error[0] != '\0')
 522     {
 523         return strdup(mi->CurrentState.error);
 524     }
 525     return NULL;
 526 }
 527
 528 int mpd_status_db_is_updating(MpdObj *mi)
 529 {
 530         if(!mpd_check_connected(mi))
 531         {
 532                 debug_printf(DEBUG_WARNING, "mpd_check_connected failed.\n");
 533                 return FALSE;
 534         }
 535         return mi->CurrentState.updatingDb;
 536 }
 537
 538
 539 int mpd_status_get_total_song_time(MpdObj *mi)
 540 {
 541         if(!mpd_check_connected(mi))
 542         {
 543                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 544                 return MPD_ARGS_ERROR;
 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->totalTime;
 552 }
 553
 554
 555 int mpd_status_get_elapsed_song_time(MpdObj *mi)
 556 {
 557         if(!mpd_check_connected(mi))
 558         {
 559                 debug_printf(DEBUG_WARNING,"failed to check mi == NULL\n");
 560                 return MPD_NOT_CONNECTED;
 561         }
 562         if(mpd_status_check(mi) != MPD_OK)
 563         {
 564                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 565                 return MPD_STATUS_FAILED;
 566         }
 567         return mi->status->elapsedTime;
 568 }
 569
 570 int mpd_status_set_volume(MpdObj *mi,int volume)
 571 {
 572         if(!mpd_check_connected(mi))
 573         {
 574                 debug_printf(DEBUG_WARNING,"not connected\n");
 575                 return MPD_NOT_CONNECTED;
 576         }
 577         /* making sure volume is between 0 and 100 */
 578         volume = (volume < 0)? 0:(volume>100)? 100:volume;
 579
 580         if(mpd_lock_conn(mi))
 581         {
 582                 debug_printf(DEBUG_ERROR,"lock failed\n");
 583                 return MPD_LOCK_FAILED;
 584         }
 585
 586         /* send the command */
 587         mpd_sendSetvolCommand(mi->connection , volume);
 588         mpd_finishCommand(mi->connection);
 589         /* check for errors */
 590
 591         mpd_unlock_conn(mi);
 592         /* update status, because we changed it */
 593         mpd_status_queue_update(mi);
 594         /* return current volume */
 595         return mpd_status_get_volume(mi);
 596 }
 597
 598 int mpd_status_get_crossfade(MpdObj *mi)
 599 {
 600         if(!mpd_check_connected(mi))
 601         {
 602                 debug_printf(DEBUG_WARNING,"not connected\n");
 603                 return MPD_NOT_CONNECTED;
 604         }
 605         if(mpd_status_check(mi) != MPD_OK)
 606         {
 607                 debug_printf(DEBUG_WARNING,"Failed grabbing status\n");
 608                 return MPD_NOT_CONNECTED;
 609         }
 610         return mi->status->crossfade;
 611 }
 612
 613 int mpd_status_set_crossfade(MpdObj *mi,int crossfade_time)
 614 {
 615         if(!mpd_check_connected(mi))
 616         {
 617                 debug_printf(DEBUG_WARNING,"not connected\n");
 618                 return MPD_NOT_CONNECTED;
 619         }
 620         if(mpd_lock_conn(mi))
 621         {
 622                 debug_printf(DEBUG_ERROR,"lock failed\n");
 623                 return MPD_LOCK_FAILED;
 624         }
 625         mpd_sendCrossfadeCommand(mi->connection, crossfade_time);
 626         mpd_finishCommand(mi->connection);
 627
 628         mpd_unlock_conn(mi);
 629         mpd_status_queue_update(mi);
 630         return MPD_OK;
 631 }
 632
 633
 634 float mpd_status_set_volume_as_float(MpdObj *mi, float fvol)
 635 {
 636         int volume = mpd_status_set_volume(mi, (int)(fvol*100.0));
 637         if(volume > -1)
 638         {
 639                 return (float)volume/100.0;
 640         }
 641         return (float)volume;
 642 }
 643
 644 int mpd_stats_update(MpdObj *mi)
 645 {
 646         return mpd_stats_update_real(mi, NULL);
 647 }
 648
 649 int mpd_stats_update_real(MpdObj *mi, ChangedStatusType* what_changed)
 650 {
 651         ChangedStatusType what_changed_here = 0;
 652         if ( what_changed == NULL ) {
 653                 /* we need to save the current state, because we're called standalone */
 654                 memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState));
 655         }
 656
 657         if(!mpd_check_connected(mi))
 658         {
 659                 debug_printf(DEBUG_INFO,"not connected\n");
 660                 return MPD_NOT_CONNECTED;
 661         }
 662         if(mpd_lock_conn(mi))
 663         {
 664                 debug_printf(DEBUG_ERROR,"lock failed\n");
 665                 return MPD_LOCK_FAILED;
 666         }
 667
 668         if(mi->stats != NULL)
 669         {
 670                 mpd_freeStats(mi->stats);
 671         }
 672         mpd_sendStatsCommand(mi->connection);
 673         mi->stats = mpd_getStats(mi->connection);
 674         if(mi->stats == NULL)
 675         {
 676                 debug_printf(DEBUG_ERROR,"Failed to grab stats from mpd\n");
 677         }
 678         else if(mi->stats->dbUpdateTime != mi->OldState.dbUpdateTime)
 679         {
 680                 debug_printf(DEBUG_INFO, "database updated\n");
 681                 what_changed_here |= MPD_CST_DATABASE;
 682
 683                 mi->CurrentState.dbUpdateTime = mi->stats->dbUpdateTime;
 684         }
 685
 686         if (what_changed) {
 687                 (*what_changed) |= what_changed_here;
 688         } else {
 689                 if((mi->the_status_changed_callback != NULL) & what_changed_here)
 690                 {
 691                         mi->the_status_changed_callback(mi, what_changed_here, mi->the_status_changed_signal_userdata);
 692                 }
 693         }
 694
 695         if(mpd_unlock_conn(mi))
 696         {
 697                 debug_printf(DEBUG_ERROR, "unlock failed");
 698                 return MPD_LOCK_FAILED;
 699         }
 700         return MPD_OK;
 701 }
 702
 703
 704 int mpd_stats_check(MpdObj *mi)
 705 {
 706         if(!mpd_check_connected(mi))
 707         {
 708                 debug_printf(DEBUG_WARNING,"not connected\n");
 709                 return MPD_NOT_CONNECTED;
 710         }
 711         if(mi->stats == NULL)
 712         {
 713                 /* try to update */
 714                 if(mpd_stats_update(mi))
 715                 {
 716                         debug_printf(DEBUG_ERROR,"failed to update status\n");
 717                         return MPD_STATUS_FAILED;
 718                 }
 719         }
 720         return MPD_OK;
 721 }