ext/wayland/gstwaylandsink.c

   1 /* GStreamer Wayland video sink
   2  *
   3  * Copyright (C) 2011 Intel Corporation
   4  * Copyright (C) 2011 Sreerenj Balachandran <sreerenj.balachandran@intel.com>
   5  * Copyright (C) 2012 Wim Taymans <wim.taymans@gmail.com>
   6  * Copyright (C) 2014 Collabora Ltd.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the Free
  20  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301 USA.
  22  */
  23
  24 /**
  25  * SECTION:element-waylandsink
  26  *
  27  *  The waylandsink is creating its own window and render the decoded video frames to that.
  28  *  Setup the Wayland environment as described in
  29  *  <ulink url="http://wayland.freedesktop.org/building.html">Wayland</ulink> home page.
  30  *  The current implementaion is based on weston compositor.
  31  *
  32  * <refsect2>
  33  * <title>Example pipelines</title>
  34  * |[
  35  * gst-launch -v videotestsrc ! waylandsink
  36  * ]| test the video rendering in wayland
  37  * </refsect2>
  38  */
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include <config.h>
  42 #endif
  43
  44 #include "gstwaylandsink.h"
  45 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
  46 #include <mm_types.h>
  47 #include "tizen-wlvideoformat.h"
  48 #endif
  49 #include "wlvideoformat.h"
  50 #include "wlbuffer.h"
  51 #include "wlshmallocator.h"
  52
  53 #include <gst/wayland/wayland.h>
  54 #include <gst/video/videooverlay.h>
  55
  56
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60
  61 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
  62 #define GST_APP_EVENT_FLUSH_BUFFER_NAME "application/flush-buffer"
  63
  64 #define GST_TYPE_WAYLANDSINK_DISPLAY_GEOMETRY_METHOD (gst_waylandsink_display_geometry_method_get_type())
  65 #define GST_TYPE_WAYLANDSINK_ROTATE_ANGLE (gst_waylandsink_rotate_angle_get_type())
  66 #define GST_TYPE_WAYLANDSINK_FLIP (gst_waylandsink_flip_get_type())
  67
  68 static GType
  69 gst_waylandsink_rotate_angle_get_type (void)
  70 {
  71   static GType waylandsink_rotate_angle_type = 0;
  72   static const GEnumValue rotate_angle_type[] = {
  73     {0, "No rotate", "DEGREE_0"},
  74     {1, "Rotate 90 degree", "DEGREE_90"},
  75     {2, "Rotate 180 degree", "DEGREE_180"},
  76     {3, "Rotate 270 degree", "DEGREE_270"},
  77     {4, NULL, NULL},
  78   };
  79
  80   if (!waylandsink_rotate_angle_type) {
  81     waylandsink_rotate_angle_type =
  82         g_enum_register_static ("GstWaylandSinkRotateAngleType",
  83         rotate_angle_type);
  84   }
  85
  86   return waylandsink_rotate_angle_type;
  87 }
  88
  89
  90 static GType
  91 gst_waylandsink_display_geometry_method_get_type (void)
  92 {
  93   static GType waylandsink_display_geometry_method_type = 0;
  94   static const GEnumValue display_geometry_method_type[] = {
  95     {0, "Letter box", "LETTER_BOX"},
  96     {1, "Origin size", "ORIGIN_SIZE"},
  97     {2, "Full-screen", "FULL_SCREEN"},
  98     {3, "Cropped full-screen", "CROPPED_FULL_SCREEN"},
  99     {4, "Origin size(if screen size is larger than video size(width/height)) or Letter box(if video size(width/height) is larger than screen size)", "ORIGIN_SIZE_OR_LETTER_BOX"},
 100     {5, "Specially described destination ROI", "DISP_GEO_METHOD_CUSTOM_ROI"},
 101     {6, NULL, NULL},
 102   };
 103
 104   if (!waylandsink_display_geometry_method_type) {
 105     waylandsink_display_geometry_method_type =
 106         g_enum_register_static ("GstWaylandSinkDisplayGeometryMethodType",
 107         display_geometry_method_type);
 108   }
 109   return waylandsink_display_geometry_method_type;
 110 }
 111
 112 static GType
 113 gst_waylandsink_flip_get_type (void)
 114 {
 115   static GType waylandsink_flip_type = 0;
 116   static const GEnumValue flip_type[] = {
 117     {FLIP_NONE, "Flip NONE", "FLIP_NONE"},
 118     {FLIP_HORIZONTAL, "Flip HORIZONTAL", "FLIP_HORIZONTAL"},
 119     {FLIP_VERTICAL, "Flip VERTICAL", "FLIP_VERTICAL"},
 120     {FLIP_BOTH, "Flip BOTH", "FLIP_BOTH"},
 121     {FLIP_NUM, NULL, NULL},
 122   };
 123
 124   if (!waylandsink_flip_type) {
 125     waylandsink_flip_type =
 126         g_enum_register_static ("GstWaylandSinkFlipType", flip_type);
 127   }
 128
 129   return waylandsink_flip_type;
 130 }
 131
 132 #endif
 133
 134 /* signals */
 135 enum
 136 {
 137   SIGNAL_0,
 138 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 139   SIGNAL_HANDOFF,
 140   SIGNAL_PREROLL_HANDOFF,
 141 #endif
 142   LAST_SIGNAL
 143 };
 144
 145 /* Properties */
 146 enum
 147 {
 148   PROP_0,
 149   PROP_DISPLAY,
 150 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 151   PROP_SIGNAL_HANDOFFS,
 152   PROP_USE_GAPLESS,
 153   PROP_KEEP_CAMERA_PREVIEW,
 154   PROP_USE_TBM,
 155   PROP_ROTATE_ANGLE,
 156   PROP_DISPLAY_GEOMETRY_METHOD,
 157   PROP_FLIP,
 158   PROP_VISIBLE,
 159   PROP_FOLLOW_PARENT_TRANSFORM,
 160   PROP_CROP_X,
 161   PROP_CROP_Y,
 162   PROP_CROP_WIDTH,
 163   PROP_CROP_HEIGHT,
 164   PROP_RATIO_WIDTH,
 165   PROP_RATIO_HEIGHT,
 166   PROP_SCALE_WIDTH,
 167   PROP_SCALE_HEIGHT,
 168   PROP_OFFSET_X,
 169   PROP_OFFSET_Y,
 170   PROP_OFFSET_WIDTH,
 171   PROP_OFFSET_HEIGHT,
 172   PROP_ALIGN_WIDTH,
 173   PROP_ALIGN_HEIGHT
 174 #endif
 175 };
 176 int dump__cnt = 0;
 177
 178 GST_DEBUG_CATEGORY (gstwayland_debug);
 179 #define GST_CAT_DEFAULT gstwayland_debug
 180
 181 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
 182     GST_PAD_SINK,
 183     GST_PAD_ALWAYS,
 184     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE
 185         ("{ BGRx, BGRA, RGBx, xBGR, xRGB, RGBA, ABGR, ARGB, RGB, BGR, "
 186             "RGB16, BGR16, YUY2, YVYU, UYVY, AYUV, NV12, NV21, NV16, "
 187 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 188             "SN12, ST12, "
 189 #endif
 190             "YUV9, YVU9, Y41B, I420, YV12, Y42B, v308 }"))
 191     );
 192
 193 static void gst_wayland_sink_get_property (GObject * object,
 194     guint prop_id, GValue * value, GParamSpec * pspec);
 195 static void gst_wayland_sink_set_property (GObject * object,
 196     guint prop_id, const GValue * value, GParamSpec * pspec);
 197 static void gst_wayland_sink_finalize (GObject * object);
 198
 199 static GstStateChangeReturn gst_wayland_sink_change_state (GstElement * element,
 200     GstStateChange transition);
 201 static void gst_wayland_sink_set_context (GstElement * element,
 202     GstContext * context);
 203
 204 static GstCaps *gst_wayland_sink_get_caps (GstBaseSink * bsink,
 205     GstCaps * filter);
 206 static gboolean gst_wayland_sink_set_caps (GstBaseSink * bsink, GstCaps * caps);
 207 static gboolean gst_wayland_sink_preroll (GstBaseSink * bsink,
 208     GstBuffer * buffer);
 209 static gboolean
 210 gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query);
 211 static gboolean gst_wayland_sink_render (GstBaseSink * bsink,
 212     GstBuffer * buffer);
 213
 214 /* VideoOverlay interface */
 215 static void gst_wayland_sink_videooverlay_init (GstVideoOverlayInterface *
 216     iface);
 217 static void gst_wayland_sink_set_window_handle (GstVideoOverlay * overlay,
 218     guintptr handle);
 219 static void
 220 gst_wayland_sink_set_wl_window_wl_surface_id (GstVideoOverlay * overlay,
 221     guintptr wl_surface_id);
 222 static void gst_wayland_sink_set_render_rectangle (GstVideoOverlay * overlay,
 223     gint x, gint y, gint w, gint h);
 224 static void gst_wayland_sink_expose (GstVideoOverlay * overlay);
 225
 226 /* WaylandVideo interface */
 227 static void gst_wayland_sink_waylandvideo_init (GstWaylandVideoInterface *
 228     iface);
 229 static void gst_wayland_sink_begin_geometry_change (GstWaylandVideo * video);
 230 static void gst_wayland_sink_end_geometry_change (GstWaylandVideo * video);
 231 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 232 static gboolean gst_wayland_sink_event (GstBaseSink * bsink, GstEvent * event);
 233 static void gst_wayland_sink_update_window_geometry (GstWaylandSink * sink);
 234 static void render_last_buffer (GstWaylandSink * sink);
 235
 236 static guint gst_waylandsink_signals[LAST_SIGNAL] = { 0 };
 237
 238 #endif
 239 #define gst_wayland_sink_parent_class parent_class
 240 G_DEFINE_TYPE_WITH_CODE (GstWaylandSink, gst_wayland_sink, GST_TYPE_VIDEO_SINK,
 241     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
 242         gst_wayland_sink_videooverlay_init)
 243     G_IMPLEMENT_INTERFACE (GST_TYPE_WAYLAND_VIDEO,
 244         gst_wayland_sink_waylandvideo_init));
 245
 246 static void
 247 gst_wayland_sink_class_init (GstWaylandSinkClass * klass)
 248 {
 249   GObjectClass *gobject_class;
 250   GstElementClass *gstelement_class;
 251   GstBaseSinkClass *gstbasesink_class;
 252   FUNCTION;
 253
 254   gobject_class = (GObjectClass *) klass;
 255   gstelement_class = (GstElementClass *) klass;
 256   gstbasesink_class = (GstBaseSinkClass *) klass;
 257
 258   gobject_class->set_property = gst_wayland_sink_set_property;
 259   gobject_class->get_property = gst_wayland_sink_get_property;
 260   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_wayland_sink_finalize);
 261
 262   gst_element_class_add_pad_template (gstelement_class,
 263       gst_static_pad_template_get (&sink_template));
 264
 265   gst_element_class_set_static_metadata (gstelement_class,
 266       "wayland video sink", "Sink/Video",
 267       "Output to wayland surface",
 268       "Sreerenj Balachandran <sreerenj.balachandran@intel.com>, "
 269       "George Kiagiadakis <george.kiagiadakis@collabora.com>");
 270
 271   gstelement_class->change_state =
 272       GST_DEBUG_FUNCPTR (gst_wayland_sink_change_state);
 273   gstelement_class->set_context =
 274       GST_DEBUG_FUNCPTR (gst_wayland_sink_set_context);
 275
 276   gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_wayland_sink_get_caps);
 277   gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_wayland_sink_set_caps);
 278   gstbasesink_class->preroll = GST_DEBUG_FUNCPTR (gst_wayland_sink_preroll);
 279   gstbasesink_class->propose_allocation =
 280       GST_DEBUG_FUNCPTR (gst_wayland_sink_propose_allocation);
 281   gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_wayland_sink_render);
 282 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 283   gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_wayland_sink_event);
 284 #endif
 285
 286   g_object_class_install_property (gobject_class, PROP_DISPLAY,
 287       g_param_spec_string ("display", "Wayland Display name", "Wayland "
 288           "display name to connect to, if not supplied via the GstContext",
 289           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 290
 291 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 292   g_object_class_install_property (gobject_class, PROP_KEEP_CAMERA_PREVIEW,
 293       g_param_spec_boolean ("keep-camera-preview", "use flush buffer mechanism",
 294           "Last tbm buffer is copied and returned to camerasrc immediately "
 295           "when state change(PAUSED_TO_READY)", FALSE,
 296           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 297
 298   g_object_class_install_property (gobject_class, PROP_USE_TBM,
 299       g_param_spec_boolean ("use-tbm", "use tbm buffer",
 300           "Use Tizen Buffer Memory insted of Shared memory, "
 301           "Memory is alloced by TBM insted of SHM when enabled", TRUE,
 302           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 303
 304   g_object_class_install_property (gobject_class, PROP_ROTATE_ANGLE,
 305       g_param_spec_enum ("rotate", "Rotate angle",
 306           "Rotate angle of display output",
 307           GST_TYPE_WAYLANDSINK_ROTATE_ANGLE, DEGREE_0,
 308           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 309
 310   g_object_class_install_property (gobject_class, PROP_DISPLAY_GEOMETRY_METHOD,
 311       g_param_spec_enum ("display-geometry-method", "Display geometry method",
 312           "Geometrical method for display",
 313           GST_TYPE_WAYLANDSINK_DISPLAY_GEOMETRY_METHOD,
 314           DEF_DISPLAY_GEOMETRY_METHOD,
 315           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 316
 317   g_object_class_install_property (gobject_class, PROP_FLIP,
 318       g_param_spec_enum ("flip", "Display flip",
 319           "Flip for display",
 320           GST_TYPE_WAYLANDSINK_FLIP, DEF_DISPLAY_FLIP,
 321           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 322
 323   g_object_class_install_property (gobject_class, PROP_VISIBLE,
 324       g_param_spec_boolean ("visible", "Visible",
 325           "Draws screen or blacks out, true means visible, false blacks out",
 326           TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 327
 328 #ifdef ENABLE_FUNCTION
 329   g_object_class_install_property (gobject_class, PROP_SCALE_WIDTH,
 330       g_param_spec_double ("scale-w", "ratio width",
 331           "scale width for rendering video,"
 332           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0.0,
 333           G_MAXDOUBLE, 1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 334
 335   g_object_class_install_property (gobject_class, PROP_SCALE_HEIGHT,
 336       g_param_spec_double ("scale-h", "scale height",
 337           "scale width for rendering video, "
 338           "Function is not support in DISP_GEO_METHOD_CUSTOM_ROI. ", 0.0,
 339           G_MAXDOUBLE, 1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 340
 341   g_object_class_install_property (gobject_class, PROP_FOLLOW_PARENT_TRANSFORM,
 342       g_param_spec_boolean ("follow-parent-transform",
 343           "follow parent transform",
 344           "Video is rotated automatically without setting rotate property by rotating Display"
 345           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", TRUE,
 346           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 347
 348   g_object_class_install_property (gobject_class, PROP_CROP_X,
 349       g_param_spec_uint ("crop-x", "crop x",
 350           "x-coordinate for cropping video. "
 351           "Please set crop-x, crop-y, crop-w and crop-h togethrer. "
 352           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 353           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 354
 355   g_object_class_install_property (gobject_class, PROP_CROP_Y,
 356       g_param_spec_uint ("crop-y", "crop y",
 357           "y-coordinate for cropping video. "
 358           "Please set crop-x, crop-y, crop-w and crop-h togethrer. "
 359           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 360           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 361
 362   g_object_class_install_property (gobject_class, PROP_CROP_WIDTH,
 363       g_param_spec_uint ("crop-w", "crop width",
 364           "width for cropping video. "
 365           "If value is not set or is set 0, Width is set to video width after set_caps. "
 366           "Please set crop-x, crop-y, crop-w and crop-h togethrer. "
 367           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 368           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 369
 370   g_object_class_install_property (gobject_class, PROP_CROP_HEIGHT,
 371       g_param_spec_uint ("crop-h", "crop height",
 372           "height for cropping video. "
 373           "If value is not set or is set 0, Hight is set to video height after set_caps. "
 374           "Please set crop-x, crop-y, crop-w and crop-h togethrer. "
 375           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 376           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 377
 378   g_object_class_install_property (gobject_class, PROP_RATIO_WIDTH,
 379       g_param_spec_double ("ratio-w", "ratio width",
 380           "ratio width for rendering video,"
 381           "If value is set, Original video ratio is ignored. to restore original size, set to -1"
 382           "Please set ratio-w and ratio-h togethrer. "
 383           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", -1.0,
 384           G_MAXDOUBLE, -1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 385
 386   g_object_class_install_property (gobject_class, PROP_RATIO_HEIGHT,
 387       g_param_spec_double ("ratio-h", "ratio height",
 388           "ratio width for rendering video, "
 389           "If value is set, Original video ratio is ignored. to restore original size, set to -1"
 390           "Please set ratio-w and ratio-h togethrer. "
 391           "Function is not support in DISP_GEO_METHOD_CUSTOM_ROI. ", -1.0,
 392           G_MAXDOUBLE, -1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 393
 394   g_object_class_install_property (gobject_class, PROP_OFFSET_X,
 395       g_param_spec_uint ("offset-x", "offset x",
 396           "x offset for moving x-coordinate of video pixel, "
 397           "Please set x, y, w and h offset togethrer"
 398           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 399           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 400
 401   g_object_class_install_property (gobject_class, PROP_OFFSET_Y,
 402       g_param_spec_uint ("offset-y", "offset y",
 403           "y offset for moving y-coordinate of video pixel, "
 404           "Please set x, y, w and h offset togethrer"
 405           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 406           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 407
 408   g_object_class_install_property (gobject_class, PROP_OFFSET_WIDTH,
 409       g_param_spec_uint ("offset-w", "offset width",
 410           "width offset for adjusting width of of video pixel, "
 411           "Please set x, y, w and h offset togethrer"
 412           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 413           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 414
 415   g_object_class_install_property (gobject_class, PROP_OFFSET_HEIGHT,
 416       g_param_spec_uint ("offset-h", "offset height",
 417           "height offset for adjusting height of of video pixel"
 418           "Please set x, y, w and h offset togethrer"
 419           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0,
 420           G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 421
 422   g_object_class_install_property (gobject_class, PROP_ALIGN_WIDTH,
 423       g_param_spec_double ("align-w", "align width",
 424           "Align with, Left: 0.0, Middle: 0.5, Right: 1.0, "
 425           "Please set align-w and align-h togethrer"
 426           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0.0,
 427           1.0, 0.5, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 428
 429   g_object_class_install_property (gobject_class, PROP_ALIGN_HEIGHT,
 430       g_param_spec_double ("align-h", "align height",
 431           "Align height, Left: 0.0, Middle: 0.5, Right: 1.0, "
 432           "Please set align-w and align-h togethrer"
 433           "Function is not supported in DISP_GEO_METHOD_CUSTOM_ROI. ", 0.0,
 434           1.0, 0.5, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 435 #endif
 436
 437   /* fakesink function for stream callback of MSL with browser */
 438   g_object_class_install_property (gobject_class, PROP_SIGNAL_HANDOFFS,
 439       g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
 440           "Send a signal before unreffing the buffer", FALSE,
 441           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 442
 443   gst_waylandsink_signals[SIGNAL_HANDOFF] =
 444       g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 445       G_STRUCT_OFFSET (GstWaylandSinkClass, handoff), NULL, NULL,
 446       g_cclosure_marshal_generic, G_TYPE_NONE, 2,
 447       GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE, GST_TYPE_PAD);
 448
 449   gst_waylandsink_signals[SIGNAL_PREROLL_HANDOFF] =
 450       g_signal_new ("preroll-handoff", G_TYPE_FROM_CLASS (klass),
 451       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstWaylandSinkClass, preroll_handoff),
 452       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2,
 453       GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE, GST_TYPE_PAD);
 454
 455 #endif
 456 }
 457
 458 #ifdef DUMP_BUFFER
 459 int
 460 __write_rawdata (const char *file, const void *data, unsigned int size)
 461 {
 462   FILE *fp;
 463
 464   fp = fopen (file, "wb");
 465   if (fp == NULL)
 466     return -1;
 467
 468   fwrite ((char *) data, sizeof (char), size, fp);
 469   fclose (fp);
 470
 471   return 0;
 472 }
 473 #endif
 474 static void
 475 gst_wayland_sink_init (GstWaylandSink * sink)
 476 {
 477   FUNCTION;
 478 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 479   sink->signal_handoffs = FALSE;
 480   sink->request_camera_flush_buf = FALSE;
 481   sink->keep_camera_preview = FALSE;
 482   sink->got_costum_event = FALSE;
 483   sink->USE_TBM = TRUE;
 484   sink->display_geometry_method = DEF_DISPLAY_GEOMETRY_METHOD;
 485   sink->flip = DEF_DISPLAY_FLIP;
 486   sink->rotate_angle = DEGREE_0;
 487   sink->visible = TRUE;
 488   sink->crop_x = sink->crop_y = sink->crop_w = sink->crop_h = 0;
 489 #ifdef ENABLE_FUNCTION
 490   sink->follow_parent_transform = FALSE;
 491   sink->ratio_w = sink->ratio_h = -1.0; //need to set -1.0 for original video ratio
 492   sink->align_w = sink->align_h = 0.5;
 493   sink->scale_w = sink->scale_h = 1.0;
 494   sink->offset_x = sink->offset_y = sink->offset_w = sink->offset_h = 0;
 495 #endif
 496 #endif
 497   g_mutex_init (&sink->display_lock);
 498   g_mutex_init (&sink->render_lock);
 499 }
 500
 501 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 502 static void
 503 gst_wayland_sink_stop_video (GstWaylandSink * sink)
 504 {
 505   FUNCTION;
 506   g_return_if_fail (sink != NULL);
 507   gst_wl_window_render (sink->window, NULL, NULL);
 508 }
 509
 510 static int
 511 gst_wayland_sink_check_use_gapless (GstWaylandSink * sink)
 512 {
 513   g_return_val_if_fail (sink != NULL, FALSE);
 514   g_return_val_if_fail (sink->display != NULL, FALSE);
 515
 516   if (sink->got_costum_event && sink->USE_TBM
 517       && sink->display->is_native_format)
 518     return TRUE;
 519
 520   return FALSE;
 521 }
 522
 523 static int
 524 gst_wayland_sink_need_to_make_flush_buffer (GstWaylandSink * sink)
 525 {
 526   g_return_val_if_fail (sink != NULL, FALSE);
 527   g_return_val_if_fail (sink->display != NULL, FALSE);
 528
 529   if ((gst_wayland_sink_check_use_gapless (sink))
 530       || sink->request_camera_flush_buf || sink->display->flush_request) {
 531     sink->display->flush_request = TRUE;
 532     return TRUE;
 533   }
 534   return FALSE;
 535 }
 536
 537 static void
 538 gst_wayland_sink_update_last_buffer_geometry (GstWaylandSink * sink)
 539 {
 540   GstWlBuffer *wlbuffer;
 541   gboolean no_render_buffer = FALSE;
 542   FUNCTION;
 543   g_return_if_fail (sink != NULL);
 544   g_return_if_fail (sink->last_buffer != NULL);
 545   wlbuffer = gst_buffer_get_wl_buffer (sink->last_buffer);
 546
 547   g_return_if_fail (wlbuffer != NULL);
 548
 549   if (wlbuffer->used_by_compositor) {
 550     /* used last buffer by compositor don't receive buffer-release-event when attach */
 551     wlbuffer->used_by_compositor = FALSE;
 552   } else {
 553     /* unused last buffer by compositor will receive buffer release event when attach */
 554     no_render_buffer = TRUE;
 555   }
 556
 557   GST_LOG ("gstbuffer(%p) ref_count(%d)", sink->last_buffer,
 558       GST_OBJECT_REFCOUNT_VALUE (sink->last_buffer));
 559
 560   if (sink->visible) {
 561     /* need to render last buffer, reuse current GstWlBuffer */
 562     render_last_buffer (sink);
 563
 564     /* ref count is incresed in gst_wl_buffer_attach() of render_last_buffer(),
 565        to call gst_wl_buffer_finalize(), we need to decrease buffer ref count.
 566        wayland server can not release buffer if we attach same buffer and
 567        videosink can not receive buffer-release-event. if we use no visible,
 568        we need to attach null buffer and videosink can receive buffer-release-event */
 569
 570     /* need to decrease buffer ref_count, if no_render_buffer is TRUE,
 571        buffer is attached firstly so, videosink can receive buffer-release-event */
 572     if (no_render_buffer) {
 573       GST_LOG ("skip unref.. will get buffer-release-event");
 574     } else {
 575       gst_buffer_unref (wlbuffer->gstbuffer);
 576     }
 577
 578   } else {
 579     GST_LOG ("skip rendering");
 580   }
 581
 582   GST_LOG ("gstbuffer(%p) ref_count(%d)", sink->last_buffer,
 583       GST_OBJECT_REFCOUNT_VALUE (sink->last_buffer));
 584
 585 }
 586
 587 #ifdef USE_WL_FLUSH_BUFFER
 588 static int
 589 gst_wayland_sink_make_flush_buffer (GstWlDisplay * display,
 590     MMVideoBuffer * mm_video_buf)
 591 {
 592   GstWlFlushBuffer *flush_buffer = NULL;
 593   tbm_bo bo = NULL;
 594   int bo_size = 0;
 595   int i;
 596   FUNCTION;
 597
 598   g_return_val_if_fail (display != NULL, FALSE);
 599   g_return_val_if_fail (mm_video_buf != NULL, FALSE);
 600
 601   flush_buffer = (GstWlFlushBuffer *) malloc (sizeof (GstWlFlushBuffer));
 602   if (!flush_buffer) {
 603     GST_ERROR ("GstWlFlushBuffer alloc faile");
 604     return FALSE;
 605   }
 606   memset (flush_buffer, 0x0, sizeof (GstWlFlushBuffer));
 607
 608   display->flush_tbm_bufmgr =
 609       wayland_tbm_client_get_bufmgr (display->tbm_client);
 610   g_return_val_if_fail (display->flush_tbm_bufmgr != NULL, FALSE);
 611
 612   for (i = 0; i < NV_BUF_PLANE_NUM; i++) {
 613     if (mm_video_buf->handle.bo[i] != NULL) {
 614       tbm_bo_handle src;
 615       tbm_bo_handle dst;
 616
 617       /* get bo size */
 618       bo_size = tbm_bo_size (mm_video_buf->handle.bo[i]);
 619       GST_LOG ("tbm bo size: %d", bo_size);
 620       /* alloc bo */
 621       bo = tbm_bo_alloc (display->flush_tbm_bufmgr, bo_size, TBM_DEVICE_CPU);
 622       if (!bo) {
 623         GST_ERROR ("alloc tbm bo(size:%d) failed: %s", bo_size,
 624             strerror (errno));
 625         return FALSE;
 626       }
 627       GST_LOG ("flush buffer tbm_bo =(%p)", bo);
 628       flush_buffer->bo[i] = bo;
 629       /* get virtual address */
 630       src.ptr = dst.ptr = NULL;
 631       /* bo map, we can use tbm_bo_map too. */
 632       src = tbm_bo_get_handle (mm_video_buf->handle.bo[i], TBM_DEVICE_CPU);
 633       dst = tbm_bo_get_handle (bo, TBM_DEVICE_CPU);
 634       if (!src.ptr || !dst.ptr) {
 635         GST_ERROR ("get tbm bo handle failed src(%p) dst(%p): %s", src.ptr,
 636             dst.ptr, strerror (errno));
 637         tbm_bo_unref (mm_video_buf->handle.bo[i]);
 638         tbm_bo_unref (bo);
 639         return FALSE;
 640       }
 641       /* copy */
 642       memcpy (dst.ptr, src.ptr, bo_size);
 643       /* bo unmap */
 644       tbm_bo_unmap (mm_video_buf->handle.bo[i]);
 645       tbm_bo_unmap (bo);
 646     }
 647   }
 648   display->flush_buffer = flush_buffer;
 649   return TRUE;
 650 }
 651
 652 static int
 653 gst_wayland_sink_copy_mm_video_buf_info_to_flush (GstWlDisplay * display,
 654     MMVideoBuffer * mm_video_buf)
 655 {
 656   int ret = FALSE;
 657   g_return_val_if_fail (display != NULL, FALSE);
 658   g_return_val_if_fail (mm_video_buf != NULL, FALSE);
 659   FUNCTION;
 660
 661   ret = gst_wayland_sink_make_flush_buffer (display, mm_video_buf);
 662   if (ret) {
 663     int i;
 664     for (i = 0; i < NV_BUF_PLANE_NUM; i++) {
 665       if (display->flush_buffer->bo[i] != NULL) {
 666         display->bo[i] = display->flush_buffer->bo[i];
 667         GST_LOG ("bo %p", display->bo[i]);
 668       } else {
 669         display->bo[i] = 0;
 670       }
 671       display->plane_size[i] = mm_video_buf->size[i];
 672       display->stride_width[i] = mm_video_buf->stride_width[i];
 673       display->stride_height[i] = mm_video_buf->stride_height[i];
 674       display->native_video_size += display->plane_size[i];
 675     }
 676     memset (mm_video_buf, 0, sizeof (MMVideoBuffer));
 677   }
 678   return ret;
 679 }
 680 #endif
 681
 682 static void
 683 gst_wayland_sink_add_mm_video_buf_info (GstWlDisplay * display,
 684     MMVideoBuffer * mm_video_buf)
 685 {
 686   int i;
 687   g_return_if_fail (display != NULL);
 688   g_return_if_fail (mm_video_buf != NULL);
 689   FUNCTION;
 690
 691   for (i = 0; i < NV_BUF_PLANE_NUM; i++) {
 692     if (mm_video_buf->handle.bo[i] != NULL) {
 693       display->bo[i] = mm_video_buf->handle.bo[i];
 694     } else {
 695       display->bo[i] = 0;
 696     }
 697     display->plane_size[i] = mm_video_buf->size[i];
 698     display->stride_width[i] = mm_video_buf->stride_width[i];
 699     display->stride_height[i] = mm_video_buf->stride_height[i];
 700     display->native_video_size += display->plane_size[i];
 701   }
 702 }
 703
 704 static int
 705 gst_wayland_sink_get_mm_video_buf_info (GstWaylandSink * sink,
 706     GstBuffer * buffer)
 707 {
 708   GstWlDisplay *display;
 709   GstMemory *mem;
 710   GstMapInfo mem_info = GST_MAP_INFO_INIT;
 711   MMVideoBuffer *mm_video_buf = NULL;
 712
 713   g_return_val_if_fail (sink != NULL, FALSE);
 714   g_return_val_if_fail (buffer != NULL, FALSE);
 715
 716   FUNCTION;
 717   display = sink->display;
 718   g_return_val_if_fail (sink->display != NULL, FALSE);
 719
 720   mem = gst_buffer_peek_memory (buffer, 1);
 721   gst_memory_map (mem, &mem_info, GST_MAP_READ);
 722   mm_video_buf = (MMVideoBuffer *) mem_info.data;
 723   gst_memory_unmap (mem, &mem_info);
 724
 725   if (mm_video_buf == NULL) {
 726     GST_WARNING ("mm_video_buf is NULL. Skip rendering");
 727     return FALSE;
 728   }
 729   /* assign mm_video_buf info */
 730   if (mm_video_buf->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
 731     GST_DEBUG ("TBM bo %p %p", mm_video_buf->handle.bo[0],
 732         mm_video_buf->handle.bo[1]);
 733     display->native_video_size = 0;
 734     display->flush_request = 0;
 735     display->flush_request = mm_video_buf->flush_request;
 736     GST_DEBUG ("flush_request value is %d", display->flush_request);
 737 #ifdef USE_WL_FLUSH_BUFFER
 738     if (gst_wayland_sink_need_to_make_flush_buffer (sink)) {
 739       if (!gst_wayland_sink_copy_mm_video_buf_info_to_flush (display,
 740               mm_video_buf)) {
 741         GST_ERROR ("cat not copy mm_video_buf info to flush");
 742         return FALSE;
 743       }
 744     } else
 745 #endif
 746       /* normal routine */
 747       gst_wayland_sink_add_mm_video_buf_info (display, mm_video_buf);
 748   } else {
 749     GST_ERROR ("Buffer type is not TBM");
 750     return FALSE;
 751   }
 752   return TRUE;
 753 }
 754
 755 static void
 756 gst_wayland_sink_render_flush_buffer (GstBaseSink * bsink)
 757 {
 758   GstWaylandSink *sink;
 759   GstBuffer *buffer;
 760   sink = GST_WAYLAND_SINK (bsink);
 761   FUNCTION;
 762   g_return_if_fail (sink != NULL);
 763   g_return_if_fail (sink->last_buffer != NULL);
 764
 765   buffer = gst_buffer_copy_deep (sink->last_buffer);
 766
 767   gst_wayland_sink_render (bsink, buffer);
 768   if (buffer)
 769     gst_buffer_unref (buffer);
 770 }
 771
 772 static void
 773 gst_wayland_sink_gapless_render (GstBaseSink * bsink)
 774 {
 775   g_return_if_fail (bsink != NULL);
 776   FUNCTION;
 777   gst_wayland_sink_render_flush_buffer (bsink);
 778 }
 779
 780 static void
 781 gst_wayland_sink_keep_camera_preview (GstBaseSink * bsink)
 782 {
 783   g_return_if_fail (bsink != NULL);
 784   FUNCTION;
 785   gst_wayland_sink_render_flush_buffer (bsink);
 786 }
 787
 788 #endif
 789
 790 static void
 791 gst_wayland_sink_get_property (GObject * object,
 792     guint prop_id, GValue * value, GParamSpec * pspec)
 793 {
 794   GstWaylandSink *sink = GST_WAYLAND_SINK (object);
 795   FUNCTION;
 796
 797   switch (prop_id) {
 798     case PROP_DISPLAY:
 799       GST_OBJECT_LOCK (sink);
 800       g_value_set_string (value, sink->display_name);
 801       GST_OBJECT_UNLOCK (sink);
 802       break;
 803 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 804     case PROP_KEEP_CAMERA_PREVIEW:
 805       g_value_set_boolean (value, sink->keep_camera_preview);
 806       break;
 807     case PROP_SIGNAL_HANDOFFS:
 808       g_value_set_boolean (value, sink->signal_handoffs);
 809       break;
 810     case PROP_USE_TBM:
 811       g_value_set_boolean (value, sink->USE_TBM);
 812       break;
 813     case PROP_ROTATE_ANGLE:
 814       g_value_set_enum (value, sink->rotate_angle);
 815       break;
 816     case PROP_DISPLAY_GEOMETRY_METHOD:
 817       g_value_set_enum (value, sink->display_geometry_method);
 818       break;
 819     case PROP_FLIP:
 820       g_value_set_enum (value, sink->flip);
 821       break;
 822     case PROP_VISIBLE:
 823       g_value_set_boolean (value, sink->visible);
 824       break;
 825 #ifdef ENABLE_FUNCTION
 826     case PROP_SCALE_WIDTH:
 827       g_value_set_double (value, sink->scale_w);
 828       break;
 829     case PROP_SCALE_HEIGHT:
 830       g_value_set_double (value, sink->scale_h);
 831       break;
 832     case PROP_FOLLOW_PARENT_TRANSFORM:
 833       g_value_set_boolean (value, sink->follow_parent_transform);
 834       break;
 835     case PROP_CROP_X:
 836       g_value_set_uint (value, sink->crop_x);
 837       break;
 838     case PROP_CROP_Y:
 839       g_value_set_uint (value, sink->crop_y);
 840       break;
 841     case PROP_CROP_WIDTH:
 842       g_value_set_uint (value, sink->crop_w);
 843       break;
 844     case PROP_CROP_HEIGHT:
 845       g_value_set_uint (value, sink->crop_h);
 846       break;
 847     case PROP_RATIO_WIDTH:
 848       g_value_set_double (value, sink->ratio_w);
 849       break;
 850     case PROP_RATIO_HEIGHT:
 851       g_value_set_double (value, sink->ratio_h);
 852       break;
 853     case PROP_OFFSET_X:
 854       g_value_set_uint (value, sink->offset_x);
 855       break;
 856     case PROP_OFFSET_Y:
 857       g_value_set_uint (value, sink->offset_y);
 858       break;
 859     case PROP_OFFSET_WIDTH:
 860       g_value_set_uint (value, sink->offset_w);
 861       break;
 862     case PROP_OFFSET_HEIGHT:
 863       g_value_set_uint (value, sink->offset_h);
 864       break;
 865     case PROP_ALIGN_WIDTH:
 866       g_value_set_double (value, sink->align_w);
 867       break;
 868     case PROP_ALIGN_HEIGHT:
 869       g_value_set_double (value, sink->align_h);
 870       break;
 871 #endif
 872 #endif
 873     default:
 874       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 875       break;
 876   }
 877 }
 878
 879 static void
 880 gst_wayland_sink_set_property (GObject * object,
 881     guint prop_id, const GValue * value, GParamSpec * pspec)
 882 {
 883   GstWaylandSink *sink = GST_WAYLAND_SINK (object);
 884   FUNCTION;
 885   g_mutex_lock (&sink->render_lock);
 886
 887   switch (prop_id) {
 888     case PROP_DISPLAY:
 889       GST_OBJECT_LOCK (sink);
 890       sink->display_name = g_value_dup_string (value);
 891       GST_OBJECT_UNLOCK (sink);
 892       break;
 893 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
 894     case PROP_SIGNAL_HANDOFFS:
 895       sink->signal_handoffs = g_value_get_boolean (value);
 896       GST_LOG ("set signal_handoffs(%d)", sink->signal_handoffs);
 897       if (sink->signal_handoffs && sink->window) {
 898         /* overlay -> hand-off */
 899         gst_wayland_sink_stop_video (sink);
 900       }
 901       break;
 902     case PROP_KEEP_CAMERA_PREVIEW:
 903       sink->keep_camera_preview = g_value_get_boolean (value);
 904       GST_LOG ("keep_camera_preview (%d)", sink->keep_camera_preview);
 905       break;
 906     case PROP_USE_TBM:
 907       sink->USE_TBM = g_value_get_boolean (value);
 908       GST_LOG ("1:USE TBM 0: USE SHM set(%d)", sink->USE_TBM);
 909       break;
 910     case PROP_ROTATE_ANGLE:
 911       if (sink->rotate_angle == g_value_get_enum (value))
 912         break;
 913       sink->rotate_angle = g_value_get_enum (value);
 914       GST_WARNING_OBJECT (sink, "Rotate angle is set (%d)", sink->rotate_angle);
 915       sink->video_info_changed = TRUE;
 916       if (sink->window) {
 917         gst_wl_window_set_rotate_angle (sink->window, sink->rotate_angle);
 918       }
 919       break;
 920     case PROP_DISPLAY_GEOMETRY_METHOD:
 921       if (sink->display_geometry_method == g_value_get_enum (value))
 922         break;
 923       sink->display_geometry_method = g_value_get_enum (value);
 924       GST_WARNING_OBJECT (sink, "Display geometry method is set (%d)",
 925           sink->display_geometry_method);
 926       sink->video_info_changed = TRUE;
 927       if (sink->window) {
 928         gst_wl_window_set_destination_mode (sink->window,
 929             sink->display_geometry_method);
 930       }
 931       break;
 932     case PROP_FLIP:
 933       if (sink->flip == g_value_get_enum (value))
 934         break;
 935       sink->flip = g_value_get_enum (value);
 936       GST_WARNING_OBJECT (sink, "flip is set (%d)", sink->flip);
 937       sink->video_info_changed = TRUE;
 938       if (sink->window) {
 939         gst_wl_window_set_flip (sink->window, sink->flip);
 940       }
 941       break;
 942     case PROP_VISIBLE:
 943       if (sink->visible == g_value_get_boolean (value))
 944         break;
 945       sink->visible = g_value_get_boolean (value);
 946       GST_WARNING_OBJECT (sink, "visible is set (%d)", sink->visible);
 947       if (sink->visible && GST_STATE (sink) == GST_STATE_PAUSED) {
 948         /* need to attatch last buffer */
 949         sink->video_info_changed = TRUE;
 950       } else if (!sink->visible && GST_STATE (sink) >= GST_STATE_PAUSED) {
 951         /* video stop */
 952         if (sink->window) {
 953           gst_wayland_sink_stop_video (sink);
 954         }
 955       }
 956       break;
 957 #ifdef ENABLE_FUNCTION
 958     case PROP_SCALE_WIDTH:
 959       if (sink->scale_w == g_value_get_double (value)
 960           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
 961         break;
 962       sink->scale_w = g_value_get_double (value);
 963       GST_WARNING_OBJECT (sink, "scale-w is set (%f)", sink->scale_w);
 964       sink->video_info_changed = TRUE;
 965       if (sink->window)
 966         gst_wl_window_set_destination_mode_scale (sink->window, sink->scale_w,
 967             sink->scale_h);
 968       break;
 969     case PROP_SCALE_HEIGHT:
 970       if (sink->scale_h == g_value_get_double (value)
 971           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
 972         break;
 973       sink->scale_h = g_value_get_double (value);
 974       GST_WARNING_OBJECT (sink, "scale-h is set (%f)", sink->scale_h);
 975       sink->video_info_changed = TRUE;
 976       if (sink->window)
 977         gst_wl_window_set_destination_mode_scale (sink->window, sink->scale_w,
 978             sink->scale_h);
 979       break;
 980     case PROP_FOLLOW_PARENT_TRANSFORM:
 981       if (sink->follow_parent_transform == g_value_get_boolean (value)
 982           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
 983         break;
 984       sink->follow_parent_transform = g_value_get_boolean (value);
 985       GST_WARNING_OBJECT (sink, "follow parent transform is set (%d)",
 986           sink->follow_parent_transform);
 987       sink->video_info_changed = TRUE;
 988       if (sink->window) {
 989         gst_wl_window_set_destination_mode_follow_parent_transform
 990             (sink->window, sink->follow_parent_transform);
 991       }
 992       break;
 993     case PROP_CROP_X:
 994       if (sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
 995         break;
 996       sink->crop_x = g_value_get_uint (value);
 997       GST_WARNING_OBJECT (sink, "crop-x is set (%d)", sink->crop_x);
 998       break;
 999     case PROP_CROP_Y:
1000       if (sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1001         break;
1002       sink->crop_y = g_value_get_uint (value);
1003       GST_WARNING_OBJECT (sink, "crop-y is set (%d)", sink->crop_y);
1004       break;
1005     case PROP_CROP_WIDTH:
1006       if (sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1007         break;
1008       sink->crop_w = g_value_get_uint (value);
1009       GST_WARNING_OBJECT (sink, "crop_w is set (%d)", sink->crop_w);
1010       /* crop-w is unset by 0, set to video width size */
1011       if (sink->crop_w == 0 && sink->video_info.width > 0) {
1012         sink->crop_w =
1013             gst_util_uint64_scale_int_round (sink->video_info.width,
1014             sink->video_info.par_n, sink->video_info.par_d);
1015         GST_LOG ("crop-w is unset by 0, set to video width size(%d)",
1016             sink->crop_w);
1017       }
1018       break;
1019     case PROP_CROP_HEIGHT:
1020       if (sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1021         break;
1022       sink->crop_h = g_value_get_uint (value);
1023       GST_WARNING_OBJECT (sink, "crop-h is set (%d)", sink->crop_h);
1024       /* crop-h unset by 0, set to video height size */
1025       if (sink->crop_h == 0 && sink->video_info.height > 0) {
1026         sink->crop_h = sink->video_info.height;
1027         GST_LOG ("crop-h is unset by 0, set to video height size(%d)",
1028             sink->crop_h);
1029       }
1030       sink->video_info_changed = TRUE;
1031       if (sink->window && sink->crop_w > 0 && sink->crop_h > 0) {
1032         gst_wl_window_set_destination_mode_crop_wl_buffer (sink->window,
1033             sink->crop_x, sink->crop_y, sink->crop_w, sink->crop_h);
1034       }
1035       break;
1036     case PROP_RATIO_WIDTH:
1037       if (sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1038         break;
1039       sink->ratio_w = g_value_get_double (value);
1040       GST_WARNING_OBJECT (sink, "ratio-w is set (%f)", sink->ratio_w);
1041       break;
1042     case PROP_RATIO_HEIGHT:
1043       if (sink->scale_w == g_value_get_double (value)
1044           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1045         break;
1046       sink->ratio_h = g_value_get_double (value);
1047       GST_WARNING_OBJECT (sink, "ratio-h is set (%f)", sink->ratio_h);
1048       sink->video_info_changed = TRUE;
1049       if (sink->window)
1050         gst_wl_window_set_destination_mode_ratio (sink->window, sink->ratio_w,
1051             sink->ratio_h);
1052       break;
1053     case PROP_OFFSET_X:
1054       if (sink->offset_x == g_value_get_uint (value)
1055           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1056         break;
1057       sink->offset_x = g_value_get_uint (value);
1058       GST_WARNING_OBJECT (sink, "offset-x is set (%d)", sink->offset_x);
1059       break;
1060     case PROP_OFFSET_Y:
1061       if (sink->offset_y == g_value_get_uint (value)
1062           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1063         break;
1064       sink->offset_y = g_value_get_uint (value);
1065       GST_WARNING_OBJECT (sink, "offset-y is set (%d)", sink->offset_y);
1066       break;
1067     case PROP_OFFSET_WIDTH:
1068       if (sink->offset_w == g_value_get_uint (value)
1069           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1070         break;
1071       sink->offset_w = g_value_get_uint (value);
1072       GST_WARNING_OBJECT (sink, "offset-w is set (%d)", sink->offset_w);
1073       break;
1074     case PROP_OFFSET_HEIGHT:
1075       if (sink->offset_h == g_value_get_uint (value)
1076           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1077         break;
1078       sink->offset_h = g_value_get_uint (value);
1079       GST_WARNING_OBJECT (sink, "offset-h is set (%d)", sink->offset_h);
1080       sink->video_info_changed = TRUE;
1081       if (sink->window)
1082         gst_wl_window_set_destination_mode_offset (sink->window, sink->offset_x,
1083             sink->offset_y, sink->offset_w, sink->offset_h);
1084       break;
1085     case PROP_ALIGN_WIDTH:
1086       if (sink->align_w == g_value_get_double (value)
1087           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1088         break;
1089       sink->align_w = g_value_get_double (value);
1090       GST_WARNING_OBJECT (sink, "align_w is set (%f)", sink->align_w);
1091       break;
1092     case PROP_ALIGN_HEIGHT:
1093       if (sink->align_h == g_value_get_double (value)
1094           || sink->display_geometry_method == DISP_GEO_METHOD_CUSTOM_ROI)
1095         break;
1096       sink->align_h = g_value_get_double (value);
1097       GST_WARNING_OBJECT (sink, "align_h is set (%f)", sink->align_h);
1098       sink->video_info_changed = TRUE;
1099       if (sink->window)
1100         gst_wl_window_set_destination_mode_align (sink->window, sink->align_w,
1101             sink->align_h);
1102       break;
1103 #endif
1104 #endif
1105     default:
1106       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1107       break;
1108   }
1109 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1110   if (sink->video_info_changed && sink->window) {
1111     gst_wl_window_set_video_info_change (sink->window, TRUE);
1112     if (GST_STATE (sink) == GST_STATE_PAUSED)
1113       gst_wayland_sink_update_last_buffer_geometry (sink);
1114   }
1115 #endif
1116   g_mutex_unlock (&sink->render_lock);
1117
1118 }
1119
1120 static void
1121 gst_wayland_sink_finalize (GObject * object)
1122 {
1123   GstWaylandSink *sink = GST_WAYLAND_SINK (object);
1124   FUNCTION;
1125   GST_DEBUG_OBJECT (sink, "Finalizing the sink..");
1126
1127   if (sink->last_buffer)
1128     gst_buffer_unref (sink->last_buffer);
1129   if (sink->display)
1130     g_object_unref (sink->display);
1131   if (sink->window)
1132     g_object_unref (sink->window);
1133   if (sink->pool)
1134     gst_object_unref (sink->pool);
1135
1136   if (sink->display_name)
1137     g_free (sink->display_name);
1138
1139   g_mutex_clear (&sink->display_lock);
1140   g_mutex_clear (&sink->render_lock);
1141
1142   G_OBJECT_CLASS (parent_class)->finalize (object);
1143 }
1144
1145 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1146 static gboolean
1147 gst_wayland_sink_event (GstBaseSink * bsink, GstEvent * event)
1148 {
1149   GstWaylandSink *sink;
1150   const GstStructure *s;
1151
1152   sink = GST_WAYLAND_SINK (bsink);
1153
1154   switch (GST_EVENT_TYPE (event)) {
1155     case GST_EVENT_EOS:
1156       GST_LOG ("get GST_EVENT_EOS event..state is %d", GST_STATE (sink));
1157       break;
1158     case GST_EVENT_CUSTOM_DOWNSTREAM:
1159       s = gst_event_get_structure (event);
1160       if (s == NULL
1161           || !gst_structure_has_name (s, GST_APP_EVENT_FLUSH_BUFFER_NAME))
1162         break;
1163
1164       GST_LOG ("get GST_EVENT_CUSTOM_DOWNSTREAM EVENT: %s..state is %d",
1165           gst_structure_get_name (s), GST_STATE (sink));
1166
1167       sink->got_costum_event = TRUE;
1168       if (gst_wayland_sink_check_use_gapless (sink)) {
1169         gst_wayland_sink_gapless_render (bsink);
1170         sink->got_costum_event = FALSE;
1171       }
1172       sink->got_costum_event = FALSE;
1173       break;
1174     default:
1175       break;
1176   }
1177   return GST_BASE_SINK_CLASS (parent_class)->event (bsink, event);
1178 }
1179 #endif
1180
1181 /* must be called with the display_lock */
1182 static void
1183 gst_wayland_sink_set_display_from_context (GstWaylandSink * sink,
1184     GstContext * context)
1185 {
1186   struct wl_display *display;
1187   GError *error = NULL;
1188   FUNCTION;
1189
1190   display = gst_wayland_display_handle_context_get_handle (context);
1191   sink->display = gst_wl_display_new_existing (display, FALSE, &error);
1192
1193   if (error) {
1194     GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE,
1195         ("Could not set display handle"),
1196         ("Failed to use the external wayland display: '%s'", error->message));
1197     g_error_free (error);
1198   }
1199 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1200   sink->display->USE_TBM = sink->USE_TBM;
1201 #endif
1202 }
1203
1204 static gboolean
1205 gst_wayland_sink_find_display (GstWaylandSink * sink)
1206 {
1207   GstQuery *query;
1208   GstMessage *msg;
1209   GstContext *context = NULL;
1210   GError *error = NULL;
1211   gboolean ret = TRUE;
1212   FUNCTION;
1213
1214   g_mutex_lock (&sink->display_lock);
1215
1216   if (!sink->display) {
1217     /* first query upstream for the needed display handle */
1218     query = gst_query_new_context (GST_WAYLAND_DISPLAY_HANDLE_CONTEXT_TYPE);
1219     if (gst_pad_peer_query (GST_VIDEO_SINK_PAD (sink), query)) {
1220       gst_query_parse_context (query, &context);
1221       gst_wayland_sink_set_display_from_context (sink, context);
1222     }
1223     gst_query_unref (query);
1224
1225     if (G_LIKELY (!sink->display)) {
1226       /* now ask the application to set the display handle */
1227       msg = gst_message_new_need_context (GST_OBJECT_CAST (sink),
1228           GST_WAYLAND_DISPLAY_HANDLE_CONTEXT_TYPE);
1229
1230       g_mutex_unlock (&sink->display_lock);
1231       gst_element_post_message (GST_ELEMENT_CAST (sink), msg);
1232       /* at this point we expect gst_wayland_sink_set_context
1233        * to get called and fill sink->display */
1234       g_mutex_lock (&sink->display_lock);
1235
1236       if (!sink->display) {
1237         /* if the application didn't set a display, let's create it ourselves */
1238         GST_OBJECT_LOCK (sink);
1239         sink->display = gst_wl_display_new (sink->display_name, &error);
1240         GST_OBJECT_UNLOCK (sink);
1241
1242         if (error) {
1243           GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE,
1244               ("Could not initialise Wayland output"),
1245               ("Failed to create GstWlDisplay: '%s'", error->message));
1246           g_error_free (error);
1247           ret = FALSE;
1248         }
1249 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1250         if (sink->display)
1251           sink->display->USE_TBM = sink->USE_TBM;
1252 #endif
1253       }
1254     }
1255   }
1256
1257   g_mutex_unlock (&sink->display_lock);
1258
1259   return ret;
1260 }
1261
1262 static GstStateChangeReturn
1263 gst_wayland_sink_change_state (GstElement * element, GstStateChange transition)
1264 {
1265   GstWaylandSink *sink = GST_WAYLAND_SINK (element);
1266   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1267   FUNCTION;
1268
1269   switch (transition) {
1270     case GST_STATE_CHANGE_NULL_TO_READY:
1271       GST_LOG ("WAYLANDSINK TRANSITION: NULL_TO_READY");
1272       if (!gst_wayland_sink_find_display (sink))
1273         return GST_STATE_CHANGE_FAILURE;
1274       break;
1275     case GST_STATE_CHANGE_READY_TO_PAUSED:
1276       GST_LOG ("WAYLANDSINK TRANSITION: READY_TO_PAUSED");
1277       break;
1278     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1279       GST_LOG ("WAYLANDSINK TRANSITION: PAUSED_TO_PLAYING");
1280       break;
1281     default:
1282       break;
1283   }
1284
1285   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1286   if (ret == GST_STATE_CHANGE_FAILURE)
1287     return ret;
1288
1289   switch (transition) {
1290     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1291       GST_LOG ("WAYLANDSINK TRANSITION: PLAYING_TO_PAUSED");
1292       break;
1293     case GST_STATE_CHANGE_PAUSED_TO_READY:
1294       GST_LOG ("WAYLANDSINK TRANSITION: PAUSED_TO_READY");
1295 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1296       if (sink->keep_camera_preview) {
1297         if (sink->window) {
1298           if (!gst_wl_window_is_toplevel (sink->window)) {
1299             GstBaseSink *bsink = GST_BASE_SINK (element);
1300             sink->request_camera_flush_buf = TRUE;
1301             gst_wayland_sink_keep_camera_preview (bsink);
1302             sink->request_camera_flush_buf = FALSE;
1303             break;
1304           }
1305         }
1306       }
1307 #endif
1308       gst_buffer_replace (&sink->last_buffer, NULL);
1309       if (sink->window) {
1310         if (gst_wl_window_is_toplevel (sink->window)) {
1311           GST_DEBUG ("internal window");
1312           g_clear_object (&sink->window);
1313         } else {
1314           /* remove buffer from surface, show nothing */
1315           GST_DEBUG ("external window");
1316           gst_wl_window_render (sink->window, NULL, NULL);
1317         }
1318       }
1319       break;
1320     case GST_STATE_CHANGE_READY_TO_NULL:
1321       GST_LOG ("WAYLANDSINK TRANSITION: READY_TO_NULL");
1322       g_mutex_lock (&sink->display_lock);
1323       /* If we had a toplevel window, we most likely have our own connection
1324        * to the display too, and it is a good idea to disconnect and allow
1325        * potentially the application to embed us with GstVideoOverlay
1326        * (which requires to re-use the same display connection as the parent
1327        * surface). If we didn't have a toplevel window, then the display
1328        * connection that we have is definitely shared with the application
1329        * and it's better to keep it around (together with the window handle)
1330        * to avoid requesting them again from the application if/when we are
1331        * restarted (GstVideoOverlay behaves like that in other sinks)
1332        */
1333       if (sink->display && !sink->window) {     /* -> the window was toplevel */
1334         g_clear_object (&sink->display);
1335       }
1336       g_mutex_unlock (&sink->display_lock);
1337       g_clear_object (&sink->pool);
1338       break;
1339     default:
1340       break;
1341   }
1342
1343   return ret;
1344 }
1345
1346 static void
1347 gst_wayland_sink_set_context (GstElement * element, GstContext * context)
1348 {
1349   GstWaylandSink *sink = GST_WAYLAND_SINK (element);
1350   FUNCTION;
1351
1352   if (gst_context_has_context_type (context,
1353           GST_WAYLAND_DISPLAY_HANDLE_CONTEXT_TYPE)) {
1354     g_mutex_lock (&sink->display_lock);
1355     if (G_LIKELY (!sink->display))
1356       gst_wayland_sink_set_display_from_context (sink, context);
1357     else {
1358       GST_WARNING_OBJECT (element, "changing display handle is not supported");
1359 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1360       g_mutex_unlock (&sink->display_lock);
1361       return;
1362 #endif
1363     }
1364     g_mutex_unlock (&sink->display_lock);
1365   }
1366
1367   if (GST_ELEMENT_CLASS (parent_class)->set_context)
1368     GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
1369 }
1370
1371 static GstCaps *
1372 gst_wayland_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
1373 {
1374   GstWaylandSink *sink;
1375   GstCaps *caps;
1376   FUNCTION;
1377
1378   sink = GST_WAYLAND_SINK (bsink);
1379
1380   caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (sink));
1381
1382   g_mutex_lock (&sink->display_lock);
1383
1384   if (sink->display) {
1385     GValue list = G_VALUE_INIT;
1386     GValue value = G_VALUE_INIT;
1387     GArray *formats;
1388     gint i;
1389 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1390     uint32_t tbm_fmt;
1391 #endif
1392     enum wl_shm_format fmt;
1393
1394     g_value_init (&list, GST_TYPE_LIST);
1395     g_value_init (&value, G_TYPE_STRING);
1396 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1397     if (sink->display->USE_TBM)
1398       formats = sink->display->tbm_formats;
1399     else                        /* SHM */
1400 #endif
1401       formats = sink->display->formats;
1402
1403     for (i = 0; i < formats->len; i++) {
1404 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1405       if (sink->USE_TBM) {
1406         tbm_fmt = g_array_index (formats, uint32_t, i);
1407         g_value_set_string (&value, gst_wl_tbm_format_to_string (tbm_fmt));
1408         gst_value_list_append_value (&list, &value);
1409         /* TBM doesn't support SN12 and ST12. So we add SN12 and ST12 manually as supported format.
1410          * SN12 is same with NV12, ST12 is same with NV12MT
1411          */
1412         if (tbm_fmt == TBM_FORMAT_NV12) {
1413           g_value_set_string (&value,
1414               gst_video_format_to_string (GST_VIDEO_FORMAT_SN12));
1415           gst_value_list_append_value (&list, &value);
1416         } else if (tbm_fmt == TBM_FORMAT_NV12MT) {
1417           g_value_set_string (&value,
1418               gst_video_format_to_string (GST_VIDEO_FORMAT_ST12));
1419           gst_value_list_append_value (&list, &value);
1420         }
1421       } else {                  /* USE SHM */
1422         fmt = g_array_index (formats, uint32_t, i);
1423         g_value_set_string (&value, gst_wl_shm_format_to_string (fmt));
1424         gst_value_list_append_value (&list, &value);
1425       }
1426 #else /* open source */
1427       fmt = g_array_index (formats, uint32_t, i);
1428       g_value_set_string (&value, gst_wl_shm_format_to_string (fmt));
1429       gst_value_list_append_value (&list, &value);
1430 #endif
1431     }
1432
1433     caps = gst_caps_make_writable (caps);
1434     gst_structure_set_value (gst_caps_get_structure (caps, 0), "format", &list);
1435
1436     GST_DEBUG_OBJECT (sink, "display caps: %" GST_PTR_FORMAT, caps);
1437     g_value_unset (&value);
1438     g_value_unset (&list);
1439
1440   }
1441
1442   g_mutex_unlock (&sink->display_lock);
1443
1444   if (filter) {
1445     GstCaps *intersection;
1446
1447     intersection =
1448         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
1449     gst_caps_unref (caps);
1450     caps = intersection;
1451   }
1452
1453   return caps;
1454 }
1455
1456 static gboolean
1457 gst_wayland_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
1458 {
1459   GstWaylandSink *sink;
1460   GstBufferPool *newpool;
1461   GstVideoInfo info;
1462 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1463   uint32_t tbm_format = -1;
1464 #endif
1465   enum wl_shm_format format = -1;
1466
1467   GArray *formats;
1468   gint i;
1469   GstStructure *structure;
1470   GstWlShmAllocator *self = NULL;
1471
1472   FUNCTION;
1473
1474   sink = GST_WAYLAND_SINK (bsink);
1475
1476   GST_DEBUG_OBJECT (sink, "set caps %" GST_PTR_FORMAT, caps);
1477
1478   /* extract info from caps */
1479   if (!gst_video_info_from_caps (&info, caps))
1480     goto invalid_format;
1481 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1482   if (sink->USE_TBM) {
1483     tbm_format =
1484         gst_video_format_to_wl_tbm_format (GST_VIDEO_INFO_FORMAT (&info));
1485     if ((gint) tbm_format == -1)
1486       goto invalid_format;
1487   } else {
1488     format = gst_video_format_to_wl_shm_format (GST_VIDEO_INFO_FORMAT (&info));
1489     if ((gint) format == -1)
1490       goto invalid_format;
1491   }
1492 #else /* open source */
1493   format = gst_video_format_to_wl_shm_format (GST_VIDEO_INFO_FORMAT (&info));
1494
1495   if ((gint) format == -1)
1496     goto invalid_format;
1497 #endif
1498
1499   /* verify we support the requested format */
1500 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1501   if (sink->display->USE_TBM) {
1502     GST_LOG ("USE TBM FORMAT");
1503     formats = sink->display->tbm_formats;
1504     for (i = 0; i < formats->len; i++) {
1505       if (g_array_index (formats, uint32_t, i) == tbm_format)
1506         break;
1507     }
1508   } else {                      /* USE SHM */
1509     GST_LOG ("USE SHM FORMAT");
1510     formats = sink->display->formats;
1511     for (i = 0; i < formats->len; i++) {
1512       if (g_array_index (formats, uint32_t, i) == format)
1513         break;
1514     }
1515   }
1516 #else /* open source */
1517
1518   formats = sink->display->formats;
1519   for (i = 0; i < formats->len; i++) {
1520     if (g_array_index (formats, uint32_t, i) == format)
1521       break;
1522   }
1523 #endif
1524   if (i >= formats->len)
1525     goto unsupported_format;
1526
1527 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1528   /* init value for set source */
1529   sink->crop_x = sink->crop_y = sink->crop_w = sink->crop_h = 0;
1530
1531   if (sink->USE_TBM) {
1532     if (GST_VIDEO_INFO_FORMAT (&info) == GST_VIDEO_FORMAT_SN12 ||
1533         GST_VIDEO_INFO_FORMAT (&info) == GST_VIDEO_FORMAT_ST12) {
1534       sink->display->is_native_format = TRUE;
1535
1536       /* store the video info */
1537       sink->video_info = info;
1538       sink->video_info_changed = TRUE;
1539     } else {
1540       sink->display->is_native_format = FALSE;
1541       self = GST_WL_SHM_ALLOCATOR (gst_wl_shm_allocator_get ());
1542       self->display = sink->display;
1543       /* create a new pool for the new configuration */
1544       newpool = gst_video_buffer_pool_new ();
1545       if (!newpool)
1546         goto pool_failed;
1547
1548       structure = gst_buffer_pool_get_config (newpool);
1549       gst_buffer_pool_config_set_params (structure, caps, info.size, 6, 0);
1550       gst_buffer_pool_config_set_allocator (structure,
1551           gst_wl_shm_allocator_get (), NULL);
1552       if (!gst_buffer_pool_set_config (newpool, structure))
1553         goto config_failed;
1554
1555       /* store the video info */
1556       sink->video_info = info;
1557       sink->video_info_changed = TRUE;
1558
1559       gst_object_replace ((GstObject **) & sink->pool, (GstObject *) newpool);
1560       gst_object_unref (newpool);
1561     }
1562   } else {                      /* USE SHM */
1563
1564     self = GST_WL_SHM_ALLOCATOR (gst_wl_shm_allocator_get ());
1565     self->display = sink->display;
1566
1567     /* create a new pool for the new configuration */
1568     newpool = gst_video_buffer_pool_new ();
1569     if (!newpool)
1570       goto pool_failed;
1571
1572     structure = gst_buffer_pool_get_config (newpool);
1573     gst_buffer_pool_config_set_params (structure, caps, info.size, 6, 0);
1574     gst_buffer_pool_config_set_allocator (structure,
1575         gst_wl_shm_allocator_get (), NULL);
1576     if (!gst_buffer_pool_set_config (newpool, structure))
1577       goto config_failed;
1578
1579     /* store the video info */
1580     sink->video_info = info;
1581     sink->video_info_changed = TRUE;
1582
1583     gst_object_replace ((GstObject **) & sink->pool, (GstObject *) newpool);
1584     gst_object_unref (newpool);
1585   }
1586 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1587   if (sink->window)
1588     gst_wayland_sink_update_window_geometry (sink);
1589 #endif
1590
1591 #else /*open source */
1592   /* create a new pool for the new configuration */
1593   newpool = gst_video_buffer_pool_new ();
1594   if (!newpool)
1595     goto pool_failed;
1596
1597   structure = gst_buffer_pool_get_config (newpool);
1598   gst_buffer_pool_config_set_params (structure, caps, info.size, 6, 0);
1599   gst_buffer_pool_config_set_allocator (structure,
1600       gst_wl_shm_allocator_get (), NULL);
1601   if (!gst_buffer_pool_set_config (newpool, structure))
1602     goto config_failed;
1603
1604   /* store the video info */
1605   sink->video_info = info;
1606   sink->video_info_changed = TRUE;
1607
1608   gst_object_replace ((GstObject **) & sink->pool, (GstObject *) newpool);
1609   gst_object_unref (newpool);
1610 #endif
1611
1612   return TRUE;
1613
1614 invalid_format:
1615   {
1616     GST_DEBUG_OBJECT (sink,
1617         "Could not locate image format from caps %" GST_PTR_FORMAT, caps);
1618     return FALSE;
1619   }
1620 unsupported_format:
1621   {
1622 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1623     if (sink->USE_TBM)
1624       GST_DEBUG_OBJECT (sink, "Format %s is not available on the display",
1625           gst_wl_tbm_format_to_string (tbm_format));
1626     else                        /*USE SHM */
1627       GST_DEBUG_OBJECT (sink, "Format %s is not available on the display",
1628           gst_wl_shm_format_to_string (format));
1629 #else /*open source */
1630     GST_DEBUG_OBJECT (sink, "Format %s is not available on the display",
1631         gst_wl_shm_format_to_string (format));
1632 #endif
1633     return FALSE;
1634   }
1635 pool_failed:
1636   {
1637     GST_DEBUG_OBJECT (sink, "Failed to create new pool");
1638     return FALSE;
1639   }
1640 config_failed:
1641   {
1642     GST_DEBUG_OBJECT (bsink, "failed setting config");
1643     gst_object_unref (newpool);
1644     return FALSE;
1645   }
1646 }
1647
1648 static gboolean
1649 gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
1650 {
1651   GstWaylandSink *sink = GST_WAYLAND_SINK (bsink);
1652   GstStructure *config;
1653   guint size, min_bufs, max_bufs;
1654 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1655   gboolean need_pool;
1656   GstCaps *caps;
1657   FUNCTION;
1658
1659   if (sink->USE_TBM) {
1660     if (sink->display->is_native_format == TRUE)
1661       return TRUE;
1662
1663     gst_query_parse_allocation (query, &caps, &need_pool);
1664
1665     if (caps == NULL) {
1666       GST_DEBUG_OBJECT (bsink, "no caps specified");
1667       return FALSE;
1668     }
1669   }
1670 #endif
1671   config = gst_buffer_pool_get_config (sink->pool);
1672   gst_buffer_pool_config_get_params (config, NULL, &size, &min_bufs, &max_bufs);
1673
1674   /* we do have a pool for sure (created in set_caps),
1675    * so let's propose it anyway, but also propose the allocator on its own */
1676   gst_query_add_allocation_pool (query, sink->pool, size, min_bufs, max_bufs);
1677   gst_query_add_allocation_param (query, gst_wl_shm_allocator_get (), NULL);
1678
1679   gst_structure_free (config);
1680
1681   return TRUE;
1682 }
1683
1684 static GstFlowReturn
1685 gst_wayland_sink_preroll (GstBaseSink * bsink, GstBuffer * buffer)
1686 {
1687 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1688   GstWaylandSink *sink = GST_WAYLAND_SINK (bsink);
1689   FUNCTION;
1690
1691   GST_DEBUG_OBJECT (bsink, "preroll buffer %p", buffer);
1692
1693   if (sink->signal_handoffs) {
1694     GST_LOG ("g_signal_emit: preroll-handoff");
1695     g_signal_emit (sink,
1696         gst_waylandsink_signals[SIGNAL_PREROLL_HANDOFF], 0, buffer,
1697         bsink->sinkpad);
1698
1699     return GST_FLOW_OK;
1700   }
1701 #endif
1702   return gst_wayland_sink_render (bsink, buffer);
1703 }
1704
1705 static void
1706 frame_redraw_callback (void *data, struct wl_callback *callback, uint32_t time)
1707 {
1708   GstWaylandSink *sink = data;
1709   FUNCTION;
1710
1711   GST_LOG ("frame_redraw_cb");
1712
1713   g_atomic_int_set (&sink->redraw_pending, FALSE);
1714   GST_INFO ("wl_callback_destroy (wl_callback@%p)", callback);
1715   wl_callback_destroy (callback);
1716 }
1717
1718 static const struct wl_callback_listener frame_callback_listener = {
1719   frame_redraw_callback
1720 };
1721
1722 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1723 static void
1724 gst_wayland_sink_update_window_geometry (GstWaylandSink * sink)
1725 {
1726   FUNCTION;
1727   g_return_if_fail (sink != NULL);
1728   g_return_if_fail (sink->window != NULL);
1729
1730   gst_wl_window_set_rotate_angle (sink->window, sink->rotate_angle);
1731   gst_wl_window_set_destination_mode (sink->window,
1732       sink->display_geometry_method);
1733   gst_wl_window_set_flip (sink->window, sink->flip);
1734   if (sink->crop_w == 0 && sink->crop_h == 0) {
1735     sink->crop_w =
1736         gst_util_uint64_scale_int_round (sink->video_info.width,
1737         sink->video_info.par_n, sink->video_info.par_d);
1738     sink->crop_h = sink->video_info.height;
1739   }
1740   gst_wl_window_set_destination_mode_crop_wl_buffer (sink->window, sink->crop_x,
1741       sink->crop_y, sink->crop_w, sink->crop_h);
1742 #ifdef ENABLE_FUNCTION
1743   gst_wl_window_set_destination_mode_follow_parent_transform (sink->window,
1744       sink->follow_parent_transform);
1745   gst_wl_window_set_destination_mode_ratio (sink->window, sink->ratio_w,
1746       sink->ratio_h);
1747   gst_wl_window_set_destination_mode_scale (sink->window, sink->scale_w,
1748       sink->scale_h);
1749   gst_wl_window_set_destination_mode_offset (sink->window, sink->offset_x,
1750       sink->offset_y, sink->offset_w, sink->offset_h);
1751   gst_wl_window_set_destination_mode_align (sink->window, sink->align_w,
1752       sink->align_h);
1753 #endif
1754 }
1755 #endif
1756 /* must be called with the render lock */
1757 static void
1758 render_last_buffer (GstWaylandSink * sink)
1759 {
1760   GstWlBuffer *wlbuffer;
1761   const GstVideoInfo *info = NULL;
1762   struct wl_surface *surface;
1763   struct wl_callback *callback;
1764   FUNCTION;
1765 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1766   g_return_if_fail (sink->last_buffer != NULL);
1767   g_return_if_fail (sink->window != NULL);
1768 #endif
1769
1770   wlbuffer = gst_buffer_get_wl_buffer (sink->last_buffer);
1771   surface = gst_wl_window_get_wl_surface (sink->window);
1772
1773   g_atomic_int_set (&sink->redraw_pending, TRUE);
1774   callback = wl_surface_frame (surface);
1775   GST_INFO ("wl_callback@%p = wl_surface_frame (video_surface@%p)", callback,
1776       surface);
1777
1778   /* frame_callback_listener is called when wayland-client finish rendering the wl_buffer */
1779   GST_INFO
1780       ("wl_callback_add_listener (wl_callback@%p, wl_callback_listener@%p, GstWaylandSink@%p)",
1781       callback, &frame_callback_listener, sink);
1782   wl_callback_add_listener (callback, &frame_callback_listener, sink);
1783
1784   if (G_UNLIKELY (sink->video_info_changed)) {
1785 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1786     gst_wl_window_set_video_info_change (sink->window, TRUE);
1787 #endif
1788     info = &sink->video_info;
1789     sink->video_info_changed = FALSE;
1790   }
1791   gst_wl_window_render (sink->window, wlbuffer, info);
1792 }
1793
1794 static GstFlowReturn
1795 gst_wayland_sink_render (GstBaseSink * bsink, GstBuffer * buffer)
1796 {
1797   GstWaylandSink *sink = GST_WAYLAND_SINK (bsink);
1798   GstBuffer *to_render;
1799   GstWlBuffer *wlbuffer;
1800   GstFlowReturn ret = GST_FLOW_OK;
1801   FUNCTION;
1802
1803   g_mutex_lock (&sink->render_lock);
1804
1805   GST_LOG_OBJECT (sink, "render gstbuffer %p, ref_count(%d)", buffer,
1806       GST_OBJECT_REFCOUNT_VALUE (buffer));
1807
1808   if (G_UNLIKELY (!sink->window)) {
1809     /* ask for window handle. Unlock render_lock while doing that because
1810      * set_window_handle & friends will lock it in this context */
1811     g_mutex_unlock (&sink->render_lock);
1812     gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (sink));
1813     g_mutex_lock (&sink->render_lock);
1814
1815     if (!sink->window) {
1816       /* if we were not provided a window, create one ourselves */
1817       sink->window =
1818           gst_wl_window_new_toplevel (sink->display, &sink->video_info);
1819     }
1820 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1821     gst_wayland_sink_update_window_geometry (sink);
1822 #endif
1823   }
1824
1825   if (sink->signal_handoffs) {
1826     GST_LOG ("g_signal_emit: hand-off ");
1827     g_signal_emit (sink, gst_waylandsink_signals[SIGNAL_HANDOFF], 0, buffer,
1828         bsink->sinkpad);
1829     goto done;
1830   }
1831
1832   /* drop buffers until we get a frame callback */
1833   if (g_atomic_int_get (&sink->redraw_pending) == TRUE
1834       && !gst_wayland_sink_check_use_gapless (sink))
1835     goto done;
1836
1837 #ifndef TIZEN_FEATURE_WLSINK_ENHANCEMENT        /* for tizen view_port, we don't know window size */
1838   /* make sure that the application has called set_render_rectangle() */
1839   if (G_UNLIKELY (sink->window->render_rectangle.w == 0))
1840     goto no_window_size;
1841 #endif
1842 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
1843
1844   wlbuffer = gst_buffer_get_wl_buffer (buffer);
1845   if (G_LIKELY (wlbuffer && wlbuffer->display == sink->display)
1846       && !(gst_wayland_sink_check_use_gapless (sink))
1847       && !sink->request_camera_flush_buf) {
1848     GST_LOG_OBJECT (sink, "buffer %p has a wl_buffer from our display, " "writing directly", buffer);   //buffer is from our  pool and have wl_buffer
1849     GST_LOG ("wl_buffer (%p)", wlbuffer->wlbuffer);
1850     to_render = buffer;
1851 #ifdef DUMP_BUFFER
1852     GstMemory *mem;
1853     GstMapInfo mem_info = GST_MAP_INFO_INIT;
1854     int size = GST_VIDEO_INFO_SIZE (&sink->video_info);
1855     mem = gst_buffer_peek_memory (to_render, 0);
1856     gst_memory_map (mem, &mem_info, GST_MAP_READ);
1857     void *data;
1858     data = mem_info.data;
1859     int ret;
1860     char file_name[128];
1861
1862     sprintf (file_name, "/home/owner/DUMP/_WLSINK_OUT_DUMP_%2.2d.dump",
1863         dump__cnt++);
1864     ret = __write_rawdata (file_name, data, size);
1865     if (ret) {
1866       GST_ERROR ("_write_rawdata() failed");
1867     }
1868     GST_LOG ("DUMP IMAGE %d, size (%d)", dump__cnt, size);
1869     gst_memory_unmap (mem, &mem_info);
1870 #endif
1871   } else {
1872     GstMemory *mem;
1873     struct wl_buffer *wbuf = NULL;
1874
1875     GST_LOG_OBJECT (sink, "buffer %p does not have a wl_buffer from our " "display, creating it", buffer);      //buffer is from our pool but have not wl_buffer
1876     mem = gst_buffer_peek_memory (buffer, 0);
1877     if (gst_is_wl_shm_memory (mem)) {
1878       FUNCTION;
1879       wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display,
1880           &sink->video_info);
1881       if (wbuf) {
1882         gst_buffer_add_wl_buffer (buffer, wbuf, sink->display); //careat GstWlBuffer and add  gstbuffer, wlbuffer, display and etc
1883         to_render = buffer;
1884       }
1885     } else {                    //buffer is not from our pool and have not wl_buffer
1886       GstMapInfo src;
1887       /* we don't know how to create a wl_buffer directly from the provided
1888        * memory, so we have to copy the data to a memory that we know how
1889        * to handle... */
1890
1891       GST_LOG_OBJECT (sink, "buffer %p is not from our pool", buffer);
1892       GST_LOG_OBJECT (sink, "buffer %p cannot have a wl_buffer, " "copying",
1893           buffer);
1894
1895       if (sink->USE_TBM && sink->display->is_native_format) {
1896         /* in case of SN12 or ST12 */
1897         if (!gst_wayland_sink_get_mm_video_buf_info (sink, buffer))
1898           return GST_FLOW_ERROR;
1899
1900         wlbuffer = gst_buffer_get_wl_buffer (buffer);
1901         /* last_buffer from gaplasee have wlbuffer */
1902         if (G_UNLIKELY (!wlbuffer)
1903             || (gst_wayland_sink_check_use_gapless (sink))
1904             || sink->request_camera_flush_buf) {
1905           wbuf =
1906               gst_wl_shm_memory_construct_wl_buffer (mem, sink->display,
1907               &sink->video_info);
1908           if (G_UNLIKELY (!wbuf))
1909             goto no_wl_buffer;
1910           gst_buffer_add_wl_buffer (buffer, wbuf, sink->display);
1911         }
1912       } else if (sink->USE_TBM && !sink->display->is_native_format) {
1913
1914         /* sink->pool always exists (created in set_caps), but it may not
1915          * be active if upstream is not using it */
1916         if (!gst_buffer_pool_is_active (sink->pool)
1917             && !gst_buffer_pool_set_active (sink->pool, TRUE))
1918           goto activate_failed;
1919
1920         ret = gst_buffer_pool_acquire_buffer (sink->pool, &to_render, NULL);
1921         if (ret != GST_FLOW_OK)
1922           goto no_buffer;
1923
1924         //GstMemory *mem;
1925         //mem = gst_buffer_peek_memory (to_render, 0);
1926         //if (gst_is_wl_shm_memory (mem)) {
1927         GST_LOG ("to_render buffer is our buffer");
1928         //}
1929         /* the first time we acquire a buffer,
1930          * we need to attach a wl_buffer on it */
1931         wlbuffer = gst_buffer_get_wl_buffer (buffer);
1932         if (G_UNLIKELY (!wlbuffer)) {
1933           mem = gst_buffer_peek_memory (to_render, 0);
1934           wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display,
1935               &sink->video_info);
1936           if (G_UNLIKELY (!wbuf))
1937             goto no_wl_buffer;
1938
1939           wlbuffer = gst_buffer_add_wl_buffer (to_render, wbuf, sink->display);
1940         }
1941
1942         gst_buffer_map (buffer, &src, GST_MAP_READ);
1943         gst_buffer_fill (to_render, 0, src.data, src.size);
1944         gst_buffer_unmap (buffer, &src);
1945       } else {                  /* USE SHM */
1946         /* sink->pool always exists (created in set_caps), but it may not
1947          * be active if upstream is not using it */
1948         if (!gst_buffer_pool_is_active (sink->pool) &&
1949             !gst_buffer_pool_set_active (sink->pool, TRUE))
1950           goto activate_failed;
1951         ret = gst_buffer_pool_acquire_buffer (sink->pool, &to_render, NULL);
1952         if (ret != GST_FLOW_OK)
1953           goto no_buffer;
1954         /* the first time we acquire a buffer,
1955          * we need to attach a wl_buffer on it */
1956         wlbuffer = gst_buffer_get_wl_buffer (buffer);
1957         if (G_UNLIKELY (!wlbuffer)) {
1958           mem = gst_buffer_peek_memory (to_render, 0);
1959           wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display,
1960               &sink->video_info);
1961           if (G_UNLIKELY (!wbuf))
1962             goto no_wl_buffer;
1963
1964           gst_buffer_add_wl_buffer (to_render, wbuf, sink->display);
1965
1966         }
1967
1968         gst_buffer_map (buffer, &src, GST_MAP_READ);
1969         gst_buffer_fill (to_render, 0, src.data, src.size);
1970         gst_buffer_unmap (buffer, &src);
1971       }
1972     }
1973   }
1974
1975   if (sink->USE_TBM && sink->display->is_native_format) {
1976     if ((G_UNLIKELY (buffer == sink->last_buffer)
1977             && !(gst_wayland_sink_check_use_gapless (sink)))
1978         || (G_UNLIKELY (buffer == sink->last_buffer)
1979             && !sink->request_camera_flush_buf)) {
1980       GST_LOG_OBJECT (sink, "Buffer already being rendered");
1981       goto done;
1982     }
1983
1984     GST_LOG_OBJECT (sink, "replace last_buffer: (%p) -> (%p)",
1985         sink->last_buffer, buffer);
1986     gst_buffer_replace (&sink->last_buffer, buffer);
1987
1988     GST_LOG_OBJECT (sink, "after gst_buffer_replace buffer %p, ref_count(%d)",
1989         buffer, GST_OBJECT_REFCOUNT_VALUE (buffer));
1990
1991     if (sink->visible) {
1992       render_last_buffer (sink);
1993     } else {
1994       GST_LOG ("skip rendering");
1995     }
1996
1997     goto done;
1998
1999   } else {                      /* USE SHM or normal format */
2000     /* drop double rendering */
2001     if (G_UNLIKELY (buffer == sink->last_buffer)) {
2002       GST_LOG_OBJECT (sink, "Buffer already being rendered");
2003       goto done;
2004     }
2005     gst_buffer_replace (&sink->last_buffer, to_render);
2006
2007     if (sink->visible) {
2008       render_last_buffer (sink);
2009     } else {
2010       GST_LOG ("skip rendering");
2011     }
2012
2013     if (buffer != to_render)
2014       gst_buffer_unref (to_render);
2015
2016     goto done;
2017   }
2018
2019 #else /* open source */
2020
2021   wlbuffer = gst_buffer_get_wl_buffer (buffer);
2022
2023   if (G_LIKELY (wlbuffer && wlbuffer->display == sink->display)) {
2024     GST_LOG_OBJECT (sink,
2025         "buffer %p has a wl_buffer from our display, " "writing directly",
2026         buffer);
2027     GST_LOG ("wl_buffer (%p)", wlbuffer->wlbuffer);
2028     to_render = buffer;
2029
2030   } else {
2031     GstMemory *mem;
2032     struct wl_buffer *wbuf = NULL;
2033
2034     GST_LOG_OBJECT (sink,
2035         "buffer %p does not have a wl_buffer from our " "display, creating it",
2036         buffer);
2037     mem = gst_buffer_peek_memory (buffer, 0);
2038     if (gst_is_wl_shm_memory (mem)) {
2039       FUNCTION;
2040       wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display,
2041           &sink->video_info);
2042     }
2043     if (wbuf) {
2044       gst_buffer_add_wl_buffer (buffer, wbuf, sink->display);
2045       to_render = buffer;
2046
2047     } else {
2048       GstMapInfo src;
2049       /* we don't know how to create a wl_buffer directly from the provided
2050        * memory, so we have to copy the data to a memory that we know how
2051        * to handle... */
2052
2053       GST_LOG_OBJECT (sink, "buffer %p is not from our pool", buffer);
2054       GST_LOG_OBJECT (sink, "buffer %p cannot have a wl_buffer, " "copying",
2055           buffer);
2056       /* sink->pool always exists (created in set_caps), but it may not
2057        * be active if upstream is not using it */
2058       if (!gst_buffer_pool_is_active (sink->pool) &&
2059           !gst_buffer_pool_set_active (sink->pool, TRUE))
2060         goto activate_failed;
2061
2062       ret = gst_buffer_pool_acquire_buffer (sink->pool, &to_render, NULL);
2063       if (ret != GST_FLOW_OK)
2064         goto no_buffer;
2065
2066       /* the first time we acquire a buffer,
2067        * we need to attach a wl_buffer on it */
2068       wlbuffer = gst_buffer_get_wl_buffer (buffer);
2069       if (G_UNLIKELY (!wlbuffer)) {
2070         mem = gst_buffer_peek_memory (to_render, 0);
2071         wbuf = gst_wl_shm_memory_construct_wl_buffer (mem, sink->display,
2072             &sink->video_info);
2073         if (G_UNLIKELY (!wbuf))
2074           goto no_wl_buffer;
2075
2076         gst_buffer_add_wl_buffer (to_render, wbuf, sink->display);
2077       }
2078
2079       gst_buffer_map (buffer, &src, GST_MAP_READ);
2080       gst_buffer_fill (to_render, 0, src.data, src.size);
2081       gst_buffer_unmap (buffer, &src);
2082     }
2083   }
2084   /* drop double rendering */
2085   if (G_UNLIKELY (buffer == sink->last_buffer)) {
2086     GST_LOG_OBJECT (sink, "Buffer already being rendered");
2087     goto done;
2088   }
2089
2090   gst_buffer_replace (&sink->last_buffer, to_render);
2091   render_last_buffer (sink);
2092
2093   if (buffer != to_render)
2094     gst_buffer_unref (to_render);
2095
2096   goto done;
2097
2098 #endif /* TIZEN_FEATURE_WLSINK_ENHANCEMENT */
2099
2100 #ifndef TIZEN_FEATURE_WLSINK_ENHANCEMENT
2101 no_window_size:
2102   {
2103     GST_ELEMENT_ERROR (sink, RESOURCE, WRITE,
2104         ("Window has no size set"),
2105         ("Make sure you set the size after calling set_window_handle"));
2106     ret = GST_FLOW_ERROR;
2107     goto done;
2108   }
2109 #endif
2110 no_buffer:
2111   {
2112     GST_WARNING_OBJECT (sink, "could not create buffer");
2113     goto done;
2114   }
2115 no_wl_buffer:
2116   {
2117     GST_ERROR_OBJECT (sink, "could not create wl_buffer out of wl_shm memory");
2118     ret = GST_FLOW_ERROR;
2119     goto done;
2120   }
2121 activate_failed:
2122   {
2123     GST_ERROR_OBJECT (sink, "failed to activate bufferpool.");
2124     ret = GST_FLOW_ERROR;
2125     goto done;
2126   }
2127 done:
2128   {
2129     g_mutex_unlock (&sink->render_lock);
2130     return ret;
2131   }
2132 }
2133
2134 static void
2135 gst_wayland_sink_videooverlay_init (GstVideoOverlayInterface * iface)
2136 {
2137   iface->set_window_handle = gst_wayland_sink_set_window_handle;
2138   iface->set_render_rectangle = gst_wayland_sink_set_render_rectangle;
2139   iface->expose = gst_wayland_sink_expose;
2140 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT /* use  unique_id */
2141   iface->set_wl_window_wl_surface_id =
2142       gst_wayland_sink_set_wl_window_wl_surface_id;
2143 #endif
2144 }
2145
2146 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT
2147 /* use  unique_id */
2148 static void
2149 gst_wayland_sink_set_wl_window_wl_surface_id (GstVideoOverlay * overlay,
2150     guintptr wl_surface_id)
2151 {
2152   GstWaylandSink *sink = GST_WAYLAND_SINK (overlay);
2153   FUNCTION;
2154   g_return_if_fail (sink != NULL);
2155
2156   if (sink->window != NULL) {
2157     GST_WARNING_OBJECT (sink, "changing window handle is not supported");
2158     return;
2159   }
2160   g_mutex_lock (&sink->render_lock);
2161   g_clear_object (&sink->window);
2162
2163   GST_LOG ("wl_surface_id %d %x", (int) wl_surface_id,
2164       (guintptr) wl_surface_id);
2165
2166   if (wl_surface_id) {
2167     if (G_LIKELY (gst_wayland_sink_find_display (sink))) {
2168       /* we cannot use our own display with an external window handle */
2169       if (G_UNLIKELY (sink->display->own_display)) {
2170         sink->display->wl_surface_id = (int) wl_surface_id;
2171         sink->window = gst_wl_window_new_in_surface (sink->display, NULL);
2172       }
2173     } else {
2174       GST_ERROR_OBJECT (sink, "Failed to find display handle, "
2175           "ignoring window handle");
2176     }
2177   }
2178   g_mutex_unlock (&sink->render_lock);
2179
2180 }
2181 #endif
2182
2183 static void
2184 gst_wayland_sink_set_window_handle (GstVideoOverlay * overlay, guintptr handle)
2185 {
2186   GstWaylandSink *sink = GST_WAYLAND_SINK (overlay);
2187   struct wl_surface *surface = (struct wl_surface *) handle;
2188   FUNCTION;
2189
2190   g_return_if_fail (sink != NULL);
2191
2192 #ifdef TIZEN_FEATURE_WLSINK_ENHANCEMENT /* use  unique_id */
2193   if (sink->window != NULL) {
2194     GST_WARNING_OBJECT (sink, "changing window handle is not supported");
2195     return;
2196   }
2197 #endif
2198   g_mutex_lock (&sink->render_lock);
2199
2200   GST_DEBUG_OBJECT (sink, "Setting window handle %" GST_PTR_FORMAT,
2201       (void *) handle);
2202
2203   g_clear_object (&sink->window);
2204
2205   if (handle) {
2206     if (G_LIKELY (gst_wayland_sink_find_display (sink))) {
2207       /* we cannot use our own display with an external window handle */
2208       if (G_UNLIKELY (sink->display->own_display)) {
2209         GST_ELEMENT_WARNING (sink, RESOURCE, OPEN_READ_WRITE,
2210             ("Application did not provide a wayland display handle"),
2211             ("Now waylandsink use internal display handle "
2212                 "which is created ourselves. Consider providing a "
2213                 "display handle from your application with GstContext"));
2214         sink->window = gst_wl_window_new_in_surface (sink->display, surface);
2215       } else {
2216         sink->window = gst_wl_window_new_in_surface (sink->display, surface);
2217       }
2218     } else {
2219       GST_ERROR_OBJECT (sink, "Failed to find display handle, "
2220           "ignoring window handle");
2221     }
2222   }
2223   g_mutex_unlock (&sink->render_lock);
2224 }
2225
2226 static void
2227 gst_wayland_sink_set_render_rectangle (GstVideoOverlay * overlay,
2228     gint x, gint y, gint w, gint h)
2229 {
2230   GstWaylandSink *sink = GST_WAYLAND_SINK (overlay);
2231   FUNCTION;
2232
2233   g_return_if_fail (sink != NULL);
2234
2235   g_mutex_lock (&sink->render_lock);
2236   if (!sink->window) {
2237     g_mutex_unlock (&sink->render_lock);
2238     GST_WARNING_OBJECT (sink,
2239         "set_render_rectangle called without window, ignoring");
2240     return;
2241   }
2242
2243   GST_DEBUG_OBJECT (sink, "window geometry changed to (%d, %d) %d x %d",
2244       x, y, w, h);
2245   gst_wl_window_set_render_rectangle (sink->window, x, y, w, h);
2246
2247   g_mutex_unlock (&sink->render_lock);
2248 }
2249
2250 static void
2251 gst_wayland_sink_expose (GstVideoOverlay * overlay)
2252 {
2253   GstWaylandSink *sink = GST_WAYLAND_SINK (overlay);
2254   FUNCTION;
2255
2256   g_return_if_fail (sink != NULL);
2257
2258   GST_DEBUG_OBJECT (sink, "expose");
2259
2260   g_mutex_lock (&sink->render_lock);
2261   if (sink->last_buffer && g_atomic_int_get (&sink->redraw_pending) == FALSE) {
2262     GST_DEBUG_OBJECT (sink, "redrawing last buffer");
2263     render_last_buffer (sink);
2264   }
2265   g_mutex_unlock (&sink->render_lock);
2266 }
2267
2268 static void
2269 gst_wayland_sink_waylandvideo_init (GstWaylandVideoInterface * iface)
2270 {
2271   iface->begin_geometry_change = gst_wayland_sink_begin_geometry_change;
2272   iface->end_geometry_change = gst_wayland_sink_end_geometry_change;
2273 }
2274
2275 static void
2276 gst_wayland_sink_begin_geometry_change (GstWaylandVideo * video)
2277 {
2278   GstWaylandSink *sink = GST_WAYLAND_SINK (video);
2279   FUNCTION;
2280   g_return_if_fail (sink != NULL);
2281
2282   g_mutex_lock (&sink->render_lock);
2283   if (!sink->window || !sink->window->area_subsurface) {
2284     g_mutex_unlock (&sink->render_lock);
2285     GST_INFO_OBJECT (sink,
2286         "begin_geometry_change called without window, ignoring");
2287     return;
2288   }
2289
2290   wl_subsurface_set_sync (sink->window->area_subsurface);
2291   g_mutex_unlock (&sink->render_lock);
2292 }
2293
2294 static void
2295 gst_wayland_sink_end_geometry_change (GstWaylandVideo * video)
2296 {
2297   GstWaylandSink *sink = GST_WAYLAND_SINK (video);
2298   FUNCTION;
2299   g_return_if_fail (sink != NULL);
2300
2301   g_mutex_lock (&sink->render_lock);
2302   if (!sink->window || !sink->window->area_subsurface) {
2303     g_mutex_unlock (&sink->render_lock);
2304     GST_INFO_OBJECT (sink,
2305         "end_geometry_change called without window, ignoring");
2306     return;
2307   }
2308
2309   wl_subsurface_set_desync (sink->window->area_subsurface);
2310   g_mutex_unlock (&sink->render_lock);
2311 }
2312
2313 static gboolean
2314 plugin_init (GstPlugin * plugin)
2315 {
2316   GST_DEBUG_CATEGORY_INIT (gstwayland_debug, "waylandsink", 0,
2317       " wayland video sink");
2318
2319   gst_wl_shm_allocator_register ();
2320
2321   return gst_element_register (plugin, "waylandsink", GST_RANK_MARGINAL,
2322       GST_TYPE_WAYLAND_SINK);
2323 }
2324
2325 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
2326     GST_VERSION_MINOR,
2327     waylandsink,
2328     "Wayland Video Sink", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME,
2329     GST_PACKAGE_ORIGIN)