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     if(mi->CurrentState.nextsongid != mi->status->nextsongid || mi->CurrentState.nextsongpos != mi->status->nextsong)
 155     {
 156                 what_changed |= MPD_CST_NEXTSONG;
 157                 /* save new songid */
 158                 mi->CurrentState.nextsongpos = mi->status->nextsong;
 159         mi->CurrentState.nextsongid = mi->status->nextsongid;
 160     }
 161
 162         if(mi->CurrentState.repeat != mi->status->repeat)
 163         {
 164                 what_changed |= MPD_CST_REPEAT;
 165                 mi->CurrentState.repeat = mi->status->repeat;
 166         }
 167         if(mi->CurrentState.random != mi->status->random)
 168         {
 169                 what_changed |= MPD_CST_RANDOM;
 170                 mi->CurrentState.random = mi->status->random;
 171         }
 172         if(mi->CurrentState.volume != mi->status->volume)
 173         {
 174                 what_changed |= MPD_CST_VOLUME;
 175                 mi->CurrentState.volume = mi->status->volume;
 176         }
 177         if(mi->CurrentState.xfade != mi->status->crossfade)
 178         {
 179                 what_changed |= MPD_CST_CROSSFADE;
 180                 mi->CurrentState.xfade = mi->status->crossfade;
 181         }
 182         if(mi->CurrentState.totaltime != mi->status->totalTime)
 183         {
 184                 what_changed |= MPD_CST_TOTAL_TIME;
 185                 mi->CurrentState.totaltime = mi->status->totalTime;
 186         }
 187         if(mi->CurrentState.elapsedtime != mi->status->elapsedTime)
 188         {
 189                 what_changed |= MPD_CST_ELAPSED_TIME;
 190                 mi->CurrentState.elapsedtime = mi->status->elapsedTime;
 191         }
 192
 193         /* Check if bitrate changed, happens with vbr encodings. */
 194         if(mi->CurrentState.bitrate != mi->status->bitRate)
 195         {
 196                 what_changed |= MPD_CST_BITRATE;
 197                 mi->CurrentState.bitrate = mi->status->bitRate;
 198         }
 199
 200         /* The following 3 probly only happen on a song change, or is it possible in one song/stream? */
 201         /* Check if the sample rate changed */
 202         if(mi->CurrentState.samplerate != mi->status->sampleRate)
 203         {
 204                 what_changed |= MPD_CST_AUDIOFORMAT;
 205                 mi->CurrentState.samplerate = mi->status->sampleRate;
 206         }
 207
 208         /* check if the sampling depth changed */
 209         if(mi->CurrentState.bits != mi->status->bits)
 210         {
 211                 what_changed |= MPD_CST_AUDIOFORMAT;
 212                 mi->CurrentState.bits = mi->status->bits;
 213         }
 214
 215         /* Check if the amount of audio channels changed */
 216         if(mi->CurrentState.channels != mi->status->channels)
 217         {
 218                 what_changed |= MPD_CST_AUDIOFORMAT;
 219                 mi->CurrentState.channels = mi->status->channels;
 220         }
 221
 222     if(mi->status->error)
 223     {
 224         what_changed |= MPD_CST_SERVER_ERROR;
 225         strcpy(mi->CurrentState.error,mi->status->error);
 226         mpd_sendClearErrorCommand(mi->connection);
 227         mpd_finishCommand(mi->connection);
 228     }
 229     else
 230     {
 231         mi->CurrentState.error[0] ='\0';
 232     }
 233
 234         /* Check if the updating changed,
 235          * If it stopped, also update the stats for the new db-time.
 236          */
 237         if(mi->CurrentState.updatingDb != mi->status->updatingDb )
 238         {
 239                 what_changed |= MPD_CST_UPDATING;
 240                 if(!mi->status->updatingDb)
 241                 {
 242                         mpd_stats_update_real(mi, &what_changed);
 243                 }
 244                 mi->CurrentState.updatingDb = mi->status->updatingDb;
 245         }
 246
 247
 248     mi->CurrentState.playlistLength = mi->status->playlistLength;
 249
 250
 251     /* Detect changed outputs */
 252     if(!mi->has_idle)
 253     {
 254         if(mi->num_outputs >0 )
 255         {
 256             mpd_OutputEntity *output = NULL;
 257             mpd_sendOutputsCommand(mi->connection);
 258             while (( output = mpd_getNextOutput(mi->connection)) != NULL)
 259             {
 260                 if(mi->output_states[output->id] != output->enabled)
 261                 {
 262                     mi->output_states[output->id] = output->enabled;
 263                     what_changed |= MPD_CST_OUTPUT;
 264                 }
 265                 mpd_freeOutputElement(output);
 266             }
 267             mpd_finishCommand(mi->connection);
 268         }
 269         else
 270         {
 271             /* if no outputs, lets fetch them */
 272             mpd_server_update_outputs(mi);
 273             if(mi->num_outputs == 0)
 274             {
 275                 assert("No outputs defined? that cannot be\n");
 276             }
 277             what_changed |= MPD_CST_OUTPUT;
 278         }
 279     }else {
 280         char *name;
 281         int update_stats = 0;
 282         mpd_sendGetEventsCommand(mi->connection);
 283         while((name = mpd_getNextEvent(mi->connection))){
 284             if(strcmp(name, "output") == 0){
 285                 what_changed |= MPD_CST_OUTPUT;
 286             }else if (strcmp(name, "database") == 0) {
 287                 if((what_changed&MPD_CST_DATABASE) == 0)
 288                 {
 289                     update_stats = 1;
 290                 }
 291                 what_changed |= MPD_CST_DATABASE;
 292             }else if (strcmp(name, "stored_playlist")==0) {
 293                 what_changed |= MPD_CST_STORED_PLAYLIST;
 294             }else if (strcmp(name, "tag") == 0) {
 295                 what_changed |= MPD_CST_PLAYLIST;
 296             }else if (strcmp (name, "sticker") == 0) {
 297                 what_changed |= MPD_CST_STICKER;
 298             }
 299             free(name);
 300        }
 301        mpd_finishCommand(mi->connection);
 302        if(update_stats) {
 303            mpd_stats_update_real(mi, &what_changed);
 304        }
 305     }
 306
 307
 308         /* Run the callback */
 309         if((mi->the_status_changed_callback != NULL) && what_changed)
 310         {
 311                 mi->the_status_changed_callback( mi, what_changed, mi->the_status_changed_signal_userdata );
 312         }
 313
 314         /* We could have lost connection again during signal handling... so before we return check again if we are connected */
 315         if(!mpd_check_connected(mi))
 316         {
 317                 return MPD_NOT_CONNECTED;
 318         }
 319         return MPD_OK;
 320 }
 321
 322 /* returns TRUE when status is availible, when not availible and connected it tries to grab it */
 323 int mpd_status_check(MpdObj *mi)
 324 {
 325         if(!mpd_check_connected(mi))
 326         {
 327                 debug_printf(DEBUG_INFO,"not connected\n");
 328                 return MPD_NOT_CONNECTED;
 329         }
 330         if(mi->status == NULL)
 331         {
 332                 /* try to update */
 333                 if(mpd_status_update(mi))
 334                 {
 335                         debug_printf(DEBUG_INFO, "failed to update status\n");
 336                         return MPD_STATUS_FAILED;
 337                 }
 338         }
 339         return MPD_OK;
 340 }
 341
 342
 343 int mpd_stats_get_total_songs(MpdObj *mi)
 344 {
 345         if(mi == NULL)
 346         {
 347                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 348                 return MPD_ARGS_ERROR;
 349         }
 350         if(mpd_stats_check(mi) != MPD_OK)
 351         {
 352                 debug_printf(DEBUG_ERROR,"Failed to get status\n");
 353                 return MPD_STATUS_FAILED;
 354         }
 355         return mi->stats->numberOfSongs;
 356 }
 357
 358 int mpd_stats_get_total_artists(MpdObj *mi)
 359 {
 360         if(mi == NULL)
 361         {
 362                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 363                 return MPD_ARGS_ERROR;
 364         }
 365         if(mpd_stats_check(mi) != MPD_OK)
 366         {
 367                 debug_printf(DEBUG_ERROR,"Failed to get status\n");
 368                 return MPD_STATS_FAILED;
 369         }
 370         return mi->stats->numberOfArtists;
 371 }
 372
 373 int mpd_stats_get_total_albums(MpdObj *mi)
 374 {
 375         if(mi == NULL)
 376         {
 377                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 378                 return MPD_ARGS_ERROR;
 379         }
 380         if(mpd_stats_check(mi) != MPD_OK)
 381         {
 382                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 383                 return MPD_STATS_FAILED;
 384         }
 385         return mi->stats->numberOfAlbums;
 386 }
 387
 388
 389 int mpd_stats_get_uptime(MpdObj *mi)
 390 {
 391         if(mi == NULL)
 392         {
 393                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 394                 return MPD_ARGS_ERROR;
 395         }
 396         if(mpd_stats_check(mi) != MPD_OK)
 397         {
 398                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 399                 return MPD_STATS_FAILED;
 400         }
 401         return mi->stats->uptime;
 402 }
 403
 404 int mpd_stats_get_playtime(MpdObj *mi)
 405 {
 406         if(mi == NULL)
 407         {
 408                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 409                 return MPD_ARGS_ERROR;
 410         }
 411         if(mpd_stats_check(mi) != MPD_OK)
 412         {
 413                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 414                 return MPD_STATS_FAILED;
 415         }
 416         return mi->stats->playTime;
 417 }
 418
 419 int mpd_stats_get_db_playtime(MpdObj *mi)
 420 {
 421         if(mi == NULL)
 422         {
 423                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 424                 return MPD_ARGS_ERROR;
 425         }
 426         if(mpd_stats_check(mi) != MPD_OK)
 427         {
 428                 debug_printf(DEBUG_WARNING,"Failed to get stats\n");
 429                 return MPD_STATS_FAILED;
 430         }
 431         return mi->stats->dbPlayTime;
 432 }
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450 int mpd_status_get_volume(MpdObj *mi)
 451 {
 452         if(mi == NULL)
 453         {
 454                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 455                 return MPD_ARGS_ERROR;
 456         }
 457         if(mpd_status_check(mi) != MPD_OK)
 458         {
 459                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 460                 return MPD_STATUS_FAILED;
 461         }
 462         return mi->status->volume;
 463 }
 464
 465
 466 int mpd_status_get_bitrate(MpdObj *mi)
 467 {
 468         if(mi == NULL)
 469         {
 470                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 471                 return MPD_ARGS_ERROR;
 472         }
 473         if(mpd_status_check(mi) != MPD_OK)
 474         {
 475                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 476                 return MPD_STATUS_FAILED;
 477         }
 478         return mi->CurrentState.bitrate;
 479 }
 480
 481 int mpd_status_get_channels(MpdObj *mi)
 482 {
 483         if(mi == NULL)
 484         {
 485                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 486                 return MPD_ARGS_ERROR;
 487         }
 488         if(mpd_status_check(mi) != MPD_OK)
 489         {
 490                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 491                 return MPD_STATUS_FAILED;
 492         }
 493         return mi->CurrentState.channels;
 494 }
 495
 496 unsigned int mpd_status_get_samplerate(MpdObj *mi)
 497 {
 498         if(mi == NULL)
 499         {
 500                 debug_printf(DEBUG_ERROR,"failed to check mi == NULL\n");
 501                 return MPD_ARGS_ERROR;
 502         }
 503         if(mpd_status_check(mi) != MPD_OK)
 504         {
 505                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 506                 return MPD_STATUS_FAILED;
 507         }
 508         return mi->CurrentState.samplerate;
 509 }
 510
 511 int mpd_status_get_bits(MpdObj *mi)
 512 {
 513         if(mi == NULL)
 514         {
 515                 debug_printf(DEBUG_WARNING,"failed to check mi == NULL\n");
 516                 return MPD_ARGS_ERROR;
 517         }
 518         if(mpd_status_check(mi) != MPD_OK)
 519         {
 520                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 521                 return MPD_STATUS_FAILED;
 522         }
 523         return mi->CurrentState.bits;
 524 }
 525
 526 char * mpd_status_get_mpd_error(MpdObj *mi)
 527 {
 528     if(mi->CurrentState.error[0] != '\0')
 529     {
 530         return strdup(mi->CurrentState.error);
 531     }
 532     return NULL;
 533 }
 534
 535 int mpd_status_db_is_updating(MpdObj *mi)
 536 {
 537         if(!mpd_check_connected(mi))
 538         {
 539                 debug_printf(DEBUG_WARNING, "mpd_check_connected failed.\n");
 540                 return FALSE;
 541         }
 542         return mi->CurrentState.updatingDb;
 543 }
 544
 545
 546 int mpd_status_get_total_song_time(MpdObj *mi)
 547 {
 548         if(!mpd_check_connected(mi))
 549         {
 550                 debug_printf(DEBUG_ERROR, "failed to check mi == NULL\n");
 551                 return MPD_ARGS_ERROR;
 552         }
 553         if(mpd_status_check(mi) != MPD_OK)
 554         {
 555                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 556                 return MPD_STATUS_FAILED;
 557         }
 558         return mi->status->totalTime;
 559 }
 560
 561
 562 int mpd_status_get_elapsed_song_time(MpdObj *mi)
 563 {
 564         if(!mpd_check_connected(mi))
 565         {
 566                 debug_printf(DEBUG_WARNING,"failed to check mi == NULL\n");
 567                 return MPD_NOT_CONNECTED;
 568         }
 569         if(mpd_status_check(mi) != MPD_OK)
 570         {
 571                 debug_printf(DEBUG_WARNING,"Failed to get status\n");
 572                 return MPD_STATUS_FAILED;
 573         }
 574         return mi->status->elapsedTime;
 575 }
 576
 577 int mpd_status_set_volume(MpdObj *mi,int volume)
 578 {
 579         if(!mpd_check_connected(mi))
 580         {
 581                 debug_printf(DEBUG_WARNING,"not connected\n");
 582                 return MPD_NOT_CONNECTED;
 583         }
 584         /* making sure volume is between 0 and 100 */
 585         volume = (volume < 0)? 0:(volume>100)? 100:volume;
 586
 587         if(mpd_lock_conn(mi))
 588         {
 589                 debug_printf(DEBUG_ERROR,"lock failed\n");
 590                 return MPD_LOCK_FAILED;
 591         }
 592
 593         /* send the command */
 594         mpd_sendSetvolCommand(mi->connection , volume);
 595         mpd_finishCommand(mi->connection);
 596         /* check for errors */
 597
 598         mpd_unlock_conn(mi);
 599         /* update status, because we changed it */
 600         mpd_status_queue_update(mi);
 601         /* return current volume */
 602         return mpd_status_get_volume(mi);
 603 }
 604
 605 int mpd_status_get_crossfade(MpdObj *mi)
 606 {
 607         if(!mpd_check_connected(mi))
 608         {
 609                 debug_printf(DEBUG_WARNING,"not connected\n");
 610                 return MPD_NOT_CONNECTED;
 611         }
 612         if(mpd_status_check(mi) != MPD_OK)
 613         {
 614                 debug_printf(DEBUG_WARNING,"Failed grabbing status\n");
 615                 return MPD_NOT_CONNECTED;
 616         }
 617         return mi->status->crossfade;
 618 }
 619
 620 int mpd_status_set_crossfade(MpdObj *mi,int crossfade_time)
 621 {
 622         if(!mpd_check_connected(mi))
 623         {
 624                 debug_printf(DEBUG_WARNING,"not connected\n");
 625                 return MPD_NOT_CONNECTED;
 626         }
 627         if(mpd_lock_conn(mi))
 628         {
 629                 debug_printf(DEBUG_ERROR,"lock failed\n");
 630                 return MPD_LOCK_FAILED;
 631         }
 632         mpd_sendCrossfadeCommand(mi->connection, crossfade_time);
 633         mpd_finishCommand(mi->connection);
 634
 635         mpd_unlock_conn(mi);
 636         mpd_status_queue_update(mi);
 637         return MPD_OK;
 638 }
 639
 640
 641 float mpd_status_set_volume_as_float(MpdObj *mi, float fvol)
 642 {
 643         int volume = mpd_status_set_volume(mi, (int)(fvol*100.0));
 644         if(volume > -1)
 645         {
 646                 return (float)volume/100.0;
 647         }
 648         return (float)volume;
 649 }
 650
 651 int mpd_stats_update(MpdObj *mi)
 652 {
 653         return mpd_stats_update_real(mi, NULL);
 654 }
 655
 656 int mpd_stats_update_real(MpdObj *mi, ChangedStatusType* what_changed)
 657 {
 658         ChangedStatusType what_changed_here = 0;
 659         if ( what_changed == NULL ) {
 660                 /* we need to save the current state, because we're called standalone */
 661                 memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState));
 662         }
 663
 664         if(!mpd_check_connected(mi))
 665         {
 666                 debug_printf(DEBUG_INFO,"not connected\n");
 667                 return MPD_NOT_CONNECTED;
 668         }
 669         if(mpd_lock_conn(mi))
 670         {
 671                 debug_printf(DEBUG_ERROR,"lock failed\n");
 672                 return MPD_LOCK_FAILED;
 673         }
 674
 675         if(mi->stats != NULL)
 676         {
 677                 mpd_freeStats(mi->stats);
 678         }
 679         mpd_sendStatsCommand(mi->connection);
 680         mi->stats = mpd_getStats(mi->connection);
 681         if(mi->stats == NULL)
 682         {
 683                 debug_printf(DEBUG_ERROR,"Failed to grab stats from mpd\n");
 684         }
 685         else if(mi->stats->dbUpdateTime != mi->OldState.dbUpdateTime)
 686         {
 687                 debug_printf(DEBUG_INFO, "database updated\n");
 688                 what_changed_here |= MPD_CST_DATABASE;
 689
 690                 mi->CurrentState.dbUpdateTime = mi->stats->dbUpdateTime;
 691         }
 692
 693         if (what_changed) {
 694                 (*what_changed) |= what_changed_here;
 695         } else {
 696                 if((mi->the_status_changed_callback != NULL) & what_changed_here)
 697                 {
 698                         mi->the_status_changed_callback(mi, what_changed_here, mi->the_status_changed_signal_userdata);
 699                 }
 700         }
 701
 702         if(mpd_unlock_conn(mi))
 703         {
 704                 debug_printf(DEBUG_ERROR, "unlock failed");
 705                 return MPD_LOCK_FAILED;
 706         }
 707         return MPD_OK;
 708 }
 709
 710
 711 int mpd_stats_check(MpdObj *mi)
 712 {
 713         if(!mpd_check_connected(mi))
 714         {
 715                 debug_printf(DEBUG_WARNING,"not connected\n");
 716                 return MPD_NOT_CONNECTED;
 717         }
 718         if(mi->stats == NULL)
 719         {
 720                 /* try to update */
 721                 if(mpd_stats_update(mi))
 722                 {
 723                         debug_printf(DEBUG_ERROR,"failed to update status\n");
 724                         return MPD_STATUS_FAILED;
 725                 }
 726         }
 727         return MPD_OK;
 728 }