static void
mex_telepathy_channel_create_preview (MexTelepathyChannel *self)
{
MexTelepathyChannelPrivate *priv = MEX_TELEPATHY_CHANNEL (self)->priv;
ClutterActor *video_preview_area;
priv->video_outgoing = clutter_texture_new ();
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (priv->video_outgoing),
TRUE);
priv->outgoing_sink =
clutter_gst_video_sink_new (CLUTTER_TEXTURE (priv->video_outgoing));
video_preview_area = mx_stack_new ();
clutter_container_add (CLUTTER_CONTAINER (video_preview_area),
mex_telepathy_channel_create_static_image(),
priv->video_outgoing,
NULL);
mx_stylable_set_style_class (MX_STYLABLE (video_preview_area),
"PreviewStack");
clutter_actor_set_height (video_preview_area, 150.0);
clutter_actor_add_effect (video_preview_area,
CLUTTER_EFFECT (
mex_telepathy_channel_create_shadow ()));
priv->preview_area = mx_frame_new ();
mx_stylable_set_style_class (MX_STYLABLE (priv->preview_area),
"PreviewPadding");
mx_bin_set_child (MX_BIN (priv->preview_area), video_preview_area);
}
static void
mex_telepathy_channel_create_incoming_video (MexTelepathyChannel *self)
{
MexTelepathyChannelPrivate *priv = MEX_TELEPATHY_CHANNEL (self)->priv;
ClutterActor *video_incoming_area;
/* Setup the incoming surface to draw to */
priv->incoming_texture = clutter_texture_new ();
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (priv->incoming_texture),
TRUE);
video_incoming_area = mx_stack_new ();
clutter_container_add (CLUTTER_CONTAINER (video_incoming_area),
mex_telepathy_channel_create_static_image(),
priv->incoming_texture,
NULL);
/* Create a frame for it with a styled border */
priv->full_frame = mx_frame_new();
clutter_actor_set_name (priv->full_frame, "Incoming Frame");
mx_bin_set_fill (MX_BIN (priv->full_frame), TRUE, TRUE);
mx_stylable_set_style_class (MX_STYLABLE (priv->full_frame),
"CallWindow");
clutter_actor_add_effect (priv->full_frame,
CLUTTER_EFFECT (
mex_telepathy_channel_create_shadow ()));
clutter_container_add_actor (CLUTTER_CONTAINER (priv->full_frame),
video_incoming_area);
priv->incoming_sink =
clutter_gst_video_sink_new (CLUTTER_TEXTURE (priv->incoming_texture));
}
static VALUE
rbcltgst_video_sink_initialize (VALUE self, VALUE texture)
{
GstElement *elem = clutter_gst_video_sink_new (RVAL2GOBJ (texture));
rbcltgst_initialize_gst_object (self, elem);
return Qnil;
}
static void
empathy_video_widget_init (EmpathyVideoWidget *object)
{
EmpathyVideoWidgetPriv *priv = GET_PRIV (object);
GstElement *colorspace, *videoscale;
ClutterActor *texture;
GstPad *pad;
texture = create_clutter_texture (object);
priv->videosink = gst_bin_new (NULL);
gst_object_ref (priv->videosink);
gst_object_sink (priv->videosink);
priv->sink_pad = gst_element_get_static_pad (priv->videosink, "sink");
priv->sink = clutter_gst_video_sink_new (CLUTTER_TEXTURE (texture));
g_object_unref (G_OBJECT (texture));
g_assert (priv->sink != NULL);
videoscale = gst_element_factory_make ("videoscale", NULL);
g_assert (videoscale != NULL);
g_object_set (videoscale, "qos", FALSE, NULL);
colorspace = gst_element_factory_make ("ffmpegcolorspace", NULL);
g_assert (colorspace != NULL);
g_object_set (colorspace, "qos", FALSE, NULL);
/* keep a reference so we can set it's "sync" or "async" properties */
gst_object_ref (priv->sink);
gst_bin_add_many (GST_BIN (priv->videosink), colorspace, videoscale,
priv->sink, NULL);
if (!gst_element_link (colorspace, videoscale))
g_error ("Failed to link ffmpegcolorspace and videoscale");
if (!gst_element_link (videoscale, priv->sink))
g_error ("Failed to link videoscale and gconfvideosink");
pad = gst_element_get_static_pad (colorspace, "sink");
g_assert (pad != NULL);
priv->sink_pad = gst_ghost_pad_new ("sink", pad);
if (!gst_element_add_pad (priv->videosink, priv->sink_pad))
g_error ("Couldn't add sink ghostpad to the bin");
gst_object_unref (pad);
}
gint main (gint argc, gchar *argv[])
{
/* initialization */
gst_init (&argc, &argv);
gtk_init(&argc, &argv);
clutter_init(&argc, &argv);
/* herein we count windows and map them to sinks */
windows_t windows;
windows.n = 0;
GMainLoop *loop = g_main_loop_new(NULL, FALSE);
GtkWidget *window1 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect (window1, "realize",
G_CALLBACK (video_widget_realize_cb), &windows);
g_signal_connect (window2, "realize",
G_CALLBACK (video_widget_realize_cb), &windows);
/* Make a timeline */
ClutterTimeline *timeline = clutter_timeline_new(1000);
g_object_set(timeline, "loop", TRUE, NULL);
ClutterActor *stage1 = new_stage();
ClutterTexture *texture1 = g_object_new (CLUTTER_TYPE_TEXTURE,
"sync-size", FALSE,
"disable-slicing", TRUE,
NULL);
GstElement *sink1 = clutter_gst_video_sink_new(CLUTTER_TEXTURE(texture1));
ClutterActor *stage2 = new_stage();
ClutterTexture *texture2 = g_object_new (CLUTTER_TYPE_TEXTURE,
"sync-size", FALSE,
"disable-slicing", TRUE,
NULL);
GstElement *sink2 = clutter_gst_video_sink_new(CLUTTER_TEXTURE(texture2));
/*To avoid flickering on show, you should call gtk_widget_show() or
gtk_widget_realize() before calling clutter_actor_show() */
//GstElement *sink1 = gst_element_factory_make("ximagesink", "sink1");
//GstElement *sink2 = gst_element_factory_make("ximagesink", "sink2");
GstElement *pipeline = (GstElement *)make_dual_pipeline(sink1, sink2);
windows.sinks[0] = sink1;
windows.sinks[1] = sink2;
windows.stages[0] = stage1;
windows.stages[1] = stage2;
set_up_window(loop, window1);
set_up_window(loop, window2);
GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
gst_bus_add_watch(bus, (GstBusFunc)bus_call, &windows);
gst_object_unref(bus);
gst_element_set_state(pipeline, GST_STATE_PLAYING);
/* start the timeline */
clutter_timeline_start(timeline);
clutter_group_add(CLUTTER_GROUP(stage1), texture1);
clutter_group_add(CLUTTER_GROUP(stage2), texture2);
clutter_actor_show_all(stage1);
clutter_actor_show_all(stage2);
g_main_loop_run(loop);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
return 0;
}
static void
_gb_player_setup_widgets (GbPlayer *self)
{
GbPlayerPrivate *p = GB_PLAYER_GET_PRIVATE(self);
ClutterColor cc_white = {0xff, 0xff, 0xff, 0x8f};
ClutterColor cc_black = {0x00, 0x00, 0x00, 0xff};
/* title group */
p->title_group = clutter_group_new ();
p->title_rect = gb_player_rounded_rect (self, 400, 36, &cc_white, 35);
p->title_label = clutter_label_new_full ("DejaVu Sans",
"<span size='11500'><b>Here comes the media's title</b></span>",
&cc_black);
clutter_label_set_use_markup (CLUTTER_LABEL(p->title_label), TRUE);
clutter_actor_set_position (p->title_group, -20, 20);
clutter_actor_set_position (p->title_label, 50, 10);
CLUTTER_GROUP_AND_SHOW(p->title_group, p->title_rect);
CLUTTER_GROUP_AND_SHOW(p->title_group, p->title_label);
/* window buttons group */
p->window_buttons_group = clutter_group_new ();
p->window_buttons_rect = gb_player_rounded_rect (self, 230, 90, &cc_white, 35);
p->window_aspect_button = clutter_texture_new_from_pixbuf (p->fullscreen);
p->window_open_file_button = clutter_texture_new_from_pixbuf (p->open_file);
clutter_label_set_use_markup (CLUTTER_LABEL(p->title_label), TRUE);
CLUTTER_GROUP_AND_SHOW(p->window_buttons_group, p->window_buttons_rect);
CLUTTER_GROUP_AND_SHOW(p->window_buttons_group, p->window_aspect_button);
CLUTTER_GROUP_AND_SHOW(p->window_buttons_group, p->window_open_file_button);
clutter_actor_set_position (p->window_buttons_group, 640 - 200, 20);
clutter_actor_set_position (p->window_open_file_button, 40, 20);
clutter_actor_set_position (p->window_aspect_button, 130, 20);
/* background group*/
p->bg_group = clutter_group_new ();
p->bg_video = clutter_gst_video_texture_new ();
p->bg_image = clutter_texture_new_from_pixbuf (p->bgpixbuf);
p->bg_logo = clutter_texture_new_from_pixbuf (p->bglogo);
CLUTTER_GROUP_AND_SHOW(p->bg_group, p->bg_image);
CLUTTER_GROUP_AND_SHOW(p->bg_group, p->bg_logo);
CLUTTER_GROUP_AND_SHOW(p->bg_group, p->bg_video);
clutter_actor_set_position (p->bg_logo, (640 / 2) - (467 / 2), (480 / 2) - (210 / 2));
clutter_actor_set_size (p->bg_video, 640, 480);
/* controls group */
p->controls_group = clutter_group_new ();
p->controls_rect = gb_player_rounded_rect (self, 400, 70, &cc_white, 45);
p->controls_backward = clutter_texture_new_from_pixbuf (p->backward);
p->controls_forward = clutter_texture_new_from_pixbuf (p->forward);
p->controls_play_pause = clutter_texture_new_from_pixbuf (p->play);
p->controls_stop = clutter_texture_new_from_pixbuf (p->stop);
CLUTTER_GROUP_AND_SHOW(p->controls_group, p->controls_rect);
CLUTTER_GROUP_AND_SHOW(p->controls_group, p->controls_backward);
CLUTTER_GROUP_AND_SHOW(p->controls_group, p->controls_forward);
CLUTTER_GROUP_AND_SHOW(p->controls_group, p->controls_play_pause);
clutter_actor_set_position (p->controls_group, (640 / 2) - (400 / 2), 480 - 70 - 30);
clutter_actor_set_position (p->controls_backward, 30, 15);
clutter_actor_set_position (p->controls_play_pause, 170, 5);
clutter_actor_set_position (p->controls_forward, 300, 15);
CLUTTER_GROUP_AND_SHOW(p->stage, p->bg_group);
CLUTTER_GROUP_AND_SHOW(p->stage, p->title_group);
CLUTTER_GROUP_AND_SHOW(p->stage, p->controls_group);
CLUTTER_GROUP_AND_SHOW(p->stage, p->window_buttons_group);
gtk_widget_show_all (p->window);
clutter_actor_set_reactive (p->controls_backward, TRUE);
clutter_actor_set_reactive (p->controls_forward, TRUE);
clutter_actor_set_reactive (p->controls_play_pause, TRUE);
clutter_actor_set_reactive (p->window_aspect_button, TRUE);
clutter_actor_set_reactive (p->window_open_file_button, TRUE);
clutter_actor_set_reactive (p->stage, TRUE);
clutter_actor_hide (p->bg_video);
p->videosink = clutter_gst_video_sink_new (CLUTTER_TEXTURE(p->bg_video));
g_object_set (p->player, "video-sink", p->videosink, NULL);
}
int
main (int argc, char *argv[])
{
UserInterface *ui = NULL;
GstEngine *engine = NULL;
ClutterActor *video_texture;
GstElement *sink;
gboolean ok, fullscreen = FALSE;
gint ret = 0;
guint c, index, pos = 0;
gchar *fileuri, *uri;
gchar *file_list[argc];
GOptionContext *context;
if (!g_thread_supported ())
g_thread_init (NULL);
context = g_option_context_new ("<media file> - Play movie files");
ok = process_args (argc, argv, file_list, &fullscreen, context);
if (!ok)
goto quit;
config_load ();
// User Interface
ui = g_new0 (UserInterface, 1);
ui->fullscreen = fullscreen;
video_texture = clutter_texture_new ();
clutter_gst_init (&argc, &argv);
// Gstreamer
engine = g_new0 (GstEngine, 1);
ui->engine = engine;
sink = clutter_gst_video_sink_new (CLUTTER_TEXTURE (video_texture));
ok = engine_init (engine, sink);
if (!ok)
goto quit;
ui->texture = video_texture;
gst_bus_add_watch (engine->bus, bus_call, ui);
gst_object_unref (engine->bus);
if (gst_uri_is_valid (file_list[0]))
uri = g_strdup (file_list[0]);
else {
fileuri = clean_uri (file_list[0]);
uri = g_strdup_printf ("file://%s", fileuri);
}
engine_load_uri (engine, uri);
interface_load_uri (ui, uri);
load_user_interface (ui);
change_state (engine, "Paused");
change_state (engine, "Playing");
clutter_main ();
close_down (ui, engine);
quit:
g_option_context_free (context);
return ret;
}
/* snappy's main function */
int
main (int argc, char *argv[])
{
UserInterface *ui = NULL;
GstEngine *engine = NULL;
ClutterActor *video_texture;
ClutterGstVideoSink *sink;
gboolean ok, blind = FALSE, fullscreen = FALSE, hide = FALSE, loop = FALSE;
gboolean secret = FALSE, tags = FALSE;
gint ret = 0;
gchar *uri = NULL;
gchar *suburi = NULL;
GList *uri_list;
GOptionContext *context;
gchar *data_dir;
ClutterInitError ci_err;
#ifdef ENABLE_DBUS
SnappyMP *mp_obj = NULL;
#endif
context = g_option_context_new ("<media file> - Play movie files");
clutter_set_windowing_backend (CLUTTER_WINDOWING_X11);
ci_err = gtk_clutter_init (&argc, &argv);
if (ci_err != CLUTTER_INIT_SUCCESS)
goto quit;
/* Try to find the path for our resources in case snappy was relocated */
data_dir = g_strdup (SNAPPY_DATA_DIR);
if (!g_file_test (data_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
gchar *root_dir;
#ifdef G_OS_WIN32
root_dir = g_win32_get_package_installation_directory_of_module (NULL);
#elif !defined(G_OS_UNIX)
gchar *exec_path;
gchar *bin_dir;
exec_path = g_file_read_link ("/proc/self/exe", NULL);
bin_dir = g_path_get_dirname (exec_path);
root_dir = g_build_filename (bin_dir, "..", NULL);
g_free (exec_path);
g_free (bin_dir);
#else
root_dir = NULL;
#endif
if (root_dir != NULL) {
data_dir = g_build_filename (root_dir, "share", "snappy", NULL);
g_free (root_dir);
}
}
/* Process command arguments */
uri_list = process_args (argc, argv, &blind, &fullscreen, &hide,
&loop, &secret, &suburi, &tags, context);
gst_init (&argc, &argv);
clutter_gst_init (NULL, NULL);
/* User Interface */
ui = g_new (UserInterface, 1);
ui->uri_list = uri_list;
ui->blind = blind;
ui->fullscreen = fullscreen;
ui->hide = hide;
ui->tags = tags;
ui->data_dir = data_dir;
interface_init (ui);
/* Gstreamer engine */
engine = g_new (GstEngine, 1);
sink = clutter_gst_video_sink_new ();
if (sink == NULL) {
g_print ("ERROR: Failed to create clutter-gst sink element\n");
return FALSE;
}
video_texture = g_object_new (CLUTTER_TYPE_ACTOR, "content",
g_object_new (CLUTTER_GST_TYPE_CONTENT, "sink", sink, NULL),
"name", "texture", NULL);
ok = engine_init (engine, sink);
if (!ok)
goto quit;
engine->secret = secret;
engine->loop = loop;
ui->engine = engine;
ui->texture = video_texture;
gst_bus_add_watch (engine->bus, bus_call, ui);
gst_object_unref (engine->bus);
/* Get uri to load */
if (uri_list) {
uri = g_list_first (uri_list)->data;
/* based on video filename we can guess subtitle file (.srt files only) */
if (NULL == suburi) {
gchar suburi_path_guessing[1024]; //buffer
gchar *uri_no_extension = strip_filename_extension (uri);
sprintf (suburi_path_guessing, "%s.srt", uri_no_extension);
/* subtitle file exists, defaults for it */
if (g_file_test (g_filename_from_uri (suburi_path_guessing, NULL, NULL),
G_FILE_TEST_EXISTS))
suburi = suburi_path_guessing;
}
}
/* Load engine and start interface */
engine_load_uri (engine, uri);
interface_start (ui, uri);
/* Load subtitle file if available */
if (suburi != NULL) {
suburi = clean_uri (suburi);
set_subtitle_uri (engine, suburi);
}
/* Start playing if we have a URI to play */
if (uri) {
change_state (engine, "Paused");
change_state (engine, "Playing");
}
#ifdef ENABLE_DBUS
/* Start MPRIS Dbus object */
mp_obj = g_new (SnappyMP, 1);
mp_obj->engine = engine;
mp_obj->ui = ui;
load_dlna (mp_obj);
#endif
/* Main loop */
gtk_main ();
/* Close snappy */
close_down (ui, engine);
#ifdef ENABLE_DBUS
close_dlna (mp_obj);
#endif
quit:
g_list_free (uri_list);
g_option_context_free (context);
return ret;
}
HandCar *
handcar_new()
{
HandCar *all = g_new0(HandCar, 1);
ClutterColor rect_color = { 0xdd, 0xdd, 0xdd, 0xee };
ClutterColor rect_border_color = { 0xee, 0xee, 0xee, 0xdd };
ClutterColor rect_entry_color = { 0xef, 0xef, 0xef, 0xee };
ClutterColor rect_entry_border_color = { 0x96, 0x96, 0x96, 0xaa };
ClutterColor label_color = { 0x55, 0x00, 0x00, 0xff };
ClutterColor time_color = { 0x00, 0x33, 0x55, 0xbb };
GError *error = NULL;
all->play = gdk_pixbuf_new_from_file("imgs/start.svg", NULL);
all->previous = gdk_pixbuf_new_from_file("imgs/backward.svg", NULL);
all->next = gdk_pixbuf_new_from_file("imgs/forward.svg", NULL);
all->stop = gdk_pixbuf_new_from_file("imgs/stop.svg", NULL);
all->time = 0;
all->playing = FALSE;
all->player = gst_element_factory_make ("playbin", "player");
if (error)
g_error ("FUDEU: %s", error->message);
all->label_actor = clutter_label_new_full("DejaVu Sans",
"Blind Guardian - <b>Mirror Mirror</b>",
&label_color);
clutter_label_set_use_markup (CLUTTER_LABEL(all->label_actor), TRUE);
all->label_time = clutter_label_new_full("DejaVu Sans",
"00:00",
&time_color);
clutter_label_set_use_markup (CLUTTER_LABEL(all->label_time), TRUE);
clutter_actor_set_position (all->label_actor, 10, 15);
clutter_actor_set_position (all->label_time, STAGE_WIDTH - 80, STAGE_HEIGHT - 20);
all->btn_actor_play = clutter_texture_new_from_pixbuf (all->play);
all->btn_actor_next = clutter_texture_new_from_pixbuf (all->next);
all->btn_actor_previous = clutter_texture_new_from_pixbuf (all->previous);
clutter_actor_set_position (all->btn_actor_previous, 60, 50);
clutter_actor_set_position (all->btn_actor_play, 140, 50);
clutter_actor_set_position (all->btn_actor_next, 200, 50);
all->rect1 = clutter_rectangle_new_with_color (&rect_color);
clutter_actor_set_size (all->rect1, 320, 30);
clutter_actor_set_position (all->rect1, -5, 10);
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE(all->rect1), 4);
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE(all->rect1), &rect_border_color);
all->rect2 = clutter_rectangle_new_with_color (&rect_entry_color);
clutter_actor_set_size (all->rect2, 270, 20);
clutter_actor_set_position (all->rect2, 20, STAGE_HEIGHT - 50);
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE(all->rect2), 1);
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE(all->rect2), &rect_entry_border_color);
all->rect3 = clutter_rectangle_new_with_color (&rect_entry_color);
clutter_actor_set_size (all->rect3, 270, 203);
clutter_actor_set_position (all->rect3, 20, 120);
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE(all->rect3), 1);
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE(all->rect3), &rect_entry_border_color);
all->entry_actor = clutter_entry_new_full ("Monospace",
"Teste",
&label_color);
clutter_actor_set_size (all->entry_actor, 270, 20);
clutter_actor_set_position (all->entry_actor, 20, STAGE_HEIGHT - 50);
all->video = clutter_gst_video_texture_new ();
clutter_actor_set_size (all->video, 270, 203);
clutter_actor_set_position (all->video, 20, 120);
clutter_actor_set_opacity (all->video, 0xff);
// all->clutter_group_add_many (all->container1, all->rect1);
all->videosink = clutter_gst_video_sink_new (CLUTTER_TEXTURE(all->video));
g_object_set (all->player, "video-sink", all->videosink, NULL);
all->format = GST_FORMAT_TIME;
clutter_actor_show(all->btn_actor_play);
clutter_actor_show(all->btn_actor_next);
clutter_actor_show(all->btn_actor_previous);
clutter_actor_show(all->label_actor);
clutter_actor_show(all->label_time);
clutter_actor_show(all->rect1);
clutter_actor_show(all->rect2);
clutter_actor_show(all->rect3);
clutter_actor_show(all->video);
clutter_actor_show(all->entry_actor);
return all;
}
