00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <glib.h>
00023 #include <libaudcore/hook.h>
00024 #include <libaudcore/vfs.h>
00025
00026 #include "config.h"
00027 #include "drct.h"
00028 #include "i18n.h"
00029 #include "misc.h"
00030 #include "playback.h"
00031 #include "playlist.h"
00032
00033
00034
00035 void drct_quit (void)
00036 {
00037 hook_call ("quit", NULL);
00038 }
00039
00040
00041
00042 void drct_play (void)
00043 {
00044 if (playback_get_playing ())
00045 {
00046 if (playback_get_paused ())
00047 playback_pause ();
00048 else
00049 playback_seek (0);
00050 }
00051 else
00052 {
00053 playlist_set_playing (playlist_get_active ());
00054 playback_play (0, FALSE);
00055 }
00056 }
00057
00058 void drct_pause (void)
00059 {
00060 if (playback_get_playing ())
00061 playback_pause ();
00062 }
00063
00064 void drct_stop (void)
00065 {
00066 if (playback_get_playing ())
00067 playback_stop ();
00068 }
00069
00070 gboolean drct_get_playing (void)
00071 {
00072 return playback_get_playing ();
00073 }
00074
00075 gboolean drct_get_ready (void)
00076 {
00077 return playback_get_ready ();
00078 }
00079
00080 gboolean drct_get_paused (void)
00081 {
00082 return playback_get_paused ();
00083 }
00084
00085 gchar * drct_get_title (void)
00086 {
00087 return playback_get_title ();
00088 }
00089
00090 void drct_get_info (gint * bitrate, gint * samplerate, gint * channels)
00091 {
00092 playback_get_info (bitrate, samplerate, channels);
00093 }
00094
00095 gint drct_get_time (void)
00096 {
00097 return playback_get_time ();
00098 }
00099
00100 gint drct_get_length (void)
00101 {
00102 return playback_get_length ();
00103 }
00104
00105 void drct_seek (gint time)
00106 {
00107 playback_seek (time);
00108 }
00109
00110
00111
00112 void drct_get_volume (gint * left, gint * right)
00113 {
00114 playback_get_volume (left, right);
00115 * left = CLAMP (* left, 0, 100);
00116 * right = CLAMP (* right, 0, 100);
00117 }
00118
00119 void drct_set_volume (gint left, gint right)
00120 {
00121 playback_set_volume (CLAMP (left, 0, 100), CLAMP (right, 0, 100));
00122 }
00123
00124 void drct_get_volume_main (gint * volume)
00125 {
00126 gint left, right;
00127 drct_get_volume (& left, & right);
00128 * volume = MAX (left, right);
00129 }
00130
00131 void drct_set_volume_main (gint volume)
00132 {
00133 gint left, right, current;
00134 drct_get_volume (& left, & right);
00135 current = MAX (left, right);
00136
00137 if (current > 0)
00138 drct_set_volume (volume * left / current, volume * right / current);
00139 else
00140 drct_set_volume (volume, volume);
00141 }
00142
00143 void drct_get_volume_balance (gint * balance)
00144 {
00145 gint left, right;
00146 drct_get_volume (& left, & right);
00147
00148 if (left == right)
00149 * balance = 0;
00150 else if (left > right)
00151 * balance = -100 + right * 100 / left;
00152 else
00153 * balance = 100 - left * 100 / right;
00154 }
00155
00156 void drct_set_volume_balance (gint balance)
00157 {
00158 gint left, right;
00159 drct_get_volume_main (& left);
00160
00161 if (balance < 0)
00162 right = left * (100 + balance) / 100;
00163 else
00164 {
00165 right = left;
00166 left = right * (100 - balance) / 100;
00167 }
00168
00169 drct_set_volume (left, right);
00170 }
00171
00172
00173
00174 gint drct_pl_get_length (void)
00175 {
00176 return playlist_entry_count (playlist_get_active ());
00177 }
00178
00179 void drct_pl_next (void)
00180 {
00181 gboolean play = playback_get_playing ();
00182 if (playlist_get_playing () < 0)
00183 playlist_set_playing (playlist_get_active ());
00184 if (playlist_next_song (playlist_get_playing (), get_bool (NULL, "repeat")) && play)
00185 playback_play (0, FALSE);
00186 }
00187
00188 void drct_pl_prev (void)
00189 {
00190 gboolean play = playback_get_playing ();
00191 if (playlist_get_playing () < 0)
00192 playlist_set_playing (playlist_get_active ());
00193 if (playlist_prev_song (playlist_get_playing ()) && play)
00194 playback_play (0, FALSE);
00195 }
00196
00197 gint drct_pl_get_pos (void)
00198 {
00199 return playlist_get_position (playlist_get_active ());
00200 }
00201
00202 void drct_pl_set_pos (gint pos)
00203 {
00204 gint playlist = playlist_get_active ();
00205 gboolean play = playback_get_playing ();
00206
00207 playlist_set_position (playlist, pos);
00208
00209 if (play)
00210 {
00211 playlist_set_playing (playlist);
00212 playback_play (0, FALSE);
00213 }
00214 }
00215
00216 gchar * drct_pl_get_file (gint entry)
00217 {
00218 return playlist_entry_get_filename (playlist_get_active (), entry);
00219 }
00220
00221 gchar * drct_pl_get_title (gint entry)
00222 {
00223 return playlist_entry_get_title (playlist_get_active (), entry, FALSE);
00224 }
00225
00226 gint drct_pl_get_time (gint pos)
00227 {
00228 return playlist_entry_get_length (playlist_get_active (), pos, FALSE);
00229 }
00230
00231 static void activate_temp (void)
00232 {
00233 gint playlists = playlist_count ();
00234 const gchar * title = _("Temporary Playlist");
00235
00236 for (gint playlist = 0; playlist < playlists; playlist ++)
00237 {
00238 gchar * title2 = playlist_get_title (playlist);
00239 if (! strcmp (title2, title))
00240 {
00241 playlist_set_active (playlist);
00242 g_free (title2);
00243 return;
00244 }
00245 g_free (title2);
00246 }
00247
00248 if (! playlist_entry_count (playlist_get_active ()))
00249 playlist_set_title (playlist_get_active (), title);
00250 else
00251 {
00252 playlist_insert (playlists);
00253 playlist_set_title (playlists, title);
00254 playlist_set_active (playlists);
00255 }
00256 }
00257
00258 static void add_list (GList * list, gint at, gboolean to_temp, gboolean play)
00259 {
00260 if (to_temp)
00261 activate_temp ();
00262
00263 gint playlist = playlist_get_active ();
00264
00265 if (play)
00266 {
00267 if (get_bool (NULL, "clear_playlist"))
00268 playlist_entry_delete (playlist, 0, playlist_entry_count (playlist));
00269 else
00270 playlist_queue_delete (playlist, 0, playlist_queue_count (playlist));
00271 }
00272
00273 struct index * filenames = index_new ();
00274 for (; list != NULL; list = list->next)
00275 index_append (filenames, g_strdup (list->data));
00276
00277 playlist_entry_insert_batch (playlist, at, filenames, NULL, play);
00278 }
00279
00280 void drct_pl_add (const gchar * filename, gint at)
00281 {
00282 GList * list = g_list_prepend (NULL, (void *) filename);
00283 add_list (list, at, FALSE, FALSE);
00284 g_list_free (list);
00285 }
00286
00287 void drct_pl_add_list (GList * list, gint at)
00288 {
00289 add_list (list, at, FALSE, FALSE);
00290 }
00291
00292 void drct_pl_open (const gchar * filename)
00293 {
00294 GList * list = g_list_prepend (NULL, (void *) filename);
00295 add_list (list, -1, get_bool (NULL, "open_to_temporary"), TRUE);
00296 g_list_free (list);
00297 }
00298
00299 void drct_pl_open_list (GList * list)
00300 {
00301 add_list (list, -1, get_bool (NULL, "open_to_temporary"), TRUE);
00302 }
00303
00304 void drct_pl_open_temp (const gchar * filename)
00305 {
00306 GList * list = g_list_prepend (NULL, (void *) filename);
00307 add_list (list, -1, TRUE, TRUE);
00308 g_list_free (list);
00309 }
00310
00311 void drct_pl_open_temp_list (GList * list)
00312 {
00313 add_list (list, -1, TRUE, TRUE);
00314 }
00315
00316 void drct_pl_delete (gint entry)
00317 {
00318 playlist_entry_delete (playlist_get_active (), entry, 1);
00319 }
00320
00321
00322
00323
00324
00325
00326 void drct_pl_delete_selected (void)
00327 {
00328 gint list = playlist_get_active ();
00329 gint pos = playlist_get_position (list);
00330
00331 if (get_bool (NULL, "advance_on_delete")
00332 && ! get_bool (NULL, "no_playlist_advance")
00333 && playback_get_playing () && list == playlist_get_playing ()
00334 && pos >= 0 && playlist_entry_get_selected (list, pos))
00335 {
00336 playlist_entry_set_selected (list, pos, FALSE);
00337 playlist_delete_selected (list);
00338 pos = playlist_get_position (list);
00339
00340 if (playlist_next_song (list, get_bool (NULL, "repeat"))
00341 && playlist_get_position (list) != pos)
00342 playback_play (0, FALSE);
00343
00344 playlist_entry_delete (list, pos, 1);
00345 }
00346 else
00347 playlist_delete_selected (list);
00348 }
00349
00350 void drct_pl_clear (void)
00351 {
00352 gint playlist = playlist_get_active ();
00353 playlist_entry_delete (playlist, 0, playlist_entry_count (playlist));
00354 }
00355
00356
00357
00358 gint drct_pq_get_length (void)
00359 {
00360 return playlist_queue_count (playlist_get_active ());
00361 }
00362
00363 gint drct_pq_get_entry (gint queue_position)
00364 {
00365 return playlist_queue_get_entry (playlist_get_active (), queue_position);
00366 }
00367
00368 gboolean drct_pq_is_queued (gint entry)
00369 {
00370 return (drct_pq_get_queue_position (entry) >= 0);
00371 }
00372
00373 gint drct_pq_get_queue_position (gint entry)
00374 {
00375 return playlist_queue_find_entry (playlist_get_active (), entry);
00376 }
00377
00378 void drct_pq_add (gint entry)
00379 {
00380 playlist_queue_insert (playlist_get_active (), -1, entry);
00381 }
00382
00383 void drct_pq_remove (gint entry)
00384 {
00385 gint playlist = playlist_get_active ();
00386 playlist_queue_delete (playlist, playlist_queue_find_entry (playlist,
00387 entry), 1);
00388 }
00389
00390 void drct_pq_clear (void)
00391 {
00392 gint playlist = playlist_get_active ();
00393 playlist_queue_delete (playlist, 0, playlist_queue_count (playlist));
00394 }