3 #include <gst/video/video.h>
4 #include <gst/video/gstvideosink.h>
8 #include "emotion_gstreamer.h"
10 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE("sink",
11 GST_PAD_SINK, GST_PAD_ALWAYS,
12 GST_STATIC_CAPS(GST_VIDEO_CAPS_BGRx ";" GST_VIDEO_CAPS_BGR ";" GST_VIDEO_CAPS_BGRA ";" GST_VIDEO_CAPS_YUV("{I420,YV12}")));
15 GST_DEBUG_CATEGORY_STATIC(evas_video_sink_debug);
16 #define GST_CAT_DEFAULT evas_video_sink_debug
31 static guint evas_video_sink_signals[LAST_SIGNAL] = { 0, };
33 struct _EvasVideoSinkPrivate {
40 GstVideoFormat format;
45 // If this is TRUE all processing should finish ASAP
46 // This is necessary because there could be a race between
47 // unlock() and render(), where unlock() wins, signals the
48 // GCond, then render() tries to render a frame although
49 // everything else isn't running anymore. This will lead
50 // to deadlocks because render() holds the stream lock.
52 // Protected by the buffer mutex
53 Eina_Bool unlocked : 1;
54 Eina_Bool preroll : 1;
57 #define _do_init(bla) \
58 GST_DEBUG_CATEGORY_INIT(evas_video_sink_debug, \
63 GST_BOILERPLATE_FULL(EvasVideoSink,
70 static void unlock_buffer_mutex(EvasVideoSinkPrivate* priv);
72 static void evas_video_sink_render_handler(void *data, void *buf, unsigned int len);
75 evas_video_sink_base_init(gpointer g_class)
77 GstElementClass* element_class;
79 element_class = GST_ELEMENT_CLASS(g_class);
80 gst_element_class_add_pad_template(element_class, gst_static_pad_template_get(&sinktemplate));
81 gst_element_class_set_details_simple(element_class, "Evas video sink",
82 "Sink/Video", "Sends video data from a GStreamer pipeline to an Evas object",
83 "Vincent Torri <vtorri@univ-evry.fr>");
87 evas_video_sink_init(EvasVideoSink* sink, EvasVideoSinkClass* klass __UNUSED__)
89 EvasVideoSinkPrivate* priv;
91 sink->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE(sink, EVAS_TYPE_VIDEO_SINK, EvasVideoSinkPrivate);
93 priv->p = ecore_pipe_add(evas_video_sink_render_handler, sink);
96 priv->update_size = TRUE;
97 priv->format = GST_VIDEO_FORMAT_UNKNOWN;
98 priv->data_cond = g_cond_new();
99 priv->buffer_mutex = g_mutex_new();
100 priv->preroll = EINA_FALSE;
101 priv->unlocked = EINA_FALSE;
105 /**** Object methods ****/
108 evas_video_sink_set_property(GObject * object, guint prop_id,
109 const GValue * value, GParamSpec * pspec)
112 EvasVideoSinkPrivate* priv;
114 sink = EVAS_VIDEO_SINK (object);
118 case PROP_EVAS_OBJECT:
119 g_mutex_lock(priv->buffer_mutex);
120 priv->o = g_value_get_pointer (value);
121 g_mutex_unlock(priv->buffer_mutex);
124 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
130 evas_video_sink_get_property(GObject * object, guint prop_id,
131 GValue * value, GParamSpec * pspec)
134 EvasVideoSinkPrivate* priv;
136 sink = EVAS_VIDEO_SINK (object);
140 case PROP_EVAS_OBJECT:
141 g_mutex_lock(priv->buffer_mutex);
142 g_value_set_pointer (value, priv->o);
143 g_mutex_unlock(priv->buffer_mutex);
146 g_mutex_lock(priv->buffer_mutex);
147 g_value_set_int(value, priv->width);
148 g_mutex_unlock(priv->buffer_mutex);
151 g_mutex_lock(priv->buffer_mutex);
152 g_value_set_int (value, priv->height);
153 g_mutex_unlock(priv->buffer_mutex);
156 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
162 evas_video_sink_dispose(GObject* object)
165 EvasVideoSinkPrivate* priv;
167 sink = EVAS_VIDEO_SINK(object);
170 if (priv->buffer_mutex) {
171 g_mutex_free(priv->buffer_mutex);
172 priv->buffer_mutex = 0;
175 if (priv->data_cond) {
176 g_cond_free(priv->data_cond);
181 ecore_pipe_del(priv->p);
185 G_OBJECT_CLASS(parent_class)->dispose(object);
189 /**** BaseSink methods ****/
191 gboolean evas_video_sink_set_caps(GstBaseSink *bsink, GstCaps *caps)
194 EvasVideoSinkPrivate* priv;
198 sink = EVAS_VIDEO_SINK(bsink);
201 if (G_UNLIKELY(!gst_video_format_parse_caps(caps, &priv->format, &width, &height))) {
205 if ((width != priv->width) || (height != priv->height))
208 priv->height = height;
209 priv->update_size = TRUE;
213 switch (priv->format)
215 case GST_VIDEO_FORMAT_I420:
216 evas_object_image_size_set(priv->o, priv->width, priv->height);
217 evas_object_image_fill_set(priv->o, 0, 0, priv->width, priv->height);
218 evas_object_image_colorspace_set(priv->o, EVAS_COLORSPACE_YCBCR422P601_PL);
219 evas_object_image_alpha_set(priv->o, 0);
222 case GST_VIDEO_FORMAT_YV12:
223 evas_object_image_size_set(priv->o, priv->width, priv->height);
224 evas_object_image_fill_set(priv->o, 0, 0, priv->width, priv->height);
225 evas_object_image_colorspace_set(priv->o, EVAS_COLORSPACE_YCBCR422P601_PL);
226 evas_object_image_alpha_set(priv->o, 0);
229 case GST_VIDEO_FORMAT_BGR:
232 case GST_VIDEO_FORMAT_BGRx:
235 case GST_VIDEO_FORMAT_BGRA:
239 printf ("unsupported : %d\n", priv->format);
247 evas_video_sink_start(GstBaseSink* base_sink)
249 EvasVideoSinkPrivate* priv;
252 priv = EVAS_VIDEO_SINK(base_sink)->priv;
253 g_mutex_lock(priv->buffer_mutex);
262 priv->unlocked = EINA_FALSE;
265 g_mutex_unlock(priv->buffer_mutex);
270 evas_video_sink_stop(GstBaseSink* base_sink)
272 EvasVideoSinkPrivate* priv = EVAS_VIDEO_SINK(base_sink)->priv;
274 unlock_buffer_mutex(priv);
279 evas_video_sink_unlock(GstBaseSink* object)
283 sink = EVAS_VIDEO_SINK(object);
285 unlock_buffer_mutex(sink->priv);
287 return GST_CALL_PARENT_WITH_DEFAULT(GST_BASE_SINK_CLASS, unlock,
292 evas_video_sink_unlock_stop(GstBaseSink* object)
295 EvasVideoSinkPrivate* priv;
297 sink = EVAS_VIDEO_SINK(object);
300 g_mutex_lock(priv->buffer_mutex);
301 priv->unlocked = FALSE;
302 g_mutex_unlock(priv->buffer_mutex);
304 return GST_CALL_PARENT_WITH_DEFAULT(GST_BASE_SINK_CLASS, unlock_stop,
309 evas_video_sink_preroll(GstBaseSink* bsink, GstBuffer* buffer)
313 EvasVideoSinkPrivate* priv;
315 sink = EVAS_VIDEO_SINK(bsink);
318 send = gst_buffer_ref(buffer);
320 priv->preroll = EINA_TRUE;
322 ecore_pipe_write(priv->p, &send, sizeof(buffer));
327 evas_video_sink_render(GstBaseSink* bsink, GstBuffer* buffer)
331 EvasVideoSinkPrivate* priv;
334 sink = EVAS_VIDEO_SINK(bsink);
337 g_mutex_lock(priv->buffer_mutex);
339 if (priv->unlocked) {
340 g_mutex_unlock(priv->buffer_mutex);
344 priv->preroll = EINA_FALSE;
346 send = gst_buffer_ref(buffer);
347 ret = ecore_pipe_write(priv->p, &send, sizeof(buffer));
349 return GST_FLOW_ERROR;
351 g_cond_wait(priv->data_cond, priv->buffer_mutex);
352 g_mutex_unlock(priv->buffer_mutex);
357 static void evas_video_sink_render_handler(void *data,
361 Emotion_Gstreamer_Video *ev;
362 Emotion_Video_Stream *vstream;
364 EvasVideoSinkPrivate* priv;
366 unsigned char *evas_data;
367 const guint8 *gst_data;
369 GstFormat fmt = GST_FORMAT_TIME;
372 sink = (EvasVideoSink *)data;
375 buffer = *((GstBuffer **)buf);
380 gst_data = GST_BUFFER_DATA(buffer);
381 if (!gst_data) goto exit_point;
382 if (priv->update_size)
384 evas_object_image_size_set(priv->o, priv->width, priv->height);
385 evas_object_image_fill_set(priv->o, 0, 0, priv->width, priv->height);
386 priv->update_size = FALSE;
389 evas_data = (unsigned char *)evas_object_image_data_get(priv->o, 1);
391 // Evas's BGRA has pre-multiplied alpha while GStreamer's doesn't.
392 // Here we convert to Evas's BGRA.
393 if (priv->format == GST_VIDEO_FORMAT_BGR) {
394 unsigned char *evas_tmp;
398 evas_tmp = evas_data;
399 /* FIXME: could this be optimized ? */
400 for (x = 0; x < priv->height; x++) {
401 for (y = 0; y < priv->width; y++) {
402 evas_tmp[0] = gst_data[0];
403 evas_tmp[1] = gst_data[1];
404 evas_tmp[2] = gst_data[2];
412 // Evas's BGRA has pre-multiplied alpha while GStreamer's doesn't.
413 // Here we convert to Evas's BGRA.
414 if (priv->format == GST_VIDEO_FORMAT_BGRx) {
415 unsigned char *evas_tmp;
419 evas_tmp = evas_data;
420 /* FIXME: could this be optimized ? */
421 for (x = 0; x < priv->height; x++) {
422 for (y = 0; y < priv->width; y++) {
423 evas_tmp[0] = gst_data[0];
424 evas_tmp[1] = gst_data[1];
425 evas_tmp[2] = gst_data[2];
433 // Evas's BGRA has pre-multiplied alpha while GStreamer's doesn't.
434 // Here we convert to Evas's BGRA.
435 if (priv->format == GST_VIDEO_FORMAT_BGRA) {
436 unsigned char *evas_tmp;
441 evas_tmp = evas_data;
442 /* FIXME: could this be optimized ? */
443 for (x = 0; x < priv->height; x++) {
444 for (y = 0; y < priv->width; y++) {
446 evas_tmp[0] = (gst_data[0] * alpha) / 255;
447 evas_tmp[1] = (gst_data[1] * alpha) / 255;
448 evas_tmp[2] = (gst_data[2] * alpha) / 255;
456 if (priv->format == GST_VIDEO_FORMAT_I420) {
458 unsigned char **rows;
460 evas_object_image_pixels_dirty_set(priv->o, 1);
461 rows = (unsigned char **)evas_data;
463 for (i = 0; i < priv->height; i++)
464 rows[i] = &gst_data[i * priv->width];
466 rows += priv->height;
467 for (i = 0; i < (priv->height / 2); i++)
468 rows[i] = &gst_data[priv->height * priv->width + i * (priv->width / 2)];
470 rows += priv->height / 2;
471 for (i = 0; i < (priv->height / 2); i++)
472 rows[i] = &gst_data[priv->height * priv->width + priv->height * (priv->width /4) + i * (priv->width / 2)];
475 if (priv->format == GST_VIDEO_FORMAT_YV12) {
477 unsigned char **rows;
479 evas_object_image_pixels_dirty_set(priv->o, 1);
481 rows = (unsigned char **)evas_data;
483 for (i = 0; i < priv->height; i++)
484 rows[i] = &gst_data[i * priv->width];
486 rows += priv->height;
487 for (i = 0; i < (priv->height / 2); i++)
488 rows[i] = &gst_data[priv->height * priv->width + priv->height * (priv->width /4) + i * (priv->width / 2)];
490 rows += priv->height / 2;
491 for (i = 0; i < (priv->height / 2); i++)
492 rows[i] = &gst_data[priv->height * priv->width + i * (priv->width / 2)];
495 evas_object_image_data_update_add(priv->o, 0, 0, priv->width, priv->height);
496 evas_object_image_data_set(priv->o, evas_data);
497 evas_object_image_pixels_dirty_set(priv->o, 0);
499 ev = evas_object_data_get(priv->o, "_emotion_gstreamer_video");
500 _emotion_frame_new(ev->obj);
502 vstream = eina_list_nth(ev->video_streams, ev->video_stream_nbr - 1);
504 gst_element_query_position(ev->pipeline, &fmt, &pos);
505 ev->position = (double)pos / (double)GST_SECOND;
507 vstream->width = priv->width;
508 vstream->height = priv->height;
509 ev->ratio = (double) priv->width / (double) priv->height;
513 _emotion_video_pos_update(ev->obj, ev->position, vstream->length_time);
514 _emotion_frame_resize(ev->obj, vstream->width, vstream->height, ev->ratio);
518 gst_buffer_unref(buffer);
520 if (priv->preroll) return ;
522 g_mutex_lock(priv->buffer_mutex);
524 if (priv->unlocked) {
525 g_mutex_unlock(priv->buffer_mutex);
529 g_cond_signal(priv->data_cond);
530 g_mutex_unlock(priv->buffer_mutex);
534 unlock_buffer_mutex(EvasVideoSinkPrivate* priv)
536 g_mutex_lock(priv->buffer_mutex);
538 priv->unlocked = EINA_TRUE;
539 g_cond_signal(priv->data_cond);
540 g_mutex_unlock(priv->buffer_mutex);
544 marshal_VOID__MINIOBJECT(GClosure * closure, GValue * return_value __UNUSED__,
545 guint n_param_values, const GValue * param_values,
546 gpointer invocation_hint __UNUSED__, gpointer marshal_data)
548 typedef void (*marshalfunc_VOID__MINIOBJECT) (gpointer obj, gpointer arg1, gpointer data2);
549 marshalfunc_VOID__MINIOBJECT callback;
551 gpointer data1, data2;
553 cc = (GCClosure *) closure;
555 g_return_if_fail(n_param_values == 2);
557 if (G_CCLOSURE_SWAP_DATA(closure)) {
558 data1 = closure->data;
559 data2 = g_value_peek_pointer(param_values + 0);
561 data1 = g_value_peek_pointer(param_values + 0);
562 data2 = closure->data;
564 callback = (marshalfunc_VOID__MINIOBJECT) (marshal_data ? marshal_data : cc->callback);
566 callback(data1, gst_value_get_mini_object(param_values + 1), data2);
570 evas_video_sink_class_init(EvasVideoSinkClass* klass)
572 GObjectClass* gobject_class;
573 GstBaseSinkClass* gstbase_sink_class;
575 gobject_class = G_OBJECT_CLASS(klass);
576 gstbase_sink_class = GST_BASE_SINK_CLASS(klass);
578 g_type_class_add_private(klass, sizeof(EvasVideoSinkPrivate));
580 gobject_class->set_property = evas_video_sink_set_property;
581 gobject_class->get_property = evas_video_sink_get_property;
583 g_object_class_install_property (gobject_class, PROP_EVAS_OBJECT,
584 g_param_spec_pointer ("evas-object", "Evas Object",
585 "The Evas object where the display of the video will be done",
588 g_object_class_install_property (gobject_class, PROP_WIDTH,
589 g_param_spec_int ("width", "Width",
590 "The width of the video",
591 0, 65536, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
593 g_object_class_install_property (gobject_class, PROP_HEIGHT,
594 g_param_spec_int ("height", "Height",
595 "The height of the video",
596 0, 65536, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
598 gobject_class->dispose = evas_video_sink_dispose;
600 gstbase_sink_class->set_caps = evas_video_sink_set_caps;
601 gstbase_sink_class->stop = evas_video_sink_stop;
602 gstbase_sink_class->start = evas_video_sink_start;
603 gstbase_sink_class->unlock = evas_video_sink_unlock;
604 gstbase_sink_class->unlock_stop = evas_video_sink_unlock_stop;
605 gstbase_sink_class->render = evas_video_sink_render;
606 gstbase_sink_class->preroll = evas_video_sink_preroll;
608 evas_video_sink_signals[REPAINT_REQUESTED] = g_signal_new("repaint-requested",
609 G_TYPE_FROM_CLASS(klass),
610 (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
614 marshal_VOID__MINIOBJECT,
615 G_TYPE_NONE, 1, GST_TYPE_BUFFER);
619 gstreamer_plugin_init (GstPlugin * plugin)
621 return gst_element_register (plugin,
624 EVAS_TYPE_VIDEO_SINK);
628 gstreamer_video_sink_new(Emotion_Gstreamer_Video *ev,
635 GstStateChangeReturn res;
637 obj = _emotion_image_get(o);
640 ERR("Not Evas_Object specified");
644 playbin = gst_element_factory_make("playbin2", "playbin");
647 ERR("Unable to create 'playbin' GstElement.");
651 sink = gst_element_factory_make("emotion-sink", "sink");
654 ERR("Unable to create 'emotion-sink' GstElement.");
658 g_object_set(G_OBJECT(playbin), "video-sink", sink, NULL);
659 g_object_set(G_OBJECT(playbin), "uri", uri, NULL);
660 g_object_set(G_OBJECT(sink), "evas-object", obj, NULL);
662 res = gst_element_set_state(playbin, GST_STATE_PAUSED);
663 if (res == GST_STATE_CHANGE_FAILURE)
665 ERR("Unable to set GST_STATE_PAUSED.");
669 res = gst_element_get_state(playbin, NULL, NULL, GST_CLOCK_TIME_NONE);
670 if (res != GST_STATE_CHANGE_SUCCESS)
672 ERR("Unable to get GST_CLOCK_TIME_NONE.");
676 evas_object_data_set(obj, "_emotion_gstreamer_video", ev);
681 gst_object_unref(playbin);