Desktop

Back to the revision list Download file Permalink

/* $Id: player.c,v 1.1 2006/11/20 23:31:06 khorben Exp $ */

#include <sys/wait.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include "callbacks.h"

#include "player.h"

/* types */

struct _menu

{

char * name;

GtkSignalFunc callback;

char * stock;

};

struct _menubar

{

char * name;

struct _menu * menu;

};

/* constants */

struct _menu _menu_file[] =

{

{ "_Open", G_CALLBACK(on_file_open), GTK_STOCK_OPEN },

{ "", NULL, NULL },

{ "_Close", G_CALLBACK(on_file_close), GTK_STOCK_CLOSE },

{ NULL, NULL, NULL }

};

struct _menu _menu_edit[] =

{

{ "_Preferences", G_CALLBACK(on_edit_preferences),

GTK_STOCK_PREFERENCES },

{ NULL, NULL, NULL }

};

struct _menu _menu_view[] =

{

{ "_Fullscreen", G_CALLBACK(on_view_fullscreen), GTK_STOCK_FULLSCREEN },

{ NULL, NULL, NULL }

};

static struct _menu _menu_help[] =

{

#if GTK_CHECK_VERSION(2, 6, 0)

{ "_About", G_CALLBACK(on_help_about), GTK_STOCK_ABOUT },

#else

{ "_About", G_CALLBACK(on_help_about), NULL },

#endif

{ NULL, NULL, NULL }

};

static struct _menubar _menubar[] =

{

{ "_File", _menu_file },

{ "_Edit", _menu_edit },

{ "_View", _menu_view },

{ "_Help", _menu_help },

{ NULL, NULL }

};

/* Player */

static int _player_error(char const * message, int ret);

static GtkWidget * _new_menubar(Player * player);

static void _new_mplayer(Player * player);

Player * player_new(void)

{

Player * player;

GtkWidget * vbox;

GtkWidget * tb_menubar;

GtkWidget * toolbar;

GtkRequisition req;

unsigned long black;

if((player = malloc(sizeof(*player))) == NULL)

return NULL;

player->filename = NULL;

player->atstart = 0;

player->pid = -1;

player->window = NULL;

if(pipe(player->fd) != 0)

{

player_error(player, strerror(errno), 0);

free(player);

return NULL;

}

player->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_default_size(GTK_WINDOW(player->window), 300, 300);

gtk_window_set_title(GTK_WINDOW(player->window), "Player");

gtk_widget_realize(player->window);

g_signal_connect(G_OBJECT(player->window), "configure_event",

G_CALLBACK(on_player_configure), player);

g_signal_connect(G_OBJECT(player->window), "delete_event", G_CALLBACK(

on_player_closex), player);

vbox = gtk_vbox_new(FALSE, 0);

gtk_container_add(GTK_CONTAINER(player->window), vbox);

tb_menubar = _new_menubar(player);

gtk_box_pack_start(GTK_BOX(vbox), tb_menubar, FALSE, FALSE, 0);

/* statusbar */

player->statusbar = gtk_statusbar_new();

player->statusbar_id = 0;

gtk_box_pack_end(GTK_BOX(vbox), player->statusbar, FALSE, FALSE, 0);

/* toolbar */

toolbar = gtk_toolbar_new();

gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

player->tb_previous = gtk_tool_button_new_from_stock(

GTK_STOCK_MEDIA_PREVIOUS);

g_signal_connect(player->tb_previous, "clicked", G_CALLBACK(

on_previous), player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_previous, -1);

player->tb_rewind = gtk_tool_button_new_from_stock(

GTK_STOCK_MEDIA_REWIND);

g_signal_connect(player->tb_rewind, "clicked", G_CALLBACK(

on_rewind), player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_rewind, -1);

player->tb_play = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);

g_signal_connect(player->tb_play, "clicked", G_CALLBACK(on_play),

player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_play, -1);

player->tb_pause = gtk_tool_button_new_from_stock(

GTK_STOCK_MEDIA_PAUSE);

g_signal_connect(player->tb_pause, "clicked", G_CALLBACK(on_pause),

player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_pause, -1);

player->tb_stop = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_STOP);

g_signal_connect(player->tb_stop, "clicked", G_CALLBACK(on_stop),

player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_stop, -1);

player->tb_forward = gtk_tool_button_new_from_stock(

GTK_STOCK_MEDIA_FORWARD);

g_signal_connect(player->tb_forward, "clicked", G_CALLBACK(

on_forward), player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_forward, -1);

player->tb_next = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_NEXT);

g_signal_connect(player->tb_next, "clicked", G_CALLBACK(

on_next), player);

gtk_toolbar_insert(GTK_TOOLBAR(toolbar), player->tb_next, -1);

gtk_box_pack_end(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);

gtk_widget_show_all(player->window);

/* view */

player->view_iheight = 0;

gtk_widget_size_request(tb_menubar, &req);

player->view_yoffset = req.height;

player->view_iheight+=req.height;

gtk_widget_size_request(toolbar, &req);

player->view_iheight+=req.height;

gtk_widget_size_request(player->statusbar, &req);

player->view_iheight+=req.height;

black = BlackPixel(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()));

player->view_window = XCreateSimpleWindow(GDK_DISPLAY(),

GDK_WINDOW_XWINDOW(player->window->window), 0,

player->view_yoffset, 400, 300 - player->view_iheight,

0, 0, black);

XMapWindow(GDK_DISPLAY(), player->view_window);

/* mplayer */

_new_mplayer(player);

return player;

}

static int _player_error(char const * message, int ret)

{

fprintf(stderr, "%s", "Player: ");

perror(message);

return ret;

}

static GtkWidget * _new_menubar(Player * player)

{

GtkWidget * tb_menubar;

GtkWidget * menu;

GtkWidget * menubar;

GtkWidget * menuitem;

unsigned int i;

unsigned int j;

struct _menu * p;

tb_menubar = gtk_menu_bar_new();

for(i = 0; _menubar[i].name != NULL; i++)

{

menubar = gtk_menu_item_new_with_mnemonic(_menubar[i].name);

menu = gtk_menu_new();

for(j = 0; _menubar[i].menu[j].name != NULL; j++)

{

p = &_menubar[i].menu[j];

if(p->name[0] == '\0')

menuitem = gtk_separator_menu_item_new();

else if(p->stock == NULL)

menuitem = gtk_menu_item_new_with_mnemonic(

p->name);

else

menuitem = gtk_image_menu_item_new_from_stock(

p->stock, NULL);

if(p->callback != NULL)

g_signal_connect(G_OBJECT(menuitem), "activate",

G_CALLBACK(p->callback),

player);

else

gtk_widget_set_sensitive(menuitem, FALSE);

gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

}

gtk_menu_item_set_submenu(GTK_MENU_ITEM(menubar), menu);

gtk_menu_bar_append(GTK_MENU_BAR(tb_menubar), menubar);

}

return tb_menubar;

}

void _player_command(Player * player, char const * cmd, size_t cmd_len);

static void _new_mplayer(Player * player)

{

char buf[] = "pausing loadfile splash.png 0\nframe_step\n";

if((player->pid = fork()) == -1)

{

player_error(player, strerror(errno), 0);

return;

}

if(player->pid == 0)

{

close(0);

if(dup2(player->fd[0], 0) == -1)

exit(_player_error("dup2", 2));

snprintf(buf, sizeof(buf), "%u", player->view_window);

execlp("mplayer", "mplayer", "-slave", "-wid", buf,

"-quiet", "-idle", NULL);

exit(_player_error("mplayer", 2));

}

_player_command(player, buf, strlen(buf));

}

void player_delete(Player * player)

{

char cmd[] = "quit\n";

_player_command(player, cmd, sizeof(cmd)-1);

free(player);

}

/* private */

void _player_command(Player * player, char const * cmd, size_t cmd_len)

{

if(player->pid == -1)

{

fprintf(stderr, "%s", "Player: mplayer not running\n");

return;

}

player->atstart = 0;

#ifdef DEBUG

fprintf(stderr, "%s%d%s%s\n", "Player: mplayer ", player->pid,

": Sending command:\n", cmd);

#endif

if(write(player->fd[1], cmd, cmd_len) != cmd_len)

_player_error("write", 0);

}

/* useful */

int player_error(Player * player, char const * message, int ret)

{

GtkWidget * dialog;

dialog = gtk_message_dialog_new(GTK_WINDOW(player->window),

GTK_DIALOG_DESTROY_WITH_PARENT,

GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", message);

gtk_window_set_title(GTK_WINDOW(dialog), "Error");

g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(

gtk_widget_destroy), NULL);

gtk_dialog_run(GTK_DIALOG(dialog));

return ret;

}

int player_sigchld(Player * player)

{

pid_t pid;

int status;

if(player->pid == -1)

return 1;

if((pid = waitpid(player->pid, &status, WNOHANG)) == -1)

return player_error(player, "waitpid", 1);

if(pid == 0)

return 1;

fprintf(stderr, "%s", "Player: mplayer ");

if(WIFEXITED(status))

fprintf(stderr, "%d%s%u\n", pid, ": exited with code ",

WEXITSTATUS(status));

else

fprintf(stderr, "%d%s", pid, ": Unknown state\n");

player->pid = -1;

return 0;

}

/* playlist management */

void player_next(Player * player)

{

char cmd[] = "pt_step 1\n";

_player_command(player, cmd, sizeof(cmd)-1);

}

void player_previous(Player * player)

{

char cmd[] = "pt_step -1\n";

_player_command(player, cmd, sizeof(cmd)-1);

}

void player_open(Player * player, char const * filename)

{

char buf[512];

size_t len;

if(player->filename != NULL)

free(player->filename);

if((player->filename = strdup(filename)) == NULL)

{

player_error(player, strerror(errno), 0);

return;

}

snprintf(buf, sizeof(buf), "%s%s", "Player - ", filename);

gtk_window_set_title(GTK_WINDOW(player->window), buf);

len = snprintf(buf, sizeof(buf), "%s%s%s", "pausing loadfile \"",

player->filename, "\" 0\nframe_step\n");

if(len >= sizeof(buf))

fprintf(stderr, "%s", "Player: String too long\n");

else

{

_player_command(player, buf, len);

player->atstart = 1;

}

void player_open_dialog(Player * player)

{

GtkWidget * dialog;

char * filename = NULL;

dialog = gtk_file_chooser_dialog_new("Open file...",

GTK_WINDOW(player->window),

GTK_FILE_CHOOSER_ACTION_OPEN,

GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);

if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)

filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(

dialog));

gtk_widget_destroy(dialog);

if(filename == NULL)

return;

player_open(player, filename);

g_free(filename);

}

void player_queue_add(Player * player, char const * filename)

{

char cmd[512];

size_t len;

len = snprintf(cmd, sizeof(cmd), "%s%s%s", "loadfile \"", filename,

"\" 1\n");

if(len >= sizeof(cmd))

fprintf(stderr, "%s", "Player: String too long\n");

else

_player_command(player, cmd, len);

}

void player_play(Player * player)

{

char cmd[512];

size_t len;

if(player->filename == NULL)

return;

if(player->atstart)

len = snprintf(cmd, sizeof(cmd), "pause\n");

else

/* FIXME escape double quotes in filename? */

len = snprintf(cmd, sizeof(cmd), "%s%s%s", "loadfile \"",

player->filename, "\" 0\n");

if(len >= sizeof(cmd))

fprintf(stderr, "%s", "Player: String too long\n");

else

_player_command(player, cmd, len);

}

void player_pause(Player * player)

{

char cmd[] = "pause\n";

_player_command(player, cmd, sizeof(cmd)-1);

}

void player_stop(Player * player)

{

char cmd[] = "pausing loadfile splash.png 0\nframe_step\n";

_player_command(player, cmd, sizeof(cmd)-1);

}

void player_rewind(Player * player)

{

char cmd[] = "speed_incr -0.5\n";

_player_command(player, cmd, sizeof(cmd)-1);

}

void player_forward(Player * player)

{

char cmd[] = "speed_incr 0.5\n";

_player_command(player, cmd, sizeof(cmd)-1);

}