int
main (int argc, char **argv)
{
GstPlay *play;
GPtrArray *playlist;
gboolean verbose = FALSE;
gboolean print_version = FALSE;
gboolean interactive = TRUE;
gboolean gapless = FALSE;
gboolean shuffle = FALSE;
gdouble volume = -1;
gchar **filenames = NULL;
gchar *audio_sink = NULL;
gchar *video_sink = NULL;
gchar **uris;
gchar *flags = NULL;
guint num, i;
GError *err = NULL;
GOptionContext *ctx;
gchar *playlist_file = NULL;
GOptionEntry options[] = {
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
N_("Output status information and property notifications"), NULL},
{"flags", 0, 0, G_OPTION_ARG_STRING, &flags,
N_("Control playback behaviour setting playbin 'flags' property"),
NULL},
{"version", 0, 0, G_OPTION_ARG_NONE, &print_version,
N_("Print version information and exit"), NULL},
{"videosink", 0, 0, G_OPTION_ARG_STRING, &video_sink,
N_("Video sink to use (default is autovideosink)"), NULL},
{"audiosink", 0, 0, G_OPTION_ARG_STRING, &audio_sink,
N_("Audio sink to use (default is autoaudiosink)"), NULL},
{"gapless", 0, 0, G_OPTION_ARG_NONE, &gapless,
N_("Enable gapless playback"), NULL},
{"shuffle", 0, 0, G_OPTION_ARG_NONE, &shuffle,
N_("Shuffle playlist"), NULL},
{"no-interactive", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE,
&interactive,
N_("Disable interactive control via the keyboard"), NULL},
{"volume", 0, 0, G_OPTION_ARG_DOUBLE, &volume,
N_("Volume"), NULL},
{"playlist", 0, 0, G_OPTION_ARG_FILENAME, &playlist_file,
N_("Playlist file containing input media files"), NULL},
{"quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet,
N_("Do not print any output (apart from errors)"), NULL},
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
{NULL}
};
setlocale (LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
g_set_prgname ("gst-play-" GST_API_VERSION);
ctx = g_option_context_new ("FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ...");
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
g_option_context_free (ctx);
g_clear_error (&err);
return 1;
}
g_option_context_free (ctx);
GST_DEBUG_CATEGORY_INIT (play_debug, "play", 0, "gst-play");
if (print_version) {
gchar *version_str;
version_str = gst_version_string ();
g_print ("%s version %s\n", g_get_prgname (), PACKAGE_VERSION);
g_print ("%s\n", version_str);
g_print ("%s\n", GST_PACKAGE_ORIGIN);
g_free (version_str);
g_free (audio_sink);
g_free (video_sink);
g_free (playlist_file);
return 0;
}
playlist = g_ptr_array_new ();
if (playlist_file != NULL) {
gchar *playlist_contents = NULL;
gchar **lines = NULL;
if (g_file_get_contents (playlist_file, &playlist_contents, NULL, &err)) {
lines = g_strsplit (playlist_contents, "\n", 0);
num = g_strv_length (lines);
for (i = 0; i < num; i++) {
if (lines[i][0] != '\0') {
GST_LOG ("Playlist[%d]: %s", i + 1, lines[i]);
add_to_playlist (playlist, lines[i]);
}
}
g_strfreev (lines);
g_free (playlist_contents);
} else {
g_printerr ("Could not read playlist: %s\n", err->message);
g_clear_error (&err);
}
g_free (playlist_file);
playlist_file = NULL;
}
if (playlist->len == 0 && (filenames == NULL || *filenames == NULL)) {
g_printerr (_("Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."),
"gst-play-" GST_API_VERSION);
g_printerr ("\n\n"),
g_printerr ("%s\n\n",
_("You must provide at least one filename or URI to play."));
/* No input provided. Free array */
g_ptr_array_free (playlist, TRUE);
g_free (audio_sink);
g_free (video_sink);
return 1;
}
/* fill playlist */
if (filenames != NULL && *filenames != NULL) {
num = g_strv_length (filenames);
for (i = 0; i < num; ++i) {
GST_LOG ("command line argument: %s", filenames[i]);
add_to_playlist (playlist, filenames[i]);
}
g_strfreev (filenames);
}
num = playlist->len;
g_ptr_array_add (playlist, NULL);
uris = (gchar **) g_ptr_array_free (playlist, FALSE);
if (shuffle)
shuffle_uris (uris, num);
/* prepare */
play =
play_new (uris, audio_sink, video_sink, gapless, volume, verbose, flags);
if (play == NULL) {
g_printerr
("Failed to create 'playbin' element. Check your GStreamer installation.\n");
return EXIT_FAILURE;
}
if (interactive) {
if (gst_play_kb_set_key_handler (keyboard_cb, play)) {
g_print (_("Press 'k' to see a list of keyboard shortcuts.\n"));
atexit (restore_terminal);
} else {
g_print ("Interactive keyboard handling in terminal not available.\n");
}
}
/* play */
do_play (play);
/* clean up */
play_free (play);
g_free (audio_sink);
g_free (video_sink);
g_print ("\n");
gst_deinit ();
return 0;
}
int
main (int argc, char **argv)
{
GstPlay *play;
GPtrArray *playlist;
gboolean print_version = FALSE;
gboolean interactive = FALSE; /* FIXME: maybe enable by default? */
gboolean shuffle = FALSE;
gdouble volume = 1.0;
gchar **filenames = NULL;
gchar **uris;
guint num, i;
GError *err = NULL;
GOptionContext *ctx;
gchar *playlist_file = NULL;
GOptionEntry options[] = {
{"version", 0, 0, G_OPTION_ARG_NONE, &print_version,
"Print version information and exit", NULL},
{"shuffle", 0, 0, G_OPTION_ARG_NONE, &shuffle,
"Shuffle playlist", NULL},
{"interactive", 0, 0, G_OPTION_ARG_NONE, &interactive,
"Interactive control via keyboard", NULL},
{"volume", 0, 0, G_OPTION_ARG_DOUBLE, &volume,
"Volume", NULL},
{"playlist", 0, 0, G_OPTION_ARG_FILENAME, &playlist_file,
"Playlist file containing input media files", NULL},
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
{NULL}
};
g_set_prgname ("gst-play");
ctx = g_option_context_new ("FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ...");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
return 1;
}
g_option_context_free (ctx);
GST_DEBUG_CATEGORY_INIT (play_debug, "play", 0, "gst-play");
if (print_version) {
gchar *version_str;
version_str = gst_version_string ();
g_print ("%s version %s\n", g_get_prgname (), "1.0");
g_print ("%s\n", version_str);
g_free (version_str);
g_free (playlist_file);
return 0;
}
playlist = g_ptr_array_new ();
if (playlist_file != NULL) {
gchar *playlist_contents = NULL;
gchar **lines = NULL;
if (g_file_get_contents (playlist_file, &playlist_contents, NULL, &err)) {
lines = g_strsplit (playlist_contents, "\n", 0);
num = g_strv_length (lines);
for (i = 0; i < num; i++) {
if (lines[i][0] != '\0') {
GST_LOG ("Playlist[%d]: %s", i + 1, lines[i]);
add_to_playlist (playlist, lines[i]);
}
}
g_strfreev (lines);
g_free (playlist_contents);
} else {
g_printerr ("Could not read playlist: %s\n", err->message);
g_clear_error (&err);
}
g_free (playlist_file);
playlist_file = NULL;
}
if (playlist->len == 0 && (filenames == NULL || *filenames == NULL)) {
g_printerr ("Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ...",
"gst-play");
g_printerr ("\n\n"),
g_printerr ("%s\n\n",
"You must provide at least one filename or URI to play.");
/* No input provided. Free array */
g_ptr_array_free (playlist, TRUE);
return 1;
}
/* fill playlist */
if (filenames != NULL && *filenames != NULL) {
num = g_strv_length (filenames);
for (i = 0; i < num; ++i) {
GST_LOG ("command line argument: %s", filenames[i]);
add_to_playlist (playlist, filenames[i]);
}
g_strfreev (filenames);
}
num = playlist->len;
g_ptr_array_add (playlist, NULL);
uris = (gchar **) g_ptr_array_free (playlist, FALSE);
if (shuffle)
shuffle_uris (uris, num);
/* prepare */
play = play_new (uris, volume);
if (interactive) {
if (gst_play_kb_set_key_handler (keyboard_cb, play)) {
atexit (restore_terminal);
} else {
g_print ("Interactive keyboard handling in terminal not available.\n");
}
}
/* play */
do_play (play);
/* clean up */
play_free (play);
g_print ("\n");
return 0;
}
/**
* @brief Loop event.
* @param ui user interface.
*/
void ui_loop_edax(UI *ui)
{
char *cmd = NULL, *param = NULL;
Play *play = ui->play;
char book_file[FILENAME_MAX];
unsigned long long histogram[129][65];
int repeat = options.repeat;
histogram_init(histogram);
// loop forever
for (;;) {
errno = 0;
if (options.verbosity) {
putchar('\n');
play_print(play, stdout);
if (play_is_game_over(play)) printf("\n*** Game Over ***\n");
putchar('\n');
}
if (log_is_open(edax_log)) {
putc('\n', edax_log->f);
play_print(play, edax_log->f);
if (play_is_game_over(play)) fputs("\n*** Game Over ***\n", edax_log->f);
putc('\n', edax_log->f);
}
// edax turn ? (automatic play mode)
if (!ui_event_exist(ui) && !play_is_game_over(play) && (ui->mode == !play->player || ui->mode == 2)) {
putchar('\n');
play_go(play, true);
printf("\nEdax plays "); move_print(play_get_last_move(play)->x, 0, stdout); putchar('\n');
if (ui->mode != 2) play_ponder(play);
// proceed by reading a command
} else {
/* automatic rules after a game over*/
if (play_is_game_over(play)) {
if (options.auto_store) play_store(play);
if (options.auto_swap && ui->mode < 2) ui->mode = !ui->mode;
if (options.repeat && repeat > 1) {
--repeat;
play_new(play);
continue;
}
if (options.auto_quit) {
return;
}
if (options.auto_start) {
play_new(play);
continue;
}
}
putchar('>'); fflush(stdout);
ui_event_wait(ui, &cmd, ¶m);
log_print(edax_log, "cmd=\"%s\" ; param=\"%s\"\n", cmd, param);
putchar('\n');
if (cmd == NULL) {
warn("unexpected null command?\n");
continue;
}
// skip empty lines or commented lines
if (*cmd == '\0' || *cmd == '#') {
// help
} else if (strcmp(cmd, "help") == 0 || strcmp(cmd, "?") == 0) {
if (*param == '\0' || strcmp(param, "options") == 0) help_options();
if (*param == '\0' || strcmp(param, "commands") == 0) help_commands();
if (*param == '\0' || strcmp(param, "book") == 0) help_book();
if (*param == '\0' || strcmp(param, "base") == 0) help_base();
if (*param == '\0' || strcmp(param, "test") == 0) help_test();
// new game from standard position
} else if (strcmp(cmd, "i") == 0 || strcmp(cmd, "init") == 0) {
board_init(play->initial_board);
play_new(play);
// new game from personnalized position
} else if ((strcmp(cmd, "n") == 0 || strcmp(cmd, "new") == 0) && *param == '\0') {
play_new(play);
// open a saved game
} else if (strcmp(cmd, "o") == 0 || strcmp(cmd, "open") == 0 || strcmp(cmd, "load") == 0) {
play_load(play, param);
// save a game
} else if (strcmp(cmd, "s") == 0 || strcmp(cmd, "save") == 0) {
play_save(play, param);
// quit
} else if (strcmp(cmd, "quit") == 0 || strcmp(cmd, "q") == 0 || strcmp(cmd, "exit") == 0) {
free(cmd); free(param);
return;
} else if (!options.auto_quit && (strcmp(cmd, "eof") == 0 && (ui->mode != 2 || play_is_game_over(play)))){
free(cmd); free(param);
return;
// undo last move
} else if (strcmp(cmd, "u") == 0 || strcmp(cmd, "undo") == 0) {
play_undo(play);
if (ui->mode == 0 || ui->mode == 1) play_undo(play);
// redo last move
} else if (strcmp(cmd, "r") == 0 || strcmp(cmd, "redo") == 0) {
play_redo(play);
if (ui->mode == 0 || ui->mode == 1) play_undo(play);
// mode
} else if (strcmp(cmd, "m") == 0 || strcmp(cmd, "mode") == 0) {
ui->mode = string_to_int(param, 3);
// analyze a game
} else if (strcmp(cmd, "a") == 0 || strcmp(cmd, "analyze") == 0 || strcmp(cmd, "analyse") == 0) {
play_analyze(play, string_to_int(param, play->n_game));
// set a new initial position
} else if (strcmp(cmd, "setboard") == 0) {
play_set_board(play, param);
// vertical mirror
} else if (strcmp(cmd, "vmirror") == 0) {
play_symetry(play, 2);
// horizontal mirror
} else if (strcmp(cmd, "hmirror") == 0) {
play_symetry(play, 1);
// rotate
} else if (strcmp(cmd, "rotate") == 0) {
int angle = string_to_int(param, 90) % 360;
if (angle < 0) angle += 360;
switch (angle) {
case 90:
play_symetry(play, 5);
break;
case 180:
play_symetry(play, 3);
break;
case 270:
play_symetry(play, 6);
break;
default:
warn("Rotate angle should be 90°, 180° or 270°");
break;
}
// direct symetry...
} else if (strcmp(cmd, "symetry") == 0) {
int sym = string_to_int(param, 1);
if (sym < 0 || sym >= 16) warn("symetry parameter should be a number between 0 and 15\n");
else {
if (sym & 8) play->player ^= 1;
play_symetry(play, sym & 7);
}
// play a serie of moves
} else if (strcmp(cmd, "play") == 0) {
string_to_lowercase(param);
play_game(play, param);
// force edax to play an opening
} else if (strcmp(cmd, "force") == 0) {
string_to_lowercase(param);
play_force_init(play, param);
// solve a set of problems
} else if (strcmp(cmd, "solve") == 0) {
char problem_file[FILENAME_MAX + 1], *hard_file;
hard_file = parse_word(param, problem_file, FILENAME_MAX);
parse_word(hard_file, hard_file, FILENAME_MAX);
obf_test(play->search, problem_file, hard_file);
search_set_observer(play->search, edax_observer);
// convert a set of problems in a .script file to a .obf file
} else if (strcmp(cmd, "script-to-obf") == 0) {
char script_file[FILENAME_MAX + 1], *obf_file;
obf_file = parse_word(param, script_file, FILENAME_MAX);
parse_word(obf_file, obf_file, FILENAME_MAX);
script_to_obf(play->search, script_file, obf_file);
search_set_observer(play->search, edax_observer);
} else if (strcmp(cmd, "select-hard") == 0) {
char full_file[FILENAME_MAX + 1], *hard_file;
hard_file = parse_word(param, full_file, FILENAME_MAX);
parse_word(hard_file, hard_file, FILENAME_MAX);
obf_filter(full_file, hard_file);
// game/position enumeration
} else if (strcmp(cmd, "count") == 0) {
char count_cmd[16], *count_param;
int depth = 10, size = 8;
count_param = parse_word(param, count_cmd, 15);
count_param = parse_int(count_param, &depth); BOUND(depth, 1, 90, "max-ply");
if (count_param) parse_int(count_param, &size); BOUND(size, 6, 8, "board-size");
if (strcmp(count_cmd, "games") == 0) { // game enumeration
quick_count_games(play->board, depth, size);
} else if (strcmp(count_cmd, "positions") == 0) { // position enumeration
count_positions(play->board, depth, size);
} else if (strcmp(count_cmd, "shapes") == 0) { // shape enumeration
count_shapes(play->board, depth, size);
} else {
warn("Unknown count command: \"%s %s\"\n", cmd, param);
}
} else if (strcmp(cmd, "perft") == 0) {
int depth = 14;
depth = string_to_int(param, 10); BOUND(depth, 1, 90, "max-ply");
count_games(play->board, depth);
// game/position enumeration
} else if (strcmp(cmd, "estimate") == 0) {
int n = 1000;
n = string_to_int(param, 10); BOUND(n, 1, 2000000000, "max-trials");
estimate_games(play->board, n);
// seek highest mobility
} else if (strcmp(cmd, "mobility") == 0) {
int t = 3600; // 1 hour
t = string_to_int(param, 10); BOUND(t, 1, 3600*24*365*10, "max time");
seek_highest_mobility(play->board, t);
// seek a position
} else if (strcmp(cmd, "seek") == 0) {
Board target;
Line solution;
board_set(&target, param);
line_init(&solution, play->player);
if (seek_position(&target, play->board, &solution)) {
printf("Solution found:\n");
line_print(&solution, 200, " ", stdout);
putchar('\n');
}
// bench (a serie of low level tests).
} else if (strcmp(cmd, "bench") == 0) {
bench();
// wtest test the engine against wthor theoretical scores
} else if (strcmp(cmd, "wtest") == 0) {
wthor_test(param, play->search);
// make wthor games played by "Edax (Delorme)" as "Etudes" tournament.
} else if (strcmp(cmd, "edaxify") == 0) {
wthor_edaxify(param);
// wtest test the engine against wthor theoretical scores
} else if (strcmp(cmd, "weval") == 0) {
wthor_eval(param, play->search, histogram);
histogram_print(histogram);
histogram_stats(histogram);
histogram_to_ppm("weval.ppm", histogram);
// go think!
} else if (strcmp(cmd, "go") == 0) {
if (play_is_game_over(play)) printf("\n*** Game Over ***\n");
else {
play_go(play, true);
printf("\nEdax plays "); move_print(play_get_last_move(play)->x, 0, stdout); putchar('\n');
}
// hint for [n] moves
} else if (strcmp(cmd, "hint") == 0) {
int n = string_to_int(param, 1); BOUND(n, 1, 60, "n_moves");
play_hint(play, n);
// stop thinking
} else if (strcmp(cmd, "stop") == 0) {
ui->mode = 3;
// user move
} else if (play_user_move(play, cmd)) {
printf("\nYou play "); move_print(play_get_last_move(play)->x, 0, stdout); putchar('\n');
// debug pv
} else if (strcmp(cmd, "debug-pv") == 0) {
Move move[1];
if (parse_move(param, play->board, move) != param) {
search_set_board(play->search, play->board, play->player);
pv_debug(play->search, move, stdout);
}
} else if (strcmp(cmd, "options") == 0) {
options_dump(stdout);
#ifdef __unix__
} else if (strcmp(cmd, "resources") == 0) {
struct rusage u;
long long t;
getrusage(RUSAGE_SELF, &u);
t = 1000 * u.ru_utime.tv_sec + u.ru_utime.tv_usec / 1000;
printf("user cpu time: "); time_print(t, false, stdout); printf("\n");
t = 1000 * u.ru_stime.tv_sec + u.ru_stime.tv_usec / 1000;
printf("system cpu time: "); time_print(t, false, stdout); printf("\n");
printf("max resident memory: %ld\n", u.ru_maxrss);
printf("page fault without I/O: %ld\n", u.ru_minflt);
printf("page fault with I/O: %ld\n", u.ru_majflt);
printf("number of input: %ld\n", u.ru_inblock);
printf("number of output: %ld\n", u.ru_oublock);
printf("number of voluntary context switch: %ld\n", u.ru_nvcsw);
printf("number of unvoluntary context switch: %ld\n\n", u.ru_nivcsw);
#endif
// opening name
} else if (strcmp(cmd, "opening") == 0) {
const char *name;
name = play_show_opening_name(play, opening_get_english_name);
if (name == NULL) name = "?";
puts(name);
// opening name in french
} else if (strcmp(cmd, "ouverture") == 0) {
const char *name;
name = play_show_opening_name(play, opening_get_french_name);
if (name == NULL) name = "?";
puts(name);
// opening book commands
} else if (strcmp(cmd, "book") == 0 || strcmp(cmd, "b") == 0) {
char book_cmd[FILENAME_MAX + 1], *book_param;
int val_1, val_2;
Book *book = play->book;
book->search = play->search;
book->search->options.verbosity = book->options.verbosity;
book_param = parse_word(param, book_cmd, FILENAME_MAX);
// store the last played game
if (strcmp(book_cmd, "store") == 0) {
play_store(play);
// turn book usage on
} else if (strcmp(book_cmd, "on") == 0) { // learn
options.book_allowed = true;
// turn book usage off
} else if (strcmp(book_cmd, "off") == 0) { // learn
options.book_allowed = false;
// set book randomness
} else if (strcmp(book_cmd, "randomness") == 0) { // learn
val_1 = 0; book_param = parse_int(book_param, &val_1);
options.book_randomness = val_1;
// set book depth (until which to learn)
} else if (strcmp(book_cmd, "depth") == 0) { // learn
val_1 = 36; book_param = parse_int(book_param, &val_1);
book->options.n_empties = 61 - val_1;
// create a new empty book
} else if (strcmp(book_cmd, "new") == 0) {
val_1 = 21; book_param = parse_int(book_param, &val_1);
val_2 = 36; book_param = parse_int(book_param, &val_2);
book_free(book) ;
book_new(book, val_1, 61 - val_2);
// load an opening book (binary format) from the disc
} else if (strcmp(book_cmd, "load") == 0 || strcmp(book_cmd, "open") == 0) {
book_free(book) ;
parse_word(book_param, book_file, FILENAME_MAX);
book_load(book, book_file);
// save an opening book (binary format) to the disc
} else if (strcmp(book_cmd, "save") == 0) {
parse_word(book_param, book_file, FILENAME_MAX);
book_save(book, book_file);
// import an opening book (text format)
} else if (strcmp(book_cmd, "import") == 0) {
book_free(book);
parse_word(book_param, book_file, FILENAME_MAX);
book_import(book, book_file);
book_link(book);
book_fix(book);
book_negamax(book);
book_sort(book);
// export an opening book (text format)
} else if (strcmp(book_cmd, "export") == 0) {
parse_word(book_param, book_file, FILENAME_MAX);
book_export(book, book_file);
// merge an opening book to the current one
} else if (strcmp(book_cmd, "merge") == 0) {
Book src[1];
parse_word(book_param, book_file, FILENAME_MAX);
src->search = play->search;
book_load(src, book_file);
book_merge(book, src);
book_free(src);
warn("Book needs to be fixed before usage\n");
// fix an opening book
} else if (strcmp(book_cmd, "fix") == 0) {
book_fix(book); // do nothing (or edax is buggy)
book_link(book); // links nodes
book_negamax(book); // negamax nodes
book_sort(book); // sort moves
// negamax an opening book
} else if (strcmp(book_cmd, "negamax") == 0) {
book_negamax(book); // negamax nodes
book_sort(book); // sort moves
// check and correct solved positions of the book
} else if (strcmp(book_cmd, "correct") == 0) {
book_correct_solved(book); // do nothing (or edax is buggy)
book_fix(book); // do nothing (or edax is buggy)
book_link(book); // links nodes
book_negamax(book); // negamax nodes
book_sort(book); // sort moves
// prune an opening book
} else if (strcmp(book_cmd, "prune") == 0) {
book_prune(book); // remove unreachable lines.
book_fix(book); // do nothing (or edax is buggy)
book_link(book); // links nodes
book_negamax(book); // negamax nodes
book_sort(book); // sort moves
// show the current position as stored in the book
} else if (strcmp(book_cmd, "show") == 0) {
book_show(book, play->board);
// show book general information
} else if (strcmp(book_cmd, "info") == 0) {
book_info(book);
// show book general information
} else if (strcmp(book_cmd, "stats") == 0) {
book_stats(book);
// set book verbosity
} else if (strcmp(book_cmd, "verbose") == 0) {
parse_int(book_param, &book->options.verbosity);
book->search->options.verbosity = book->options.verbosity;
// analyze a game from the opening book point of view
} else if (strcmp(book_cmd, "a") == 0 || strcmp(book_cmd, "analyze") == 0 || strcmp(book_cmd, "analyse") == 0) {
val_1 = string_to_int(book_param, play->n_game); BOUND(val_1, 1, play->n_game, "depth");
play_book_analyze(play, val_1);
// add positions from a game database
} else if (strcmp(book_cmd, "add") == 0) {
Base base[1];
parse_word(book_param, book_file, FILENAME_MAX);
base_init(base);
base_load(base, book_file);
book_add_base(book, base);
base_free(base);
// check positions from a game database
} else if (strcmp(book_cmd, "check") == 0) {
Base base[1];
parse_word(book_param, book_file, FILENAME_MAX);
base_init(base);
base_load(base, book_file);
book_check_base(book, base);
base_free(base);
// extract positions
} else if (strcmp(book_cmd, "problem") == 0) {
val_1 = 24; book_param = parse_int(book_param, &val_1); BOUND(val_1, 0, 60, "number of empties");
val_2 = 10; book_param = parse_int(book_param, &val_2); BOUND(val_2, 1, 1000000, "number of positions");
book_extract_positions(book, val_1, val_2);
// extract pv to a game database
} else if (strcmp(book_cmd, "extract") == 0) {
Base base[1];
parse_word(book_param, book_file, FILENAME_MAX);
base_init(base);
book_extract_skeleton(book, base);
base_save(base, book_file);
base_free(base);
// add position using the "deviate algorithm"
} else if (strcmp(book_cmd, "deviate") == 0) {
val_1 = 2; book_param = parse_int(book_param, &val_1); BOUND(val_1, -129, 129, "relative error");
val_2 = 4; book_param = parse_int(book_param, &val_2); BOUND(val_2, 0, 65, "absolute error");
book_deviate(book, play->board, val_1, val_2);
// add position using the "enhance algorithm"
} else if (strcmp(book_cmd, "enhance") == 0) {
val_1 = 2; book_param = parse_int(book_param, &val_1); BOUND(val_1, 0, 129, "midgame error");
val_2 = 4; book_param = parse_int(book_param, &val_2); BOUND(val_2, 0, 129, "endcut error");
book_enhance(book, play->board, val_1, val_2);
// add position by filling hole in the book
} else if (strcmp(book_cmd, "fill") == 0) {
val_1 = 1; book_param = parse_int(book_param, &val_1); BOUND(val_1, 1, 61, "fill depth");
book_fill(book, val_1);
// add positions by expanding positions with no-link
} else if (strcmp(book_cmd, "play") == 0) {
book_play(book);
// add positions by expanding positions with no-link
} else if (strcmp(book_cmd, "deepen") == 0) {
book_deepen(book);
// add book positions to the hash table
} else if (strcmp(book_cmd, "feed-hash") == 0) {
book_feed_hash(book, play->board, play->search);
// wrong command ?
} else {
warn("Unknown book command: \"%s %s\"\n", cmd, param);
}
book->options.verbosity = book->search->options.verbosity;
book->search->options.verbosity = options.verbosity;
/* base TODO: add more actions... */
} else if (strcmp(cmd, "base") == 0) {
char base_file[FILENAME_MAX + 1];
char base_cmd[512], *base_param;
Base base[1];
base_init(base);
base_param = parse_word(param, base_cmd, 511);
base_param = parse_word(base_param, base_file, FILENAME_MAX);
// extract problem from a game base
if (strcmp(base_cmd, "problem") == 0) {
char problem_file[FILENAME_MAX + 1];
int n_empties = 24;
base_param = parse_int(base_param, &n_empties);
base_param = parse_word(base_param, problem_file, FILENAME_MAX);
base_load(base, base_file);
base_to_problem(base, n_empties, problem_file);
// extract FEN
} else if (strcmp(base_cmd, "tofen") == 0) {
char problem_file[FILENAME_MAX + 1];
int n_empties = 24;
base_param = parse_int(base_param, &n_empties);
base_param = parse_word(base_param, problem_file, FILENAME_MAX);
base_load(base, base_file);
base_to_FEN(base, n_empties, problem_file);
// correct erroneous games
} else if (strcmp(base_cmd, "correct") == 0) {
int n_empties = 24;
base_param = parse_int(base_param, &n_empties);
base_load(base, base_file);
base_analyze(base, play->search, n_empties, true);
remove(base_file);
base_save(base, base_file);
// check erroneous games
} else if (strcmp(base_cmd, "check") == 0) {
int n_empties = 24;
base_param = parse_int(base_param, &n_empties);
base_load(base, base_file);
base_analyze(base, play->search, n_empties, false);
// terminate unfinished base
} else if (strcmp(base_cmd, "complete") == 0) {
base_load(base, base_file);
base_complete(base, play->search);
remove(base_file);
base_save(base, base_file);
// convert a base to another format
} else if (strcmp(base_cmd, "convert") == 0) {
base_load(base, base_file);
base_param = parse_word(base_param, base_file, FILENAME_MAX);
base_save(base, base_file);
// make a base unique by removing identical games
} else if (strcmp(base_cmd, "unique") == 0) {
base_load(base, base_file);
base_param = parse_word(base_param, base_file, FILENAME_MAX);
base_unique(base);
base_save(base, base_file);
// compare two game bases
} else if (strcmp(base_cmd, "compare") == 0) {
char base_file_2[FILENAME_MAX + 1];
base_param = parse_word(base_param, base_file_2, FILENAME_MAX);
base_compare(base_file, base_file_2);
} else {
warn("Unknown base command: \"%s %s\"\n", cmd, param);
}
base_free(base);
/* edax options */
} else if (options_read(cmd, param)) {
options_bound();
// parallel search changes:
if (search_count_tasks(play->search) != options.n_task) {
play_stop_pondering(play);
search_set_task_number(play->search, options.n_task);
}
/* switch to another protocol */
} else if (strcmp(cmd, "nboard") == 0 && strcmp(param, "1") == 0) {
free(cmd); free(param);
play_stop_pondering(play);
ui->free(ui);
ui_switch(ui, "nboard");
ui->init(ui);
ui->loop(ui);
return;
} else if (strcmp(cmd, "xboard") == 0) {
free(cmd); free(param);
play_stop_pondering(play);
ui->free(ui);
ui_switch(ui, "xboard");
ui->init(ui);
ui->loop(ui);
return;
} else if (strcmp(cmd, "engine-protocol") == 0 && strcmp(param, "init") == 0) {
free(cmd); free(param);
play_stop_pondering(play);
ui->free(ui);
ui_switch(ui, "cassio");
engine_loop();
return;
} else if (strcmp(cmd, "protocol_version") == 0) {
free(cmd); free(param);
play_stop_pondering(play);
ui->free(ui);
ui_switch(ui, "gtp");
ui->init(ui);
puts("= 2\n"); fflush(stdout);
ui->loop(ui);
return;
#ifdef TUNE_EDAX
/* edax tuning */
} else if (strcmp(cmd, "tune") == 0) {
char problem[FILENAME_MAX];
char *w_name;
play_stop_pondering(play);
w_name = parse_word(param, problem, FILENAME_MAX);
tune_move_evaluate(play->search, problem, parse_skip_spaces(w_name));
search_set_observer(play->search, edax_observer);
#endif
/* illegal cmd/move */
} else {
warn("Unknown command/Illegal move: \"%s %s\"\n", cmd, param);
}
}
}
}
/**
* @brief Loop event
* @param ui user interface
*/
void ui_loop_nboard(UI *ui)
{
char *cmd = NULL, *param = NULL;
Play *play = ui->play;
// loop forever
for (;;) {
errno = 0;
if (log_is_open(nboard_log)) {
play_print(play, nboard_log->f);
}
ui_event_wait(ui, &cmd, ¶m);
log_print(nboard_log, "received< \"%s %s\"\n", cmd, param);
if (*cmd == '\0') {
} else if (strcmp(cmd, "nboard") == 0) {
if (strcmp(param, "1") != 0) nboard_fail("Edax expected \"nboard 1\" protocol");
} else if (strcmp(cmd, "depth") == 0) {
options.level = string_to_int(param, 21);
nboard_send("set myname Edax%d", options.level);
} else if (strcmp(cmd, "game") == 0) {
Game game[1];
if (parse_ggf(game, param) != param) {
game_get_board(game, 60, play->initial_board);
play_new(play);
} else {
nboard_fail("Cannot parse game \"%s\"", param);
}
} else if (strcmp(cmd, "move") == 0) {
if (!play_user_move(play, param)) {
nboard_fail("Cannot parse move \"%s\"", param);
}
} else if (strcmp(cmd, "hint") == 0) {
nboard_send("status Edax is thinking");
play_hint(play, string_to_int(param, MAX_MOVE));
nboard_send("status Edax is waiting");
} else if (strcmp(cmd, "go") == 0) {
nboard_send("status Edax is thinking");
play_go(play, false);
nboard_send_move(play->result);
nboard_send("status Edax is waiting");
} else if (strcmp(cmd, "quit") == 0 || strcmp(cmd, "eof") == 0) {
free(cmd); free(param);
return;
} else if (strcmp(cmd, "ping") == 0) {
nboard_send("pong %s", param);
} else if (strcmp(cmd, "learn") == 0) {
nboard_send("status Edax is learning");
play_store(play);
nboard_send("status Edax is waiting");
} else if (play_user_move(play, cmd)) {
// error: unknown message
} else {
nboard_fail("unknown command \"%s\" \"%s\"", cmd, param);
}
}
}
int
main (int argc, char **argv)
{
GstPlay *play;
GPtrArray *playlist;
gboolean print_version = FALSE;
gboolean gapless = FALSE;
gchar **filenames = NULL;
gchar *audio_sink = NULL;
gchar *video_sink = NULL;
gchar **uris;
guint num, i;
GError *err = NULL;
GOptionContext *ctx;
GOptionEntry options[] = {
{"version", 0, 0, G_OPTION_ARG_NONE, &print_version,
N_("Print version information and exit"), NULL},
{"videosink", 0, 0, G_OPTION_ARG_STRING, &video_sink,
N_("Video sink to use (default is autovideosink)"), NULL},
{"audiosink", 0, 0, G_OPTION_ARG_STRING, &audio_sink,
N_("Audio sink to use (default is autoaudiosink)"), NULL},
{"gapless", 0, 0, G_OPTION_ARG_NONE, &gapless,
N_("Enable gapless playback"), NULL},
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
{NULL}
};
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
g_set_prgname ("gst-play-" GST_API_VERSION);
ctx = g_option_context_new ("FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ...");
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
return 1;
}
g_option_context_free (ctx);
GST_DEBUG_CATEGORY_INIT (play_debug, "play", 0, "gst-play");
if (print_version) {
gchar *version_str;
version_str = gst_version_string ();
g_print ("%s version %s\n", g_get_prgname (), PACKAGE_VERSION);
g_print ("%s\n", version_str);
g_print ("%s\n", GST_PACKAGE_ORIGIN);
g_free (version_str);
return 0;
}
if (filenames == NULL || *filenames == NULL) {
g_printerr (_("Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."),
"gst-play-" GST_API_VERSION);
g_printerr ("\n\n"),
g_printerr ("%s\n\n",
_("You must provide at least one filename or URI to play."));
return 1;
}
playlist = g_ptr_array_new ();
/* fill playlist */
num = g_strv_length (filenames);
for (i = 0; i < num; ++i) {
GST_LOG ("command line argument: %s", filenames[i]);
add_to_playlist (playlist, filenames[i]);
}
g_strfreev (filenames);
g_ptr_array_add (playlist, NULL);
/* play */
uris = (gchar **) g_ptr_array_free (playlist, FALSE);
play = play_new (uris, audio_sink, video_sink, gapless);
do_play (play);
/* clean up */
play_free (play);
return 0;
}
