/*

 * GStreamer

 * Copyright (C) 2003 Julien Moutte <julien@moutte.net>

 * Copyright (C) 2005,2006,2007 David A. Schleef <ds@schleef.org>

 * Copyright (C) 2008 Julien Isorce <julien.isorce@gmail.com>

 * Copyright (C) 2015 Matthew Waters <matthew@centricular.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:element-glimagesink

 * @title: glimagesink

 *

 * glimagesink renders video frames to a drawable on a local or remote

 * display using OpenGL. This element can receive a Window ID from the

 * application through the VideoOverlay interface and will then render video

 * frames in this drawable.

 * If no Window ID was provided by the application, the element will

 * create its own internal window and render into it.

 *

 * See the #GstGLDisplay documentation for a list of environment variables that

 * can override window/platform detection.

 *

 * ## Scaling

 *

 * Depends on the driver, OpenGL handles hardware accelerated

 * scaling of video frames. This means that the element will just accept

 * incoming video frames no matter their geometry and will then put them to the

 * drawable scaling them on the fly. Using the #GstGLImageSink:force-aspect-ratio

 * property it is possible to enforce scaling with a constant aspect ratio,

 * which means drawing black borders around the video frame.

 *

 * ## Events

 *

 * Through the gl thread, glimagesink handle some events coming from the drawable

 * to manage its appearance even when the data is not flowing (GST_STATE_PAUSED).

 * That means that even when the element is paused, it will receive expose events

 * from the drawable and draw the latest frame with correct borders/aspect-ratio.

 *

 * ## Examples

 * |[

 * gst-launch-1.0 -v videotestsrc ! video/x-raw ! glimagesink

 * ]| A pipeline to test hardware scaling.

 * No special opengl extension is used in this pipeline, that's why it should work

 * with OpenGL >= 1.1. That's the case if you are using the MESA3D driver v1.3.

 * |[

 * gst-launch-1.0 -v videotestsrc ! video/x-raw,format=I420 ! glimagesink

 * ]| A pipeline to test hardware scaling and hardware colorspace conversion.

 * When your driver supports GLSL (OpenGL Shading Language needs OpenGL >= 2.1),

 * the 4 following format YUY2, UYVY, I420, YV12 and AYUV are converted to RGB32

 * through some fragment shaders and using one framebuffer (FBO extension OpenGL >= 1.4).

 * If your driver does not support GLSL but supports MESA_YCbCr extension then

 * the you can use YUY2 and UYVY. In this case the colorspace conversion is automatically

 * made when loading the texture and therefore no framebuffer is used.

 * |[

 * gst-launch-1.0 -v gltestsrc ! glimagesink

 * ]| A pipeline 100% OpenGL.

 * No special opengl extension is used in this pipeline, that's why it should work

 * with OpenGL >= 1.1. That's the case if you are using the MESA3D driver v1.3.

 * |[

 * gst-plugins-bas/tests/examples/gl/generic/cube

 * ]| The graphic FPS scene can be greater than the input video FPS.

 * The graphic scene can be written from a client code through the

 * two glfilterapp properties.

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/video/videooverlay.h>

#include <gst/video/navigation.h>

#include <gst/video/gstvideoaffinetransformationmeta.h>

#include "gstglimagesink.h"

#include "gstglsinkbin.h"

#include "gstglutils.h"

#include <gst/gl/gstglviewconvert.h>

GST_DEBUG_CATEGORY (gst_debug_glimage_sink);

#define GST_CAT_DEFAULT gst_debug_glimage_sink

#define DEFAULT_SHOW_PREROLL_FRAME  TRUE

#define DEFAULT_HANDLE_EVENTS       TRUE

#define DEFAULT_FORCE_ASPECT_RATIO  TRUE

#define DEFAULT_IGNORE_ALPHA        TRUE

#define DEFAULT_MULTIVIEW_MODE GST_VIDEO_MULTIVIEW_MODE_MONO

#define DEFAULT_MULTIVIEW_FLAGS GST_VIDEO_MULTIVIEW_FLAGS_NONE

#define DEFAULT_MULTIVIEW_DOWNMIX GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS

typedef GstGLSinkBin GstGLImageSinkBin;

typedef GstGLSinkBinClass GstGLImageSinkBinClass;

G_DEFINE_TYPE (GstGLImageSinkBin, gst_gl_image_sink_bin, GST_TYPE_GL_SINK_BIN);

enum

{

  PROP_BIN_0,

  PROP_BIN_ROTATE_METHOD,

  PROP_BIN_FORCE_ASPECT_RATIO,

  PROP_BIN_PIXEL_ASPECT_RATIO,

  PROP_BIN_HANDLE_EVENTS,

  PROP_BIN_CONTEXT,

  PROP_BIN_IGNORE_ALPHA,

  PROP_BIN_SHOW_PREROLL_FRAME,

  PROP_BIN_OUTPUT_MULTIVIEW_LAYOUT,

  PROP_BIN_OUTPUT_MULTIVIEW_FLAGS,

  PROP_BIN_OUTPUT_MULTIVIEW_DOWNMIX_MODE,

  PROP_BIN_LAST

};

enum

{

  SIGNAL_BIN_0,

  SIGNAL_BIN_CLIENT_DRAW,

  SIGNAL_BIN_CLIENT_RESHAPE,

  SIGNAL_BIN_LAST,

};

static guint gst_gl_image_sink_bin_signals[SIGNAL_BIN_LAST] = { 0 };

static void

gst_gl_image_sink_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * param_spec)

{

  g_object_set_property (G_OBJECT (GST_GL_SINK_BIN (object)->sink),

      param_spec->name, value);

}

static void

gst_gl_image_sink_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * param_spec)

{

  g_object_get_property (G_OBJECT (GST_GL_SINK_BIN (object)->sink),

      param_spec->name, value);

}

static gboolean

_on_client_reshape (GstGLImageSink * sink, GstGLContext * context,

    guint width, guint height, gpointer data)

{

  gboolean ret;

  g_signal_emit (data, gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_RESHAPE],

      0, context, width, height, &ret;;

  return ret;

}

static gboolean

_on_client_draw (GstGLImageSink * sink, GstGLContext * context,

    GstSample * sample, gpointer data)

{

  gboolean ret;

  g_signal_emit (data, gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_DRAW], 0,

      context, sample, &ret;;

  return ret;

}

#define DEFAULT_ROTATE_METHOD GST_GL_ROTATE_METHOD_IDENTITY

#define GST_TYPE_GL_ROTATE_METHOD (gst_gl_rotate_method_get_type())

static const GEnumValue rotate_methods[] = {

  {GST_GL_ROTATE_METHOD_IDENTITY, "Identity (no rotation)", "none"},

  {GST_GL_ROTATE_METHOD_90R, "Rotate clockwise 90 degrees", "clockwise"},

  {GST_GL_ROTATE_METHOD_180, "Rotate 180 degrees", "rotate-180"},

  {GST_GL_ROTATE_METHOD_90L, "Rotate counter-clockwise 90 degrees",

      "counterclockwise"},

  {GST_GL_ROTATE_METHOD_FLIP_HORIZ, "Flip horizontally", "horizontal-flip"},

  {GST_GL_ROTATE_METHOD_FLIP_VERT, "Flip vertically", "vertical-flip"},

  {GST_GL_ROTATE_METHOD_FLIP_UL_LR,

      "Flip across upper left/lower right diagonal", "upper-left-diagonal"},

  {GST_GL_ROTATE_METHOD_FLIP_UR_LL,

      "Flip across upper right/lower left diagonal", "upper-right-diagonal"},

  {GST_GL_ROTATE_METHOD_AUTO,

      "Select rotate method based on image-orientation tag", "automatic"},

  {0, NULL, NULL},

};

static GType

gst_gl_rotate_method_get_type (void)

{

  static GType rotate_method_type = 0;

  if (!rotate_method_type) {

    rotate_method_type = g_enum_register_static ("GstGLRotateMethod",

        rotate_methods);

  }

  return rotate_method_type;

}

static void

gst_gl_image_sink_bin_init (GstGLImageSinkBin * self)

{

  GstGLImageSink *sink = g_object_new (GST_TYPE_GLIMAGE_SINK, NULL);

  g_signal_connect (sink, "client-reshape", (GCallback) _on_client_reshape,

      self);

  g_signal_connect (sink, "client-draw", (GCallback) _on_client_draw, self);

  gst_gl_sink_bin_finish_init_with_element (GST_GL_SINK_BIN (self),

      GST_ELEMENT (sink));

}

static void

gst_gl_image_sink_bin_class_init (GstGLImageSinkBinClass * klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->get_property = gst_gl_image_sink_bin_get_property;

  gobject_class->set_property = gst_gl_image_sink_bin_set_property;

  /* gl sink */

  g_object_class_install_property (gobject_class, PROP_BIN_ROTATE_METHOD,

      g_param_spec_enum ("rotate-method",

          "rotate method",

          "rotate method",

          GST_TYPE_GL_ROTATE_METHOD, DEFAULT_ROTATE_METHOD,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BIN_FORCE_ASPECT_RATIO,

      g_param_spec_boolean ("force-aspect-ratio",

          "Force aspect ratio",

          "When enabled, scaling will respect original aspect ratio",

          DEFAULT_FORCE_ASPECT_RATIO,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BIN_HANDLE_EVENTS,

      g_param_spec_boolean ("handle-events", "Handle XEvents",

          "When enabled, XEvents will be selected and handled",

          DEFAULT_HANDLE_EVENTS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BIN_IGNORE_ALPHA,

      g_param_spec_boolean ("ignore-alpha", "Ignore Alpha",

          "When enabled, alpha will be ignored and converted to black",

          DEFAULT_IGNORE_ALPHA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BIN_CONTEXT,

      g_param_spec_object ("context", "OpenGL context", "Get OpenGL context",

          GST_TYPE_GL_CONTEXT, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_BIN_PIXEL_ASPECT_RATIO,

      gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",

          "The pixel aspect ratio of the device", 0, 1, G_MAXINT, 1, 1, 1,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /* video sink */

  g_object_class_install_property (gobject_class, PROP_BIN_SHOW_PREROLL_FRAME,

      g_param_spec_boolean ("show-preroll-frame", "Show preroll frame",

          "Whether to render video frames during preroll",

          DEFAULT_SHOW_PREROLL_FRAME,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

      PROP_BIN_OUTPUT_MULTIVIEW_LAYOUT,

      g_param_spec_enum ("output-multiview-mode", "Output Multiview Mode",

          "Choose output mode for multiview/3D video",

          GST_TYPE_VIDEO_MULTIVIEW_MODE, DEFAULT_MULTIVIEW_MODE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

      PROP_BIN_OUTPUT_MULTIVIEW_FLAGS,

      g_param_spec_flags ("output-multiview-flags", "Output Multiview Flags",

          "Output multiview layout modifier flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGS, DEFAULT_MULTIVIEW_FLAGS,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

      PROP_BIN_OUTPUT_MULTIVIEW_DOWNMIX_MODE,

      g_param_spec_enum ("output-multiview-downmix-mode",

          "Mode for mono downmixed output",

          "Output anaglyph type to generate when downmixing to mono",

          GST_TYPE_GL_STEREO_DOWNMIX_MODE_TYPE, DEFAULT_MULTIVIEW_DOWNMIX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  gst_video_overlay_install_properties (gobject_class, PROP_BIN_LAST);

  gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_DRAW] =

      g_signal_new ("client-draw", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      0, NULL, NULL, g_cclosure_marshal_generic, G_TYPE_BOOLEAN, 2,

      GST_TYPE_GL_CONTEXT, GST_TYPE_SAMPLE);

  gst_gl_image_sink_bin_signals[SIGNAL_BIN_CLIENT_RESHAPE] =

      g_signal_new ("client-reshape", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,

      G_TYPE_BOOLEAN, 3, GST_TYPE_GL_CONTEXT, G_TYPE_UINT, G_TYPE_UINT);

}

#define GST_GLIMAGE_SINK_GET_LOCK(glsink) \

  (GST_GLIMAGE_SINK(glsink)->drawing_lock)

#define GST_GLIMAGE_SINK_LOCK(glsink) \

  (g_mutex_lock(&GST_GLIMAGE_SINK_GET_LOCK (glsink)))

#define GST_GLIMAGE_SINK_UNLOCK(glsink) \

  (g_mutex_unlock(&GST_GLIMAGE_SINK_GET_LOCK (glsink)))

#define USING_OPENGL(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL, 1, 0))

#define USING_OPENGL3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL3, 3, 1))

#define USING_GLES(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES, 1, 0))

#define USING_GLES2(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 2, 0))

#define USING_GLES3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 3, 0))

#define SUPPORTED_GL_APIS GST_GL_API_OPENGL | GST_GL_API_GLES2 | GST_GL_API_OPENGL3

static void gst_glimage_sink_thread_init_redisplay (GstGLImageSink * gl_sink);

static void gst_glimage_sink_cleanup_glthread (GstGLImageSink * gl_sink);

static void gst_glimage_sink_on_close (GstGLImageSink * gl_sink);

static void gst_glimage_sink_on_resize (GstGLImageSink * gl_sink,

    gint width, gint height);

static void gst_glimage_sink_on_draw (GstGLImageSink * gl_sink);

static gboolean gst_glimage_sink_redisplay (GstGLImageSink * gl_sink);

static void gst_glimage_sink_finalize (GObject * object);

static void gst_glimage_sink_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * param_spec);

static void gst_glimage_sink_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * param_spec);

static gboolean gst_glimage_sink_event (GstBaseSink * sink, GstEvent * event);

static gboolean gst_glimage_sink_query (GstBaseSink * bsink, GstQuery * query);

static void gst_glimage_sink_set_context (GstElement * element,

    GstContext * context);

static GstStateChangeReturn

gst_glimage_sink_change_state (GstElement * element, GstStateChange transition);

static void gst_glimage_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,

    GstClockTime * start, GstClockTime * end);

static gboolean gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps);

static GstCaps *gst_glimage_sink_get_caps (GstBaseSink * bsink,

    GstCaps * filter);

static GstFlowReturn gst_glimage_sink_prepare (GstBaseSink * bsink,

    GstBuffer * buf);

static GstFlowReturn gst_glimage_sink_show_frame (GstVideoSink * bsink,

    GstBuffer * buf);

static gboolean gst_glimage_sink_propose_allocation (GstBaseSink * bsink,

    GstQuery * query);

static void gst_glimage_sink_video_overlay_init (GstVideoOverlayInterface *

    iface);

static void gst_glimage_sink_set_window_handle (GstVideoOverlay * overlay,

    guintptr id);

static void gst_glimage_sink_expose (GstVideoOverlay * overlay);

static void gst_glimage_sink_set_render_rectangle (GstVideoOverlay * overlay,

    gint x, gint y, gint width, gint height);

static void gst_glimage_sink_handle_events (GstVideoOverlay * overlay,

    gboolean handle_events);

static gboolean update_output_format (GstGLImageSink * glimage_sink);

#define GST_GL_SINK_CAPS \

    "video/x-raw(" GST_CAPS_FEATURE_MEMORY_GL_MEMORY "), "              \

    "format = (string) RGBA, "                                          \

    "width = " GST_VIDEO_SIZE_RANGE ", "                                \

    "height = " GST_VIDEO_SIZE_RANGE ", "                               \

    "framerate = " GST_VIDEO_FPS_RANGE ", "                             \

    "texture-target = (string) { 2D, external-oes } "                   \

    " ; "                                                               \

    "video/x-raw(" GST_CAPS_FEATURE_MEMORY_GL_MEMORY ","                \

    GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION "), "           \

    "format = (string) RGBA, "                                          \

    "width = " GST_VIDEO_SIZE_RANGE ", "                                \

    "height = " GST_VIDEO_SIZE_RANGE ", "                               \

    "framerate = " GST_VIDEO_FPS_RANGE ", "                             \

    "texture-target = (string) { 2D, external-oes } "

static GstStaticPadTemplate gst_glimage_sink_template =

GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS (GST_GL_SINK_CAPS));

enum

{

  ARG_0,

  ARG_DISPLAY,

  PROP_ROTATE_METHOD,

  PROP_FORCE_ASPECT_RATIO,

  PROP_PIXEL_ASPECT_RATIO,

  PROP_CONTEXT,

  PROP_HANDLE_EVENTS,

  PROP_IGNORE_ALPHA,

  PROP_OUTPUT_MULTIVIEW_LAYOUT,

  PROP_OUTPUT_MULTIVIEW_FLAGS,

  PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE,

  PROP_LAST

};

enum

{

  SIGNAL_0,

  CLIENT_DRAW_SIGNAL,

  CLIENT_RESHAPE_SIGNAL,

  LAST_SIGNAL

};

static guint gst_glimage_sink_signals[LAST_SIGNAL] = { 0 };

static void

_display_size_to_stream_size (GstGLImageSink * gl_sink, gdouble x,

    gdouble y, gdouble * stream_x, gdouble * stream_y)

{

  gdouble stream_width, stream_height;

  stream_width = (gdouble) GST_VIDEO_INFO_WIDTH (&gl_sink->out_info);

  stream_height = (gdouble) GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info);

  /* from display coordinates to stream coordinates */

  if (gl_sink->display_rect.w > 0)

    *stream_x =

        (x - gl_sink->display_rect.x) / gl_sink->display_rect.w * stream_width;

  else

    *stream_x = 0.;

  /* clip to stream size */

  if (*stream_x < 0.)

    *stream_x = 0.;

  if (*stream_x > GST_VIDEO_INFO_WIDTH (&gl_sink->out_info))

    *stream_x = GST_VIDEO_INFO_WIDTH (&gl_sink->out_info);

  /* same for y-axis */

  if (gl_sink->display_rect.h > 0)

    *stream_y =

        (y - gl_sink->display_rect.y) / gl_sink->display_rect.h * stream_height;

  else

    *stream_y = 0.;

  if (*stream_y < 0.)

    *stream_y = 0.;

  if (*stream_y > GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info))

    *stream_y = GST_VIDEO_INFO_HEIGHT (&gl_sink->out_info);

  GST_TRACE ("transform %fx%f into %fx%f", x, y, *stream_x, *stream_y);

}

/* rotate 90 */

static const gfloat clockwise_matrix[] = {

  0.0f, -1.0f, 0.0f, 0.0f,

  1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* rotate 180 */

static const gfloat clockwise_180_matrix[] = {

  -1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, -1.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* rotate 270 */

static const gfloat counterclockwise_matrix[] = {

  0.0f, 1.0f, 0.0f, 0.0f,

  -1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* horizontal-flip */

static const gfloat horizontal_flip_matrix[] = {

  -1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, 1.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* vertical-flip */

static const gfloat vertical_flip_matrix[] = {

  1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, -1.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* upper-left-diagonal */

static const gfloat upper_left_matrix[] = {

  0.0f, 1.0f, 0.0f, 0.0f,

  1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* upper-right-diagonal */

static const gfloat upper_right_matrix[] = {

  0.0f, -1.0f, 0.0f, 0.0f,

  -1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

static void

gst_glimage_sink_set_rotate_method (GstGLImageSink * gl_sink,

    GstGLRotateMethod method, gboolean from_tag)

{

  GstGLRotateMethod tag_method = DEFAULT_ROTATE_METHOD;

  GST_GLIMAGE_SINK_LOCK (gl_sink);

  if (from_tag)

    tag_method = method;

  else

    gl_sink->rotate_method = method;

  if (gl_sink->rotate_method == GST_GL_ROTATE_METHOD_AUTO)

    method = tag_method;

  else

    method = gl_sink->rotate_method;

  if (method != gl_sink->current_rotate_method) {

    GST_DEBUG_OBJECT (gl_sink, "Changing method from %s to %s",

        rotate_methods[gl_sink->current_rotate_method].value_nick,

        rotate_methods[method].value_nick);

    switch (method) {

      case GST_GL_ROTATE_METHOD_IDENTITY:

        gl_sink->transform_matrix = NULL;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_90R:

        gl_sink->transform_matrix = clockwise_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_180:

        gl_sink->transform_matrix = clockwise_180_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_90L:

        gl_sink->transform_matrix = counterclockwise_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_FLIP_HORIZ:

        gl_sink->transform_matrix = horizontal_flip_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_FLIP_VERT:

        gl_sink->transform_matrix = vertical_flip_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_FLIP_UL_LR:

        gl_sink->transform_matrix = upper_left_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      case GST_GL_ROTATE_METHOD_FLIP_UR_LL:

        gl_sink->transform_matrix = upper_right_matrix;

        gl_sink->output_mode_changed = TRUE;

        break;

      default:

        g_assert_not_reached ();

        break;

    }

    gl_sink->current_rotate_method = method;

  }

  GST_GLIMAGE_SINK_UNLOCK (gl_sink);

}

static void

gst_glimage_sink_navigation_send_event (GstNavigation * navigation, GstStructure

    * structure)

{

  GstGLImageSink *sink = GST_GLIMAGE_SINK (navigation);

  gboolean handled = FALSE;

  GstEvent *event = NULL;

  GstGLWindow *window;

  guint width, height;

  gdouble x, y;

  if (!sink->context) {

    gst_structure_free (structure);

    return;

  }

  window = gst_gl_context_get_window (sink->context);

  g_return_if_fail (GST_IS_GL_WINDOW (window));

  width = GST_VIDEO_SINK_WIDTH (sink);

  height = GST_VIDEO_SINK_HEIGHT (sink);

  gst_gl_window_get_surface_dimensions (window, &width, &height);

  /* Converting pointer coordinates to the non scaled geometry */

  if (width != 0 && gst_structure_get_double (structure, "pointer_x", &x)

      && height != 0 && gst_structure_get_double (structure, "pointer_y", &y)) {

    gdouble stream_x, stream_y;

    _display_size_to_stream_size (sink, x, y, &stream_x, &stream_y);

    gst_structure_set (structure, "pointer_x", G_TYPE_DOUBLE,

        stream_x, "pointer_y", G_TYPE_DOUBLE, stream_y, NULL);

  }

  event = gst_event_new_navigation (structure);

  if (event) {

    gst_event_ref (event);

    handled = gst_pad_push_event (GST_VIDEO_SINK_PAD (sink), event);

    if (!handled)

      gst_element_post_message ((GstElement *) sink,

          gst_navigation_message_new_event ((GstObject *) sink, event));

    gst_event_unref (event);

  }

  gst_object_unref (window);

}

static void

gst_glimage_sink_navigation_interface_init (GstNavigationInterface * iface)

{

  iface->send_event = gst_glimage_sink_navigation_send_event;

}

#define gst_glimage_sink_parent_class parent_class

G_DEFINE_TYPE_WITH_CODE (GstGLImageSink, gst_glimage_sink,

    GST_TYPE_VIDEO_SINK, G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,

        gst_glimage_sink_video_overlay_init);

    G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,

        gst_glimage_sink_navigation_interface_init);

    GST_DEBUG_CATEGORY_INIT (gst_debug_glimage_sink, "glimagesink", 0,

        "OpenGL Video Sink"));

static void

gst_glimage_sink_class_init (GstGLImageSinkClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  GstBaseSinkClass *gstbasesink_class;

  GstVideoSinkClass *gstvideosink_class;

  GstElementClass *element_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  gstbasesink_class = (GstBaseSinkClass *) klass;

  gstvideosink_class = (GstVideoSinkClass *) klass;

  element_class = GST_ELEMENT_CLASS (klass);

  gobject_class->set_property = gst_glimage_sink_set_property;

  gobject_class->get_property = gst_glimage_sink_get_property;

  g_object_class_install_property (gobject_class, PROP_ROTATE_METHOD,

      g_param_spec_enum ("rotate-method",

          "rotate method",

          "rotate method",

          GST_TYPE_GL_ROTATE_METHOD, DEFAULT_ROTATE_METHOD,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,

      g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio",

          "When enabled, scaling will respect original aspect ratio",

          DEFAULT_FORCE_ASPECT_RATIO,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_PIXEL_ASPECT_RATIO,

      gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",

          "The pixel aspect ratio of the device", 0, 1, G_MAXINT, 1, 1, 1,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_CONTEXT,

      g_param_spec_object ("context", "OpenGL context", "Get OpenGL context",

          GST_TYPE_GL_CONTEXT, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_HANDLE_EVENTS,

      g_param_spec_boolean ("handle-events", "Handle XEvents",

          "When enabled, XEvents will be selected and handled",

          DEFAULT_HANDLE_EVENTS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_IGNORE_ALPHA,

      g_param_spec_boolean ("ignore-alpha", "Ignore Alpha",

          "When enabled, alpha will be ignored and converted to black",

          DEFAULT_IGNORE_ALPHA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_OUTPUT_MULTIVIEW_LAYOUT,

      g_param_spec_enum ("output-multiview-mode",

          "Output Multiview Mode",

          "Choose output mode for multiview/3D video",

          GST_TYPE_VIDEO_MULTIVIEW_MODE, DEFAULT_MULTIVIEW_MODE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_OUTPUT_MULTIVIEW_FLAGS,

      g_param_spec_flags ("output-multiview-flags",

          "Output Multiview Flags",

          "Output multiview layout modifier flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGS, DEFAULT_MULTIVIEW_FLAGS,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class,

      PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE,

      g_param_spec_enum ("output-multiview-downmix-mode",

          "Mode for mono downmixed output",

          "Output anaglyph type to generate when downmixing to mono",

          GST_TYPE_GL_STEREO_DOWNMIX_MODE_TYPE, DEFAULT_MULTIVIEW_DOWNMIX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  gst_video_overlay_install_properties (gobject_class, PROP_LAST);

  gst_element_class_set_metadata (element_class, "OpenGL video sink",

      "Sink/Video", "A videosink based on OpenGL",

      "Julien Isorce <julien.isorce@gmail.com>");

  /**

   * GstGLImageSink::client-draw:

   * @object: the #GstGLImageSink

   * @texture: the #guint id of the texture.

   * @width: the #guint width of the texture.

   * @height: the #guint height of the texture.

   *

   * Will be emitted before actually drawing the texture.  The client should

   * redraw the surface/contents with the @texture, @width and @height and

   * and return %TRUE.

   *

   * Returns: whether the texture was redrawn by the signal.  If not, a

   *          default redraw will occur.

   */

  gst_glimage_sink_signals[CLIENT_DRAW_SIGNAL] =

      g_signal_new ("client-draw", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,

      G_TYPE_BOOLEAN, 2, GST_TYPE_GL_CONTEXT, GST_TYPE_SAMPLE);

  /**

   * GstGLImageSink::client-reshape:

   * @object: the #GstGLImageSink

   * @width: the #guint width of the texture.

   * @height: the #guint height of the texture.

   *

   * The client should resize the surface/window/viewport with the @width and

   * @height and return %TRUE.

   *

   * Returns: whether the content area was resized by the signal.  If not, a

   *          default viewport resize will occur.

   */

  gst_glimage_sink_signals[CLIENT_RESHAPE_SIGNAL] =

      g_signal_new ("client-reshape", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,

      G_TYPE_BOOLEAN, 3, GST_TYPE_GL_CONTEXT, G_TYPE_UINT, G_TYPE_UINT);

  gst_element_class_add_static_pad_template (element_class,

      &gst_glimage_sink_template);

  gobject_class->finalize = gst_glimage_sink_finalize;

  gstelement_class->change_state = gst_glimage_sink_change_state;

  gstelement_class->set_context = gst_glimage_sink_set_context;

  gstbasesink_class->event = gst_glimage_sink_event;

  gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_glimage_sink_query);

  gstbasesink_class->set_caps = gst_glimage_sink_set_caps;

  gstbasesink_class->get_caps = gst_glimage_sink_get_caps;

  gstbasesink_class->get_times = gst_glimage_sink_get_times;

  gstbasesink_class->prepare = gst_glimage_sink_prepare;

  gstbasesink_class->propose_allocation = gst_glimage_sink_propose_allocation;

  gstvideosink_class->show_frame =

      GST_DEBUG_FUNCPTR (gst_glimage_sink_show_frame);

}

static void

gst_glimage_sink_init (GstGLImageSink * glimage_sink)

{

  glimage_sink->window_id = 0;

  glimage_sink->new_window_id = 0;

  glimage_sink->display = NULL;

  glimage_sink->keep_aspect_ratio = TRUE;

  glimage_sink->par_n = 0;

  glimage_sink->par_d = 1;

  glimage_sink->redisplay_texture = 0;

  glimage_sink->handle_events = TRUE;

  glimage_sink->ignore_alpha = TRUE;

  glimage_sink->overlay_compositor = NULL;

  glimage_sink->mview_output_mode = DEFAULT_MULTIVIEW_MODE;

  glimage_sink->mview_output_flags = DEFAULT_MULTIVIEW_FLAGS;

  glimage_sink->mview_downmix_mode = DEFAULT_MULTIVIEW_DOWNMIX;

  glimage_sink->current_rotate_method = DEFAULT_ROTATE_METHOD;

  glimage_sink->transform_matrix = NULL;

  g_mutex_init (&glimage_sink->drawing_lock);

}

static void

gst_glimage_sink_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstGLImageSink *glimage_sink;

  g_return_if_fail (GST_IS_GLIMAGE_SINK (object));

  glimage_sink = GST_GLIMAGE_SINK (object);

  switch (prop_id) {

    case PROP_ROTATE_METHOD:

      gst_glimage_sink_set_rotate_method (glimage_sink,

          g_value_get_enum (value), FALSE);

      break;

    case PROP_FORCE_ASPECT_RATIO:

    {

      glimage_sink->keep_aspect_ratio = g_value_get_boolean (value);

      break;

    }

    case PROP_PIXEL_ASPECT_RATIO:

    {

      glimage_sink->par_n = gst_value_get_fraction_numerator (value);

      glimage_sink->par_d = gst_value_get_fraction_denominator (value);

      break;

    }

    case PROP_HANDLE_EVENTS:

      gst_glimage_sink_handle_events (GST_VIDEO_OVERLAY (glimage_sink),

          g_value_get_boolean (value));

      break;

    case PROP_IGNORE_ALPHA:

      glimage_sink->ignore_alpha = g_value_get_boolean (value);

      break;

    case PROP_OUTPUT_MULTIVIEW_LAYOUT:

      GST_GLIMAGE_SINK_LOCK (glimage_sink);

      glimage_sink->mview_output_mode = g_value_get_enum (value);

      glimage_sink->output_mode_changed = TRUE;

      GST_GLIMAGE_SINK_UNLOCK (glimage_sink);

      break;

    case PROP_OUTPUT_MULTIVIEW_FLAGS:

      GST_GLIMAGE_SINK_LOCK (glimage_sink);

      glimage_sink->mview_output_flags = g_value_get_flags (value);

      glimage_sink->output_mode_changed = TRUE;

      GST_GLIMAGE_SINK_UNLOCK (glimage_sink);

      break;

    case PROP_OUTPUT_MULTIVIEW_DOWNMIX_MODE:

      GST_GLIMAGE_SINK_LOCK (glimage_sink);

      glimage_sink->mview_downmix_mode = g_value_get_enum (value);

      glimage_sink->output_mode_changed = TRUE;

      GST_GLIMAGE_SINK_UNLOCK (glimage_sink);

      break;

    default:

      if (!gst_video_overlay_set_property (object, PROP_LAST, prop_id, value))

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_glimage_sink_finalize (GObject * object)

{

  GstGLImageSink *glimage_sink;

  g_return_if_fail (GST_IS_GLIMAGE_SINK (object));

  glimage_sink = GST_GLIMAGE_SINK (object);

  g_mutex_clear (&glimage_sink->drawing_lock);

  GST_DEBUG ("finalized");

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_glimage_sink_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstGLImageSink *glimage_sink;

  g_return_if_fail (GST_IS_GLIMAGE_SINK (object));

  glimage_sink = GST_GLIMAGE_SINK (object);

  switch (prop_id) {

    case PROP_ROTATE_METHOD:

      g_value_set_enum (value, glimage_sink->current_rotate_method);

      break;

    case PROP_FORCE_ASPECT_RATIO:

      g_value_set_boolean (value, glimage_sink->keep_aspect_ratio);

      break;

    case PROP_PIXEL_ASPECT_RATIO:

      gst_value_set_fraction (value, glimage_sink->par_n, glimage_sink->par_d);

      break;

    case PROP_CONTEXT:

      g_value_set_object (value, glimage_sink->context);

      break;

    case PROP_HANDLE_EVENTS: