git.maemo.org Git - monky/blob - src/audacious.c

   1 /* $Id$ */
   2
   3 /* audacious.c:  conky support for audacious music player
   4  *
   5  * Copyright (C) 2005-2007 Philip Kovacs pkovacs@users.sourceforge.net
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  20  * USA. */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <glib.h>
  27 #ifndef AUDACIOUS_LEGACY
  28 #include <glib-object.h>
  29 #include <audacious/audctrl.h>
  30 #include <audacious/dbus.h>
  31 #else
  32 #include <audacious/beepctrl.h>
  33 #define audacious_remote_is_running(x)                          \
  34         xmms_remote_is_running(x)
  35 #define audacious_remote_is_paused(x)                           \
  36         xmms_remote_is_paused(x)
  37 #define audacious_remote_is_playing(x)                          \
  38         xmms_remote_is_playing(x)
  39 #define audacious_remote_get_playlist_pos(x)            \
  40         xmms_remote_get_playlist_pos(x)
  41 #define audacious_remote_get_playlist_title(x, y)       \
  42         xmms_remote_get_playlist_title(x, y)
  43 #define audacious_remote_get_playlist_time(x, y)        \
  44         xmms_remote_get_playlist_time(x, y)
  45 #define audacious_remote_get_output_time(x)                     \
  46         xmms_remote_get_output_time(x)
  47 #define audacious_remote_get_info(w, x, y, z)           \
  48         xmms_remote_get_info(w, x, y, z)
  49 #define audacious_remote_get_playlist_file(x, y)        \
  50         xmms_remote_get_playlist_file(x, y)
  51 #define audacious_remote_get_playlist_length(x)         \
  52         xmms_remote_get_playlist_length(x)
  53 #endif
  54
  55 #include "conky.h"
  56 #include "audacious.h"
  57
  58 /* access to this item array is synchronized */
  59 static audacious_t audacious_items;
  60
  61 /* -----------------------------------------
  62  * Conky update function for audacious data.
  63  * ----------------------------------------- */
  64 void update_audacious(void)
  65 {
  66         /* The worker thread is updating audacious_items array asynchronously
  67          * to the main conky thread.
  68          * We merely copy the audacious_items array into the main thread's info
  69          * structure when the main thread's update cycle fires. */
  70         if (!info.audacious.p_timed_thread) {
  71                 if (create_audacious_thread() != 0) {
  72                         CRIT_ERR("unable to create audacious thread!");
  73                 }
  74                 timed_thread_register(info.audacious.p_timed_thread,
  75                         &info.audacious.p_timed_thread);
  76         }
  77
  78         timed_thread_lock(info.audacious.p_timed_thread);
  79         memcpy(&info.audacious.items, audacious_items, sizeof(audacious_items));
  80         timed_thread_unlock(info.audacious.p_timed_thread);
  81 }
  82
  83 /* ---------------------------------------------------------
  84  * Create a worker thread for audacious media player status.
  85  *
  86  * Returns 0 on success, -1 on error.
  87  * --------------------------------------------------------- */
  88 int create_audacious_thread(void)
  89 {
  90         if (!info.audacious.p_timed_thread) {
  91                 info.audacious.p_timed_thread =
  92                         timed_thread_create(audacious_thread_func, NULL,
  93                         info.music_player_interval * 1000000);
  94         }
  95
  96         if (!info.audacious.p_timed_thread
  97                         || timed_thread_run(info.audacious.p_timed_thread)) {
  98                 return -1;
  99         }
 100
 101         return 0;
 102 }
 103
 104 /* ---------------------------------------
 105  * Destroy audacious player status thread.
 106  *
 107  * Returns 0 on success, -1 on error.
 108  * --------------------------------------- */
 109 int destroy_audacious_thread(void)
 110 {
 111         /* Is a worker is thread running? If not, no error. */
 112         if (!info.audacious.p_timed_thread) {
 113                 return 0;
 114         }
 115
 116         timed_thread_destroy(info.audacious.p_timed_thread,
 117                 &info.audacious.p_timed_thread);
 118
 119         return 0;
 120 }
 121
 122 /* ---------------------------------------------------
 123  * Worker thread function for audacious data sampling.
 124  * --------------------------------------------------- */
 125 void *audacious_thread_func(void *pvoid)
 126 {
 127         static audacious_t items;
 128         gint playpos, frames, length;
 129         gint rate, freq, chans;
 130         gchar *psong, *pfilename;
 131
 132 #ifndef AUDACIOUS_LEGACY
 133         DBusGProxy *session = NULL;
 134         DBusGConnection *connection = NULL;
 135 #else
 136         gint session;
 137 #endif
 138
 139         pvoid = (void *) pvoid; /* avoid warning */
 140         session = 0;
 141         psong = NULL;
 142         pfilename = NULL;
 143
 144 #ifndef AUDACIOUS_LEGACY
 145         g_type_init();
 146         connection = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
 147         if (!connection) {
 148                 CRIT_ERR("unable to establish dbus connection");
 149         }
 150         session = dbus_g_proxy_new_for_name(connection, AUDACIOUS_DBUS_SERVICE,
 151                         AUDACIOUS_DBUS_PATH, AUDACIOUS_DBUS_INTERFACE);
 152         if (!session) {
 153                 CRIT_ERR("unable to create dbus proxy");
 154         }
 155 #endif /* AUDACIOUS_LEGACY */
 156
 157         /* Loop until the main thread resets the runnable signal. */
 158         while (1) {
 159
 160                 do {
 161                         if (!audacious_remote_is_running(session)) {
 162                                 memset(&items, 0, sizeof(items));
 163                                 strcpy(items[AUDACIOUS_STATUS], "Not running");
 164                                 break;
 165                         }
 166
 167                         /* Player status */
 168                         if (audacious_remote_is_paused(session)) {
 169                                 strcpy(items[AUDACIOUS_STATUS], "Paused");
 170                         } else if (audacious_remote_is_playing(session)) {
 171                                 strcpy(items[AUDACIOUS_STATUS], "Playing");
 172                         } else {
 173                                 strcpy(items[AUDACIOUS_STATUS], "Stopped");
 174                         }
 175
 176                         /* Current song title */
 177                         playpos = audacious_remote_get_playlist_pos(session);
 178                         psong = audacious_remote_get_playlist_title(session, playpos);
 179                         if (psong) {
 180                                 strncpy(items[AUDACIOUS_TITLE], psong,
 181                                                 sizeof(items[AUDACIOUS_TITLE]) - 1);
 182                                 g_free(psong);
 183                                 psong = NULL;
 184                         }
 185
 186                         /* Current song length as MM:SS */
 187                         frames = audacious_remote_get_playlist_time(session, playpos);
 188                         length = frames / 1000;
 189                         snprintf(items[AUDACIOUS_LENGTH], sizeof(items[AUDACIOUS_LENGTH]) - 1,
 190                                         "%d:%.2d", length / 60, length % 60);
 191
 192                         /* Current song length in seconds */
 193                         snprintf(items[AUDACIOUS_LENGTH_SECONDS],
 194                                         sizeof(items[AUDACIOUS_LENGTH_SECONDS]) - 1, "%d", length);
 195
 196                         /* Current song position as MM:SS */
 197                         frames = audacious_remote_get_output_time(session);
 198                         length = frames / 1000;
 199                         snprintf(items[AUDACIOUS_POSITION],
 200                                         sizeof(items[AUDACIOUS_POSITION]) - 1, "%d:%.2d", length / 60,
 201                                         length % 60);
 202
 203                         /* Current song position in seconds */
 204                         snprintf(items[AUDACIOUS_POSITION_SECONDS],
 205                                         sizeof(items[AUDACIOUS_POSITION_SECONDS]) - 1, "%d", length);
 206
 207                         /* Current song bitrate */
 208                         audacious_remote_get_info(session, &rate, &freq, &chans);
 209                         snprintf(items[AUDACIOUS_BITRATE], sizeof(items[AUDACIOUS_BITRATE]) - 1,
 210                                         "%d", rate);
 211
 212                         /* Current song frequency */
 213                         snprintf(items[AUDACIOUS_FREQUENCY],
 214                                         sizeof(items[AUDACIOUS_FREQUENCY]) - 1, "%d", freq);
 215
 216                         /* Current song channels */
 217                         snprintf(items[AUDACIOUS_CHANNELS],
 218                                         sizeof(items[AUDACIOUS_CHANNELS]) - 1, "%d", chans);
 219
 220                         /* Current song filename */
 221                         pfilename = audacious_remote_get_playlist_file(session, playpos);
 222                         if (pfilename) {
 223                                 strncpy(items[AUDACIOUS_FILENAME], pfilename,
 224                                                 sizeof(items[AUDACIOUS_FILENAME]) - 1);
 225                                 g_free(pfilename);
 226                                 pfilename = NULL;
 227                         }
 228
 229                         /* Length of the Playlist (number of songs) */
 230                         length = audacious_remote_get_playlist_length(session);
 231                         snprintf(items[AUDACIOUS_PLAYLIST_LENGTH],
 232                                         sizeof(items[AUDACIOUS_PLAYLIST_LENGTH]) - 1, "%d", length);
 233
 234                         /* Playlist position (index of song) */
 235                         snprintf(items[AUDACIOUS_PLAYLIST_POSITION],
 236                                         sizeof(items[AUDACIOUS_PLAYLIST_POSITION]) - 1, "%d", playpos + 1);
 237                 } while (0);
 238                 /* Deliver the refreshed items array to audacious_items. */
 239                 timed_thread_lock(info.audacious.p_timed_thread);
 240                 memcpy(&audacious_items, items, sizeof(items));
 241                 timed_thread_unlock(info.audacious.p_timed_thread);
 242
 243                 if (timed_thread_test(info.audacious.p_timed_thread)) {
 244 #ifndef AUDACIOUS_LEGACY
 245                         /* release reference to dbus proxy */
 246                         g_object_unref(session);
 247 #endif
 248                         timed_thread_exit(info.audacious.p_timed_thread);
 249                 }
 250         }
 251 }