void
quit()
{
debug_printf ("Quitting.\n");
prefs_set_stream_prefs (&g_rmo, "stream defaults");
prefs_set_wstreamripper_prefs (&g_gui_prefs);
prefs_save ();
CloseHandle (m_hpipe_exe_read);
CloseHandle (m_hpipe_exe_write);
if (m_bRipping)
rip_manager_stop (m_rmi);
rip_manager_cleanup ();
debug_printf ("Going to render_destroy()...\n");
render_destroy();
debug_printf ("Going to DestroyWindow()...\n");
DestroyWindow(m_hwnd);
Shell_NotifyIcon(NIM_DELETE, &m_nid);
DestroyIcon(m_nid.hIcon);
debug_printf ("Going to UnregisterClass()...\n");
UnregisterClass(m_szWindowClass, m_hinstance); // unregister window class
debug_printf ("Finished UnregisterClass()\n");
}
static void dump_pref_file(void (*dump)(ang_file *), const char *title, int row)
{
char ftmp[80];
char buf[1024];
screen_save();
/* Prompt */
prt(format("%s to a pref file", title), row, 0);
/* Prompt */
prt("File: ", row + 2, 0);
/* Default filename */
strnfmt(ftmp, sizeof ftmp, "%s.prf", op_ptr.base_name);
/* Get a filename */
if (askfor_aux(ftmp, sizeof ftmp, null))
{
/* Build the filename */
path_build(buf, sizeof(buf), ANGBAND_DIR_USER, ftmp);
prt("", 0, 0);
if (prefs_save(buf, dump, title))
msg("Dumped %s", strstr(title, " ") + 1);
else
msg("Failed");
}
screen_load();
return;
}
/**
* Save the game
*/
void save_game(void)
{
char name[80];
char path[1024];
/* Disturb the player */
disturb(player, 1);
/* Clear messages */
event_signal(EVENT_MESSAGE_FLUSH);
/* Handle stuff */
handle_stuff(player);
/* Message */
prt("Saving game...", 0, 0);
/* Refresh */
Term_fresh();
/* The player is not dead */
my_strcpy(player->died_from, "(saved)", sizeof(player->died_from));
/* Forbid suspend */
signals_ignore_tstp();
/* Save the player */
if (savefile_save(savefile))
prt("Saving game... done.", 0, 0);
else
prt("Saving game... failed!", 0, 0);
/* Refresh */
Term_fresh();
/* Save the window prefs */
strnfmt(name, sizeof(name), "%s.prf", player_safe_name(player, TRUE));
path_build(path, sizeof(path), ANGBAND_DIR_USER, name);
if (!prefs_save(path, option_dump, "Dump window settings"))
prt("Failed to save subwindow preferences", 0, 0);
/* Allow suspend again */
signals_handle_tstp();
/* Refresh */
Term_fresh();
/* Note that the player is not dead */
my_strcpy(player->died_from, "(alive and well)", sizeof(player->died_from));
}
static gint
prefs_respond(GtkWidget *widget,
gint response_id,
gpointer data)
{
if ( response_id == GTK_RESPONSE_APPLY
|| response_id == GTK_RESPONSE_OK) {
prefs_update_prefs_from_dialog();
prefs_save();
diagram_redraw_all();
}
if (response_id != GTK_RESPONSE_APPLY)
gtk_widget_hide(widget);
return 0;
}
static void dump_pref_file(void (*dump)(ang_file *), const char *title, int row)
{
char buf[1024];
/* Get filename from user */
if (!get_pref_path(title, row, buf, sizeof(buf)))
return;
/* Try to save */
if (prefs_save(buf, dump, title))
msg("Saved %s.", strstr(title, " ") + 1);
else
msg("Failed to save %s.", strstr(title, " ") + 1);
event_signal(EVENT_MESSAGE_FLUSH);
return;
}
int
init ()
{
WNDCLASS wc;
char* sr_debug_env;
int rc;
sr_debug_env = getenv ("STREAMRIPPER_DEBUG");
if (sr_debug_env) {
debug_enable();
debug_set_filename (sr_debug_env);
}
winamp_init (m_hinstance);
rc = prefs_load ();
prefs_get_stream_prefs (&g_rmo, "");
if (rc == 0) {
options_get_desktop_folder (g_rmo.output_directory);
}
prefs_get_wstreamripper_prefs (&g_gui_prefs);
prefs_save ();
/* GCS FIX */
//m_guiOpt.m_enabled = 1;
//debug_printf ("Checking if enabled.\n");
//if (!m_guiOpt.m_enabled)
// return 0;
//debug_printf ("Was enabled.\n");
memset (&wc,0,sizeof(wc));
wc.lpfnWndProc = WndProc; // our window procedure
wc.hInstance = m_hinstance;
wc.lpszClassName = m_szWindowClass; // our window class name
wc.hCursor = LoadCursor (NULL, IDC_ARROW);
// Load systray popup menu
m_hmenu_systray = LoadMenu (m_hinstance, MAKEINTRESOURCE(IDR_TASKBAR_POPUP));
m_hmenu_systray_sub = GetSubMenu (m_hmenu_systray, 0);
SetMenuDefaultItem (m_hmenu_systray_sub, 0, TRUE);
if (!RegisterClass(&wc)) {
MessageBox (NULL,"Error registering window class","blah",MB_OK);
return 1;
}
/* Ref: http://msdn2.microsoft.com/en-us/library/bb776822.aspx */
if (g_running_standalone) {
m_hwnd = CreateWindowEx (
WS_EX_APPWINDOW,
m_szWindowClass, "Streamripper Plugin", WS_POPUP,
g_gui_prefs.oldpos_x, g_gui_prefs.oldpos_y, WINDOW_WIDTH, WINDOW_HEIGHT,
NULL, NULL, m_hinstance, NULL);
} else {
m_hwnd = CreateWindowEx (
WS_EX_TOOLWINDOW,
m_szWindowClass, "Streamripper Plugin", WS_POPUP,
g_gui_prefs.oldpos_x, g_gui_prefs.oldpos_y, WINDOW_WIDTH, WINDOW_HEIGHT,
NULL, NULL, m_hinstance, NULL);
}
// Create a systray icon
memset(&m_nid, 0, sizeof(NOTIFYICONDATA));
m_nid.cbSize = sizeof(NOTIFYICONDATA);
m_nid.hIcon = LoadImage(m_hinstance, MAKEINTRESOURCE(IDI_SR_ICON), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
m_nid.hWnd = m_hwnd;
strcpy(m_nid.szTip, m_szToopTip);
m_nid.uCallbackMessage = WM_MY_TRAY_NOTIFICATION;
m_nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
m_nid.uID = 1;
Shell_NotifyIcon(NIM_ADD, &m_nid);
// Load main popup menu
m_hmenu_context = LoadMenu (m_hinstance, MAKEINTRESOURCE(IDR_HISTORY_POPUP));
m_hmenu_context_sub = GetSubMenu (m_hmenu_context, 0);
SetMenuDefaultItem (m_hmenu_context_sub, 0, TRUE);
// Populate main popup menu
populate_history_popup ();
if (!g_gui_prefs.m_start_minimized)
dock_show_window(m_hwnd, SW_SHOWNORMAL);
else
dock_show_window(m_hwnd, SW_HIDE);
return 0;
}
gboolean
app_exit(void)
{
GList *list;
GSList *slist;
/*
* The following "solves" a crash related to a second call of app_exit,
* after gtk_main_quit was called. It may be a win32 gtk-1.3.x bug only
* but the check shouldn't hurt on *ix either. --hb
*/
static gboolean app_exit_once = FALSE;
if (app_exit_once) {
g_error(_("This shouldn't happen. Please file a bug report at bugzilla.gnome.org\n"
"describing how you caused this message to appear.\n"));
return FALSE;
}
if (diagram_modified_exists()) {
if (is_integrated_ui ())
{
GtkWidget *dialog;
int result;
exit_dialog_item_array_t *items = NULL;
GList * list;
Diagram * diagram;
dialog = exit_dialog_make (GTK_WINDOW (interface_get_toolbox_shell ()),
_("Exiting Dia"));
list = dia_open_diagrams();
while (list)
{
diagram = list->data;
if (diagram_is_modified (diagram))
{
const gchar * name = diagram_get_name (diagram);
const gchar * path = diagram->filename;
exit_dialog_add_item (dialog, name, path, diagram);
}
list = g_list_next (list);
}
result = exit_dialog_run (dialog, &items);
gtk_widget_destroy (dialog);
if (result == EXIT_DIALOG_EXIT_CANCEL)
{
return FALSE;
}
else if (result == EXIT_DIALOG_EXIT_SAVE_SELECTED)
{
DiaContext *ctx = dia_context_new(_("Save"));
int i;
for (i = 0 ; i < items->array_size ; i++) {
gchar *filename;
diagram = items->array[i].data;
filename = g_filename_from_utf8 (diagram->filename, -1, NULL, NULL, NULL);
diagram_update_extents (diagram);
dia_context_set_filename (ctx, filename);
if (!diagram_save (diagram, filename, ctx)) {
exit_dialog_free_items (items);
dia_context_release (ctx);
return FALSE;
} else {
dia_context_reset (ctx);
}
g_free (filename);
}
dia_context_release (ctx);
exit_dialog_free_items (items);
}
else if (result == EXIT_DIALOG_EXIT_NO_SAVE)
{
list = dia_open_diagrams();
while (list) {
diagram = list->data;
/* slight hack: don't ask again */
diagram_set_modified (diagram, FALSE);
undo_clear(diagram->undo);
list = g_list_next (list);
}
}
}
else
{
GtkWidget *dialog;
GtkWidget *button;
dialog = gtk_message_dialog_new(
NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE, /* no standard buttons */
_("Quitting without saving modified diagrams"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
_("Modified diagrams exist. "
"Are you sure you want to quit Dia "
"without saving them?"));
gtk_window_set_title (GTK_WINDOW(dialog), _("Quit Dia"));
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_CANCEL);
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_default (GTK_WIDGET (button), TRUE);
#else
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
#endif
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_OK);
gtk_widget_show_all (dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return FALSE;
}
gtk_widget_destroy(dialog);
}
}
prefs_save();
persistence_save();
dynobj_refresh_finish();
{
DiaContext *ctx = dia_context_new (_("Exit"));
dia_object_defaults_save (NULL, ctx);
dia_context_release (ctx);
}
/* Free loads of stuff (toolbox) */
list = dia_open_diagrams();
while (list!=NULL) {
Diagram *dia = (Diagram *)list->data;
list = g_list_next(list);
slist = dia->displays;
while (slist!=NULL) {
DDisplay *ddisp = (DDisplay *)slist->data;
slist = g_slist_next(slist);
gtk_widget_destroy(ddisp->shell);
}
/* The diagram is freed when the last display is destroyed */
}
/* save pluginrc */
if (dia_is_interactive)
dia_pluginrc_write();
gtk_main_quit();
/* This printf seems to prevent a race condition with unrefs. */
/* Yuck. -Lars */
/* Trying to live without it. -Lars 10/8/07*/
/* g_print(_("Thank you for using Dia.\n")); */
app_exit_once = TRUE;
return TRUE;
}
int main(int argc, char **argv)
{
const char *device_param = default_pcm_device;
char *prefsdir;
char thefile[1024];
char str[1024];
float start_vol = 1.0;
int ap_result = 0;
int use_fragsize = -1; // Initialized
int use_fragcount = -1; // later
int do_loopsong = 0;
int do_looplist = 0;
int do_enqueue = 0;
int do_replace = 0;
int do_realtime = 0;
int do_remote_control = 0;
int do_shuffle = 0;
int do_start = 0;
int do_stop = 0;
int do_prev = 0;
int do_next = 0;
int do_pause = 0;
int do_jump = -1;
int do_clear = 0;
int do_seek = -1;
int do_relative = 0;
int do_setvol = 0;
int do_quit = 0;
int do_status = 0;
int do_speed = 0;
float speed_val = 0.0;
int do_onebyone = 0;
int use_freq = OUTPUT_RATE;
float use_vol = 1.0;
int use_session = 0;
int do_crossfade = 0;
int do_save = 1;
int bool_val = 0;
const char *use_output = NULL;
char *use_interface = NULL;
char *use_config = NULL;
char *use_loopsong = NULL;
char *use_onebyone = NULL;
char *use_looplist = NULL;
int opt;
int option_index;
const char *options = "Cc:d:eEf:F:g:hi:J:I:l:n:NMp:qrs:vRSQVxo:";
struct option long_options[] = {
/* { "long_option", take_argument, 0, 'short_option' }, */
{ "config", 1, 0, 'c' },
{ "device", 1, 0, 'd' },
{ "enqueue", 0, 0, 'e' },
{ "replace", 0, 0, 'E' },
{ "fragsize", 1, 0, 'f' },
{ "frequency", 1, 0, 'F' },
{ "fragcount", 1, 0, 'g' },
{ "help", 0, 0, 'h' },
{ "interface", 1, 0, 'i' },
{ "volume", 1, 0, 'Y' },
{ "session", 1, 0, 'n' },
{ "nosave", 0, 0, 'N' },
{ "path", 1, 0, 'p' },
{ "quiet", 0, 0, 'q' },
{ "realtime", 0, 0, 'r' },
{ "script", 1, 0, 'I'},
{ "session-name", 1, 0, 's' },
{ "version", 0, 0, 'v' },
{ "verbose", 0, 0, 'V' },
{ "reverb", 0, 0, 'R' },
{ "loopsong", 1, 0, 'L' },
{ "looplist", 1, 0, 'P' },
{ "crossfade", 0, 0, 'x' },
{ "output", 1, 0, 'o' },
{ "stop", 0, 0, 'U' },
{ "pause", 0, 0, 'O' },
{ "start", 0, 0, 'T' },
{ "shuffle", 0, 0, 'S' },
{ "prev", 0, 0, 'Q' },
{ "next", 0, 0, 'M' },
{ "jump", 1, 0, 'J' },
{ "seek", 1, 0, 'X' },
{ "relative", 1, 0, 'Z' },
{ "speed", 1, 0, 'H' },
{ "clear", 0, 0, 'C' },
{ "startvolume", 1, 0, 'l' },
{ "quit", 0, 0, 'A' },
{ "status", 0, 0, 'B' },
{ "onebyone", 1, 0, 't' },
// Options that we want to be able to pass on to gtk_init(). See man
// gtk-options(7).
// Give all of these an option number of 128 because we're going to
// ignore them option switch statement anyway.
{ "gtk-module", 1, 0, 128 },
{ "gtk-debug", 1, 0, 128 },
{ "gtk-no-debug", 1, 0, 128 },
{ "g-fatal-warnings", 0, 0, 128 },
{ "display", 1, 0, 128 },
{ "screen", 1, 0, 128 },
{ "sync", 0, 0, 128 },
{ "no-xshm", 0, 0, 128 },
{ "name", 1, 0, 128 },
{ "class", 1, 0, 128 },
{ "gxid_host", 1, 0, 128 },
{ "gxid_port", 1, 0, 128 },
{ "xim-preedit", 0, 0, 128 },
{ "xim-status", 0, 0, 128 },
{ "gdk-debug", 1, 0, 128 },
{ "gdk-no-debug", 1, 0, 128 },
// End of list marker.
{ 0, 0, 0, 0 }
};
// First setup signal handler
signal(SIGPIPE, nonfatal_sighandler); // PIPE (socket control)
signal(SIGTERM, exit_sighandler); // kill
signal(SIGHUP, exit_sighandler); // kill -HUP / xterm closed
signal(SIGINT, exit_sighandler); // Interrupt from keyboard
signal(SIGQUIT, exit_sighandler); // Quit from keyboard
// fatal errors
signal(SIGBUS, exit_sighandler); // bus error
//signal(SIGSEGV, exit_sighandler); // segfault
signal(SIGILL, exit_sighandler); // illegal instruction
signal(SIGFPE, exit_sighandler); // floating point exc.
signal(SIGABRT, exit_sighandler); // abort()
// Enable locale support
#ifdef ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
bind_textdomain_codeset (PACKAGE, "UTF-8");
#endif
// Init global mutexes
pthread_mutex_init(&playlist_sort_seq_mutex, NULL);
#if !defined(EMBEDDED)
init_effects();
#endif
while ((opt = getopt_long(argc, argv, options, long_options, &option_index)) != EOF) {
switch(opt) {
case 'A':
do_remote_control = 1;
do_quit = 1;
break;
case 'B':
do_remote_control = 1;
do_status = 1;
break;
case 'c':
if (strlen(optarg) < 1023) {
use_config = optarg;
} else {
alsaplayer_error("config file path too long");
return 1;
}
break;
case 'd':
device_param = optarg;
break;
case 'E':
do_replace = 1;
case 'e':
do_enqueue = 1;
break;
case 'f':
use_fragsize = atoi(optarg);
if (!use_fragsize) {
alsaplayer_error("invalid fragment size");
return 1;
}
if (use_fragsize > 32768) {
alsaplayer_error("fragment size (%d) out of range (0-32768)", use_fragsize);
return 1;
}
break;
case 'F':
use_freq = atoi(optarg);
if (use_freq < 8000 || use_freq > 48000) {
alsaplayer_error("frequency (%d) out of range (8000-48000)", use_freq);
return 1;
}
break;
case 'g':
use_fragcount = atoi(optarg);
if (use_fragcount < 2 || use_fragcount > 128) {
alsaplayer_error("fragcount (%d) out of range (2-128)", use_fragcount);
return 1;
}
break;
case 'h':
help();
return 0;
case 'H':
if ((sscanf(optarg, "%f", &speed_val))) {
do_remote_control = 1;
do_speed = 1;
}
break;
case 'i':
use_interface = optarg;
break;
case 'l':
start_vol = atof(optarg);
if (start_vol < 0.0 || start_vol > 1.0) {
alsaplayer_error("volume (%.3f) out of range: using 1.0", start_vol);
start_vol = 1.0;
}
break;
case 'L':
do_remote_control = 1;
do_loopsong = 1;
use_loopsong = optarg;
break;
case 'Y':
do_remote_control = 1;
do_setvol = 1;
use_vol = atof(optarg);
if (use_vol < 0.0 || use_vol > 1.0) {
alsaplayer_error("volume (%.3f) out of range: using 1.0", use_vol);
use_vol = 1.0;
}
break;
case 'n':
use_session = atoi(optarg);
break;
case 'N':
do_save = 0;
break;
case 'O':
do_remote_control = 1;
do_pause = 1;
break;
case 'p':
global_pluginroot = optarg;
break;
case 'q':
global_quiet = 1;
break;
case 'r':
do_realtime = 1;
break;
case 's':
if (strlen(optarg) < 32) {
global_session_name = strdup(optarg);
} else {
alsaplayer_error("max 32 char session name, ignoring");
}
break;
case 'v':
version();
return 0;
case 'V':
global_verbose = 1;
break;
case 'R':
break;
case 'P':
do_remote_control = 1;
do_looplist = 1;
use_looplist = optarg;
break;
case 'x':
do_crossfade = 1;
break;
case 'o':
use_output = optarg;
break;
case '?':
return 1;
case 'I':
global_interface_script = optarg;
break;
case 'U':
do_remote_control = 1;
do_stop = 1;
break;
case 'T':
do_remote_control = 1;
do_start = 1;
break;
case 'S':
do_remote_control = 1;
do_shuffle = 1;
break;
case 'Q':
do_remote_control = 1;
do_prev = 1;
break;
case 'M':
do_remote_control = 1;
do_next = 1;
break;
case 'J':
do_remote_control = 1;
do_jump = atoi(optarg);
break;
case 'C':
do_remote_control = 1;
do_clear = 1;
break;
case 'X':
do_remote_control = 1;
do_seek = atoi(optarg);
break;
case 'Z':
do_remote_control = 1;
do_relative = 1;
do_seek = atoi(optarg);
break;
case 't':
do_remote_control = 1;
do_onebyone = 1;
use_onebyone = optarg;
break;
case 128:
// Gtk-option which we ignore.
break;
default:
alsaplayer_error("Unknown option '%c'", opt);
break;
}
}
prefsdir = get_prefsdir();
mkdir(prefsdir, 0700); /* XXX We don't do any error checking here */
snprintf(thefile, sizeof(thefile)-21, "%s/config", prefsdir);
if (use_config)
ap_prefs = prefs_load(use_config);
else
ap_prefs = prefs_load(thefile);
if (!ap_prefs) {
alsaplayer_error("Invalid config file %s\n", use_config ? use_config : thefile);
return 1;
}
/* Initialize some settings (and populate the prefs system if needed */
if (use_fragsize < 0)
use_fragsize = prefs_get_int(ap_prefs, "main", "period_size", 4096);
if (use_fragcount < 0)
use_fragcount = prefs_get_int(ap_prefs, "main", "period_count", 8);
if (global_verbose)
puts(copyright_string);
if (!global_pluginroot) {
global_pluginroot = strdup (ADDON_DIR);
}
if (use_session == 0) {
for (; use_session < MAX_REMOTE_SESSIONS+1; use_session++) {
ap_result = ap_session_running(use_session);
if (ap_result)
break;
}
if (use_session == (MAX_REMOTE_SESSIONS+1)) {
//alsaplayer_error("No remote session found");
if (do_remote_control) {
alsaplayer_error("No active sessions");
return 1;
}
do_enqueue = 0;
} else {
//alsaplayer_error("Found session %d", use_session);
if (prefs_get_bool(ap_prefs, "main", "multiopen", 1) == 0) {
// We should not spawn another alsaplayer
//alsaplayer_error("Using session %d, not doing multiopen", use_session);
do_enqueue = 1;
do_replace = 1;
}
}
}
// Check if we're in remote control mode
if (do_remote_control) {
if (do_quit) {
ap_quit(use_session);
return 0;
} else if (do_status) {
char res[1024];
float fres;
int ires;
fprintf(stdout, "---------------- Session ----------------\n");
if (ap_get_session_name(use_session, res) && strlen(res))
fprintf(stdout, "name: %s\n", res);
if (ap_get_playlist_length(use_session, &ires))
fprintf(stdout, "playlist_length: %d\n", ires);
if (ap_get_volume(use_session, &fres))
fprintf(stdout, "volume: %.2f\n", fres);
if (ap_get_speed(use_session, &fres))
fprintf(stdout, "speed: %d%%\n", (int)(fres * 100));
fprintf(stdout, "-------------- Current Track ------------\n");
if (ap_get_artist(use_session, res) && strlen(res))
fprintf(stdout, "artist: %s\n", res);
if (ap_get_title(use_session, res) && strlen(res))
fprintf(stdout, "title: %s\n", res);
if (ap_get_album(use_session, res) && strlen(res))
fprintf(stdout, "album: %s\n", res);
if (ap_get_genre(use_session, res) && strlen(res))
fprintf(stdout, "genre: %s\n", res);
if (ap_get_file_path(use_session, res) && strlen(res))
fprintf(stdout, "path: %s\n", res);
if (ap_get_blocks(use_session, &ires))
fprintf(stdout, "blocks: %d\n", ires);
if (ap_get_length(use_session, &ires))
fprintf(stdout, "length: %d second%s\n", ires, (ires == 1) ? "": "s");
if (ap_get_position(use_session, &ires))
fprintf(stdout, "position: %d\n", ires);
fprintf(stdout, "-----------------------------------------\n");
return 0;
} else if (do_setvol) {
ap_set_volume(use_session, use_vol);
return 0;
} else if (do_shuffle) {
ap_shuffle_playlist(use_session);
return 0;
} else if (do_start) {
ap_play(use_session);
return 0;
} else if (do_stop) {
ap_stop(use_session);
return 0;
} else if (do_pause) {
if (ap_is_paused(use_session, &bool_val)) {
if (bool_val)
ap_unpause(use_session);
else
ap_pause(use_session);
}
return 0;
} else if (do_next) {
ap_next(use_session);
return 0;
} else if (do_prev) {
ap_prev(use_session);
return 0;
} else if (do_jump >= 0) {
ap_jump_to(use_session, do_jump);
return 0;
} else if (do_clear) {
ap_clear_playlist(use_session);
return 0;
} else if (do_relative) {
if (do_seek != 0)
ap_set_position_relative(use_session, do_seek);
return 0;
} else if (do_speed) {
if (speed_val < -10.0 || speed_val > 10.0) {
alsaplayer_error("Speed out of range, must be between -10.00 and 10.00");
return 1;
}
ap_set_speed(use_session, speed_val);
return 0;
} else if (do_seek >= 0) {
ap_set_position(use_session, do_seek);
return 0;
} else if (do_loopsong) {
if (strcasecmp(use_loopsong, "on") != 0) {
do_loopsong = false;
}
ap_set_looping(use_session, do_loopsong);
return 0;
} else if (do_onebyone) {
if (strcasecmp(use_onebyone, "on") != 0) {
do_onebyone = false;
}
ap_set_onebyone(use_session, do_onebyone);
return 0;
} else if (do_looplist) {
if (strcasecmp(use_looplist, "on") != 0) {
do_looplist = false;
}
ap_set_playlist_looping(use_session, do_looplist);
return 0;
} else
alsaplayer_error("No remote control command executed.");
}
// Check if we need to enqueue the files
if (do_enqueue) {
char queue_name[2048];
int count = 0;
int was_playing = 0;
int playlist_length = 0;
count = optind;
ap_result = 1;
if (do_replace && count < argc) {
ap_is_playing(use_session, &was_playing);
if (was_playing) {
ap_stop(use_session);
}
ap_clear_playlist(use_session);
} else {
ap_get_playlist_length(use_session, &playlist_length);
if (!playlist_length) { // Empty list so fire up after add
was_playing = 1;
}
}
while (count < argc && ap_result) {
if (is_playlist(argv[count])) {
ap_add_playlist(use_session, argv[count]);
count++;
continue;
}
if (argv[count][0] != '/' &&
strncmp(argv[count], "http://", 7) != 0 &&
strncmp(argv[count], "ftp://", 6) != 0) {
// Not absolute so append cwd
if (getcwd(queue_name, 1024) == NULL) {
alsaplayer_error("error getting cwd");
return 1;
}
ap_strlcat(queue_name, "/", sizeof(queue_name));
ap_strlcat(queue_name, argv[count], sizeof(queue_name));
} else
ap_strlcpy(queue_name, argv[count], sizeof(queue_name));
count++;
//alsaplayer_error("Adding %s", queue_name);
ap_result = ap_add_path(use_session, queue_name);
//alsaplayer_error("ap_result = %d", ap_result);
}
if (was_playing)
ap_jump_to(use_session, 1);
if (ap_result)
return 0;
}
AlsaNode *node;
// Check if we want jack
if (strcmp(argv[0], "jackplayer") == 0) {
use_output = "jack";
}
// Check the output option
if (use_output == NULL) {
use_output = prefs_get_string(ap_prefs, "main",
"default_output", "alsa");
}
// Else do the usual plugin based thing
node = new AlsaNode(use_output, device_param, do_realtime);
if (!node->RegisterPlugin(use_output)) {
alsaplayer_error("Failed to load output plugin \"%s\". Trying defaults.", use_output);
if (!node->RegisterPlugin())
return 1;
}
int output_is_ok = 0;
int output_alternate = 0;
do {
if (!node || !node->ReadyToRun()) {
alsaplayer_error
("failed to load output plugin (%s). exitting...",
use_output ? use_output: "alsa,etc.");
return 1;
}
if (!node->SetSamplingRate(use_freq) ||
!node->SetStreamBuffers(use_fragsize, use_fragcount, 2)) {
alsaplayer_error
("failed to configure output device...trying OSS");
/* Special case for OSS, since it's easiest to get going, so try it */
if (!output_alternate) {
output_alternate = 1;
node->RegisterPlugin("oss");
continue;
} else {
return 1;
}
}
output_is_ok = 1; /* output device initialized */
} while (!output_is_ok);
// Initialise reader
reader_init ();
// Initialise playlist - must be done before things try to register with it
playlist = new Playlist(node);
if (!prefs_get_bool(ap_prefs, "main", "play_on_start", false))
playlist->Pause();
else
playlist->UnPause();
if (!playlist) {
alsaplayer_error("Failed to create Playlist object");
return 1;
}
// Add any command line arguments to the playlist
if (optind < argc) {
std::vector < std::string > newitems;
while (optind < argc) {
if (is_playlist(argv[optind])) {
if (global_verbose)
alsaplayer_error("Loading playlist (%s)", argv[optind]);
playlist->Load(std::string(argv[optind++]),
playlist->Length(), false);
} else {
newitems.push_back(std::string(argv[optind++]));
}
}
playlist->Insert(newitems, playlist->Length());
} else {
prefsdir = get_prefsdir();
snprintf(thefile, sizeof(thefile)-28, "%s/alsaplayer.m3u", prefsdir);
playlist->Load(thefile, playlist->Length(), false);
}
// Loop song
if (do_loopsong) {
playlist->LoopSong();
}
// Loop Playlist
if (do_looplist) {
playlist->LoopPlaylist();
}
// Play songs one by one
if (do_onebyone) {
playlist->SetOneByOne();
}
// Cross fading
if (do_crossfade) {
playlist->Crossfade();
}
// Set start volume
playlist->GetCorePlayer()->SetVolume(start_vol);
interface_plugin_info_type interface_plugin_info;
interface_plugin *ui;
if (get_interface_from_argv0 (argv[0], str))
use_interface = str;
if (use_interface && *use_interface) {
if (!(interface_plugin_info = load_interface(use_interface))) {
alsaplayer_error("Failed to load interface %s\n", use_interface);
goto _fatal_err;
}
} else {
const char *interface = prefs_get_string
(ap_prefs, "main", "default_interface", "gtk2");
// if we're trying to use the old gtk-1 interface, use gtk-2 instead
if (strcmp (interface, "gtk") == 0)
interface = "gtk2";
// if we're trying to use the gtk interface, but we have no
// $DISPLAY, use the text interface instead
if (strcmp (interface, "gtk2") == 0 && !getenv("DISPLAY"))
interface = "text";
if (!(interface_plugin_info = load_interface(interface))) {
if (!(interface_plugin_info = load_interface(prefs_get_string
(ap_prefs, "main", "fallback_interface", "text")))) {
alsaplayer_error("Failed to load text interface. This is bad (%s,%s,%s)",
interface, interface,
global_pluginroot);
goto _fatal_err;
}
}
}
if (interface_plugin_info) {
ui = interface_plugin_info();
if (global_verbose)
printf("Interface plugin: %s\n", ui->name);
if (!ui->init()) {
alsaplayer_error("Failed to load interface plugin. Should fall back to text\n");
} else {
control_socket_start(playlist, ui);
ui->start(playlist, argc, argv);
ui->close();
// Unfortunately gtk+ is a pig when it comes to
// cleaning up its resources; it doesn't!
// so we can never safely dlclose gtk+ based
// user interfaces, bah!
//dlclose(ui->handle);
control_socket_stop();
}
}
// Save playlist before exit
prefsdir = get_prefsdir();
snprintf(thefile, sizeof(thefile)-25, "%s/alsaplayer", prefsdir);
playlist->Save(thefile, PL_FORMAT_M3U);
// Save preferences
if (ap_prefs && do_save) {
if (prefs_save(ap_prefs) < 0) {
alsaplayer_error("failed to save preferences.");
}
}
_fatal_err:
delete playlist;
//delete p;
delete node;
if (global_session_name)
free(global_session_name);
return 0;
}
