static VALUE
rbclt_media_set_position (int argc, VALUE *argv, VALUE self)
{
ClutterMedia *media = CLUTTER_MEDIA (RVAL2GOBJ (self));
VALUE pos, y;
/* The 'set_position' setter for the 'position' property overrides
the 'set_position(x,y)' method in Clutter::Actor, so to work
around this we will fake a special set_position method, but only
if the object is actually a ClutterActor */
if (CLUTTER_IS_ACTOR (media))
rb_scan_args (argc, argv, "11", &pos, &y);
else
{
rb_scan_args (argc, argv, "10", &pos);
y = Qnil;
}
if (y != Qnil)
clutter_actor_set_position (CLUTTER_ACTOR (media),
NUM2INT (pos), NUM2INT (y));
else
clutter_media_set_position (media, NUM2INT (pos));
return self;
}
static gboolean
_stop_video_preview (MexContentTile *self)
{
MexContentTilePrivate *priv = MEX_CONTENT_TILE (self)->priv;
if (priv->start_video_preview > 0)
g_source_remove (priv->start_video_preview);
/* video never started */
if (priv->child == priv->image)
return FALSE;
if (!priv->video_preview)
return FALSE;
clutter_media_set_playing (CLUTTER_MEDIA (priv->video_preview), FALSE);
clutter_actor_remove_child (CLUTTER_ACTOR (self), priv->video_preview);
clutter_actor_add_child (CLUTTER_ACTOR (self), priv->image);
/* After setting the child the old child is killed off so NULL this to
* help with checks
*/
priv->video_preview = NULL;
return FALSE;
}
static VALUE
rbclt_media_filename_equals (VALUE self, VALUE filename)
{
ClutterMedia *media = CLUTTER_MEDIA (RVAL2GOBJ (self));
clutter_media_set_filename (media, StringValuePtr (filename));
return filename;
}
static void
mex_get_stream_cb (MexProgram *program,
const gchar *url,
const GError *error,
gpointer user_data)
{
MexPlayer *player = user_data;
MexPlayerPrivate *priv = player->priv;
MexGenericContent *generic_content;
#ifdef USE_PLAYER_CLUTTER_GST
ClutterGstVideoTexture *video_texture;
#endif
/* if idle mode has been set before the program stream was found */
if (priv->idle_mode)
return;
if (G_UNLIKELY (error))
{
g_warning ("Could not play content: %s (%s)", error->message, url);
return;
}
#ifdef USE_PLAYER_CLUTTER_GST
/* We seek at the precise time when the file is local, but we
* seek to key frame when streaming */
video_texture = CLUTTER_GST_VIDEO_TEXTURE (priv->media);
if (g_str_has_prefix (url, "file://"))
{
clutter_gst_video_texture_set_seek_flags (video_texture,
CLUTTER_GST_SEEK_FLAG_ACCURATE);
}
else
{
clutter_gst_video_texture_set_seek_flags (video_texture,
CLUTTER_GST_SEEK_FLAG_NONE);
}
#endif
clutter_media_set_uri (CLUTTER_MEDIA (priv->media), url);
generic_content = MEX_GENERIC_CONTENT (priv->content);
if (mex_generic_content_get_last_position_start (generic_content))
clutter_media_set_progress (CLUTTER_MEDIA (priv->media), priv->position);
clutter_media_set_playing (CLUTTER_MEDIA (priv->media), TRUE);
}
void
mex_player_stop (MexPlayer *player)
{
MexPlayerPrivate *priv = player->priv;
if (priv->idle_mode)
return;
clutter_media_set_uri (CLUTTER_MEDIA (priv->media), NULL);
clutter_media_set_playing (priv->media, FALSE);
g_signal_emit (player, signals[CLOSE_REQUEST], 0);
}
int
main (int argc,
char **argv)
{
MexPluginManager *pmanager;
MexMediaDBUSBridge *bridge;
GMainLoop *loop;
GError *error = NULL;
gchar **plugin_directories;
plugin_directories = g_new0 (gchar *, 2);
plugin_directories[0] = g_strdup (MEX_PLAYER_PLUGIN_PATH);
g_thread_init (NULL);
gst_init (&argc, &argv);
mex_init (&argc, &argv);
/* Setup player and expose it to mex */
media_player = mex_surface_player_new ();
mex_player_set_media_player_callback (_get_media_player);
bridge = mex_media_dbus_bridge_new (CLUTTER_MEDIA (media_player));
/* Load player's plugins */
pmanager = mex_plugin_manager_get_default ();
g_object_set (G_OBJECT (pmanager), "search-paths", plugin_directories, NULL);
mex_plugin_manager_refresh (pmanager);
/* Export player's interface on d-bus */
if (!mex_media_dbus_bridge_register (bridge, &error))
{
g_error ("Error registering on D-BUS: %s", error->message);
g_clear_error (&error);
return EXIT_SUCCESS;
}
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return EXIT_SUCCESS;
}
static void
mex_get_stream_cb (MexProgram *program,
const gchar *url,
const GError *error,
gpointer user_data)
{
MexPlayer *player = user_data;
MexPlayerPrivate *priv = player->priv;
MexGenericContent *generic_content;
#ifdef USE_PLAYER_CLUTTER_GST
ClutterGstVideoTexture *video_texture;
#endif
/* if idle mode has been set before the program stream was found */
if (priv->idle_mode)
return;
if (G_UNLIKELY (error))
{
g_warning ("Could not play content: %s (%s)", error->message, url);
return;
}
#ifdef USE_PLAYER_CLUTTER_GST
/* We seek at the precise time when the file is local, but we
* seek to key frame when streaming */
video_texture = CLUTTER_GST_VIDEO_TEXTURE (priv->media);
if (g_str_has_prefix (url, "file://"))
{
clutter_gst_video_texture_set_seek_flags (video_texture,
CLUTTER_GST_SEEK_FLAG_ACCURATE);
}
else
{
clutter_gst_video_texture_set_seek_flags (video_texture,
CLUTTER_GST_SEEK_FLAG_NONE);
}
/* TODO when we have settings we can configure this feature */
if (g_str_has_prefix (mex_content_get_metadata (priv->content,
MEX_CONTENT_METADATA_MIMETYPE),
"audio/"))
{
GstElement *gst_element, *visual;
gint gst_flags;
gst_element = clutter_gst_video_texture_get_pipeline (video_texture);
g_object_get (G_OBJECT (gst_element), "flags", &gst_flags, NULL);
gst_flags = (GST_PLAY_FLAG_VIS | gst_flags);
g_object_set (G_OBJECT (gst_element), "flags", gst_flags, NULL);
visual = gst_element_factory_make ("libvisual_infinite", NULL);
if (visual)
g_object_set (G_OBJECT (gst_element), "vis-plugin", visual, NULL);
}
#endif
clutter_media_set_uri (CLUTTER_MEDIA (priv->media), url);
generic_content = MEX_GENERIC_CONTENT (priv->content);
if (mex_generic_content_get_last_position_start (generic_content))
clutter_media_set_progress (CLUTTER_MEDIA (priv->media), priv->position);
clutter_media_set_playing (CLUTTER_MEDIA (priv->media), TRUE);
}
int
main (int argc, char *argv[])
{
ClutterActor *video;
/* So we can fade out at the end. */
clutter_x11_set_use_argb_visual (TRUE);
if (clutter_gst_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return EXIT_FAILURE;
if (argc < 2)
{
g_print ("Usage: %s [OPTIONS] <video file>\n", argv[0]);
return EXIT_FAILURE;
}
if (!clutter_color_from_string (&bg_color, BG_COLOR))
{
g_warning ("Invalid BG_COLOR");
exit (1);
}
stage = clutter_stage_new ();
/* Clutter's full-screening code does not allow us to
* set both that and _NET_WM_STATE_ABOVE, so do the state
* management ourselves for now. */
#if 0
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);
#endif
/* Clutter will set maximum size restrictions (meaning not
* full screen) unless I set this. */
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);
clutter_actor_set_background_color (stage, &bg_color);
clutter_actor_set_layout_manager (stage,
clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FIXED));
clutter_actor_realize (stage);
set_above_and_fullscreen ();
video = clutter_gst_video_texture_new ();
clutter_actor_set_x_expand (video, TRUE);
clutter_actor_set_y_expand (video, TRUE);
clutter_actor_set_x_align (video, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_align (video, CLUTTER_ACTOR_ALIGN_CENTER);
set_idle_material (CLUTTER_GST_VIDEO_TEXTURE (video));
g_signal_connect (video,
"eos",
G_CALLBACK (on_video_texture_eos),
NULL);
g_signal_connect (stage,
"destroy",
G_CALLBACK (clutter_main_quit),
NULL);
clutter_media_set_filename (CLUTTER_MEDIA (video), argv[1]);
clutter_stage_hide_cursor (CLUTTER_STAGE (stage));
clutter_actor_add_child (stage, video);
g_signal_connect (stage, "key-press-event", G_CALLBACK (key_press_cb), NULL);
clutter_media_set_playing (CLUTTER_MEDIA (video), TRUE);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
static gboolean
_start_video_preview (MexContentTile *self)
{
MexContentTilePrivate *priv = self->priv;
GstElement *pipeline;
gint gst_flags;
const gchar *mimetype, *uri;
/* Check we're still focused */
if (!mex_actor_has_focus (CLUTTER_ACTOR (self)))
return FALSE;
/* Don't play if the main player is still playing..
* too many videos spoil the broth.
*/
if (clutter_media_get_playing (mex_player_get_clutter_media (mex_player_get_default ())))
return FALSE;
mimetype = mex_content_get_metadata (priv->content,
MEX_CONTENT_METADATA_MIMETYPE);
if ((mimetype) && strncmp (mimetype, "video/", 6) != 0)
return FALSE;
if (!(uri = mex_content_get_metadata (priv->content,
MEX_CONTENT_METADATA_STREAM)))
return FALSE;
priv->video_preview = clutter_gst_video_texture_new ();
pipeline = clutter_gst_video_texture_get_pipeline (CLUTTER_GST_VIDEO_TEXTURE (priv->video_preview));
g_object_get (G_OBJECT (pipeline), "flags", &gst_flags, NULL);
gst_flags = 1;//GST_PLAY_FLAG_VIDEO;
g_object_set (G_OBJECT (pipeline), "flags", gst_flags, NULL);
clutter_gst_video_texture_set_idle_material (CLUTTER_GST_VIDEO_TEXTURE (priv->video_preview),
NULL);
g_signal_connect (priv->video_preview, "eos",
G_CALLBACK (_stop_video_eos),
self);
clutter_actor_set_opacity (priv->video_preview, 0);
g_object_ref (priv->image);
clutter_actor_remove_child (CLUTTER_ACTOR (self), priv->image);
clutter_actor_add_child (CLUTTER_ACTOR (self), priv->video_preview);
clutter_actor_animate (priv->video_preview, CLUTTER_LINEAR, 500,
"opacity", 0xff, NULL);
clutter_actor_set_size (priv->video_preview,
(gfloat)priv->thumb_width,
(gfloat)priv->thumb_height);
clutter_media_set_uri (CLUTTER_MEDIA (priv->video_preview), uri);
clutter_media_set_playing (CLUTTER_MEDIA (priv->video_preview), TRUE);
if (priv->stop_video_preview <= 0)
priv->stop_video_preview =
g_timeout_add_seconds (180, (GSourceFunc)_stop_video_preview, self);
return FALSE;
}
int
main (int argc, char *argv[])
{
ClutterActor *video;
GdkPixbuf *shot = NULL;
gint duration;
CoglHandle tex_id;
CoglPixelFormat format;
gint size;
gint width;
gint height;
gint rowstride;
guchar *data = NULL;
#ifdef USE_HELIX
clutter_helix_init (&argc, &argv);
#else
gst_init (&argc, &argv);
#endif
clutter_init (&argc, &argv);
if (argc < 3)
{
g_print ("Usage: %s <path to movie file> <output png>\n", argv[0]);
exit(-1);
}
totem_resources_monitor_start (argv[1], 60 * G_USEC_PER_SEC);
#ifdef USE_HELIX
video = clutter_helix_video_texture_new ();
#else
video = clutter_gst_video_texture_new ();
#endif
if (argv[1][0] == '/')
clutter_media_set_filename(CLUTTER_MEDIA(video), argv[1]);
else
clutter_media_set_uri(CLUTTER_MEDIA(video), argv[1]);
clutter_media_set_volume (CLUTTER_MEDIA(video), 0);
clutter_media_set_playing (CLUTTER_MEDIA(video), TRUE);
do {
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
duration = clutter_media_get_duration (CLUTTER_MEDIA(video));
} while (duration == 0);
clutter_actor_realize (video);
clutter_media_set_position (CLUTTER_MEDIA(video), duration/3);
do {
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
} while (clutter_media_get_position (CLUTTER_MEDIA(video)) <= duration/3);
tex_id = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (video));
if (tex_id)
{
format = cogl_texture_get_format (tex_id);
size = cogl_texture_get_data (tex_id, format, 0, NULL);
width = cogl_texture_get_width (tex_id);
height = cogl_texture_get_height (tex_id);
rowstride = cogl_texture_get_rowstride (tex_id);
data = (guchar*) g_malloc (sizeof(guchar) * size);
if (!data)
g_error ("malloc");;
cogl_texture_get_data (tex_id, format, rowstride, data);
shot = gdk_pixbuf_new_from_data (data,
GDK_COLORSPACE_RGB,
FALSE,
8,
width,
height,
rowstride,
NULL,
NULL);
}
totem_resources_monitor_stop ();
if (shot)
{
GdkPixbuf *thumb, *pic;
gint x, y, nw, nh, w, h, size;
size = 128;
/* FIXME swap RGB pixels */
w = clutter_actor_get_width (video);
h = clutter_actor_get_height (video);
nh = ( h * size) / w;
if (nh <= size)
{
nw = size;
x = 0;
y = (size - nh) / 2;
}
else
{
nw = ( w * size ) / h;
nh = size;
x = (size - nw) / 2;
y = 0;
}
thumb = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, size, size);
gdk_pixbuf_fill (thumb, 0x000000FF);
pic = gdk_pixbuf_scale_simple (shot, nw, nh, GDK_INTERP_BILINEAR);
gdk_pixbuf_copy_area (pic, 0, 0, nw, nh, thumb, x, y);
if (!gdk_pixbuf_save (thumb, argv[2], "png", NULL, NULL))
{
g_error ("%s: Pixbuf save failed\n", argv[0]);
exit(-1);
}
g_object_unref (shot);
g_object_unref (thumb);
g_object_unref (pic);
exit(0);
}
exit (-1);
}
static ClutterMedia *
_get_media_player (void)
{
return CLUTTER_MEDIA (media_player);
}
