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