/* GStreamer

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

 *

 * 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-xvimagesink

 *

 * <refsect2>

 * <para>

 * XvImageSink renders video frames to a drawable (XWindow) on a local display

 * using the XVideo extension. Rendering to a remote display is theorically

 * possible but i doubt that the XVideo extension is actually available when

 * connecting to a remote display. This element can receive a Window ID from the

 * application through the XOverlay 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.

 * </para>

 * <title>Scaling</title>

 * <para>

 * The XVideo extension, when it's available, 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

 * <link linkend="GstXvImageSink--force-aspect-ratio">force-aspect-ratio</link>

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

 * which means drawing black borders around the video frame.

 * </para>

 * <title>Events</title>

 * <para>

 * XvImageSink creates a thread to handle events coming from the drawable. There

 * are several kind of events that can be grouped in 2 big categories: input

 * events and window state related events. Input events will be translated to

 * navigation events and pushed upstream for other elements to react on them.

 * This includes events such as pointer moves, key press/release, clicks etc...

 * Other events are used to handle the drawable 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.

 * </para>

 * <title>Pixel aspect ratio</title>

 * <para>

 * When changing state to GST_STATE_READY, XvImageSink will open a connection to

 * the display specified in the

 * <link linkend="GstXvImageSink--display">display</link> property or the

 * default display if nothing specified. Once this connection is open it will

 * inspect the display configuration including the physical display geometry and

 * then calculate the pixel aspect ratio. When receiving video frames with a

 * different pixel aspect ratio, XvImageSink will use hardware scaling to

 * display the video frames correctly on display's pixel aspect ratio.

 * Sometimes the calculated pixel aspect ratio can be wrong, it is

 * then possible to enforce a specific pixel aspect ratio using the

 * <link linkend="GstXvImageSink--pixel-aspect-ratio">pixel-aspect-ratio</link>

 * property.

 * </para>

 * <title>Examples</title>

 * <para>

 * Here is a simple pipeline to test hardware scaling :

 * <programlisting>

 * gst-launch -v videotestsrc ! xvimagesink

 * </programlisting>

 * When the test video signal appears you can resize the window and see that

 * video frames are scaled through hardware (no extra CPU cost). You can try

 * again setting the force-aspect-ratio property to true and observe the borders

 * drawn around the scaled image respecting aspect ratio.

 * <programlisting>

 * gst-launch -v videotestsrc ! xvimagesink force-aspect-ratio=true

 * </programlisting>

 * </para>

 * <para>

 * Here is a simple pipeline to test navigation events :

 * <programlisting>

 * gst-launch -v videotestsrc ! navigationtest ! xvimagesink

 * </programlisting>

 * While moving the mouse pointer over the test signal you will see a black box

 * following the mouse pointer. If you press the mouse button somewhere on the

 * video and release it somewhere else a green box will appear where you pressed

 * the button and a red one where you released it. (The navigationtest element

 * is part of gst-plugins-good.) You can observe here that even if the images

 * are scaled through hardware the pointer coordinates are converted back to the

 * original video frame geometry so that the box can be drawn to the correct

 * position. This also handles borders correctly, limiting coordinates to the

 * image area

 * </para>

 * <para>

 * Here is a simple pipeline to test pixel aspect ratio :

 * <programlisting>

 * gst-launch -v videotestsrc ! video/x-raw-yuv, pixel-aspect-ratio=(fraction)4/3 ! xvimagesink

 * </programlisting>

 * This is faking a 4/3 pixel aspect ratio caps on video frames produced by

 * videotestsrc, in most cases the pixel aspect ratio of the display will be

 * 1/1. This means that XvImageSink will have to do the scaling to convert

 * incoming frames to a size that will match the display pixel aspect ratio

 * (from 320x240 to 320x180 in this case). Note that you might have to escape

 * some characters for your shell like '\(fraction\)'.

 * </para>

 * <para>

 * Here is a test pipeline to test the colorbalance interface :

 * <programlisting>

 * gst-launch -v videotestsrc ! xvimagesink hue=100 saturation=-100 brightness=100

 * </programlisting>

 * </para>

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

/* Our interfaces */

#include <gst/interfaces/navigation.h>

#include <gst/interfaces/xoverlay.h>

#include <gst/interfaces/colorbalance.h>

#include <gst/interfaces/propertyprobe.h>

/* Helper functions */

#include <gst/video/video.h>

/* Object header */

#include "xvimagesink.h"

/* Debugging category */

#include <gst/gstinfo.h>

GST_DEBUG_CATEGORY_STATIC (gst_debug_xvimagesink);

#define GST_CAT_DEFAULT gst_debug_xvimagesink

typedef struct

{

  unsigned long flags;

  unsigned long functions;

  unsigned long decorations;

  long input_mode;

  unsigned long status;

}

MotifWmHints, MwmHints;

#define MWM_HINTS_DECORATIONS   (1L << 1)

static void gst_xvimagesink_reset (GstXvImageSink * xvimagesink);

static GstBufferClass *xvimage_buffer_parent_class = NULL;

static void gst_xvimage_buffer_finalize (GstXvImageBuffer * xvimage);

static void gst_xvimagesink_xwindow_update_geometry (GstXvImageSink *

    xvimagesink, GstXWindow * xwindow);

static gint gst_xvimagesink_get_format_from_caps (GstXvImageSink * xvimagesink,

    GstCaps * caps);

static void gst_xvimagesink_expose (GstXOverlay * overlay);

/* ElementFactory information */

static const GstElementDetails gst_xvimagesink_details =

GST_ELEMENT_DETAILS ("Video sink",

    "Sink/Video",

    "A Xv based videosink",

    "Julien Moutte <julien@moutte.net>");

/* Default template - initiated with class struct to allow gst-register to work

   without X running */

static GstStaticPadTemplate gst_xvimagesink_sink_template_factory =

    GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("video/x-raw-rgb, "

        "framerate = (fraction) [ 0, MAX ], "

        "width = (int) [ 1, MAX ], "

        "height = (int) [ 1, MAX ]; "

        "video/x-raw-yuv, "

        "framerate = (fraction) [ 0, MAX ], "

        "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]")

    );

enum

{

  ARG_0,

  ARG_CONTRAST,

  ARG_BRIGHTNESS,

  ARG_HUE,

  ARG_SATURATION,

  ARG_DISPLAY,

  ARG_SYNCHRONOUS,

  ARG_PIXEL_ASPECT_RATIO,

  ARG_FORCE_ASPECT_RATIO,

  ARG_HANDLE_EVENTS,

  ARG_DEVICE,

  ARG_DEVICE_NAME,

  ARG_HANDLE_EXPOSE,

  ARG_DOUBLE_BUFFER

};

static GstVideoSinkClass *parent_class = NULL;

/* ============================================================= */

/*                                                               */

/*                       Private Methods                         */

/*                                                               */

/* ============================================================= */

/* xvimage buffers */

#define GST_TYPE_XVIMAGE_BUFFER (gst_xvimage_buffer_get_type())

#define GST_IS_XVIMAGE_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_XVIMAGE_BUFFER))

#define GST_XVIMAGE_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_XVIMAGE_BUFFER, GstXvImageBuffer))

/* This function destroys a GstXvImage handling XShm availability */

static void

gst_xvimage_buffer_destroy (GstXvImageBuffer * xvimage)

{

  GstXvImageSink *xvimagesink;

  GST_DEBUG_OBJECT (xvimage, "Destroying buffer");

  xvimagesink = xvimage->xvimagesink;

  if (G_UNLIKELY (xvimagesink == NULL))

    goto no_sink;

  g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));

  GST_OBJECT_LOCK (xvimagesink);

  /* If the destroyed image is the current one we destroy our reference too */

  if (xvimagesink->cur_image == xvimage)

    xvimagesink->cur_image = NULL;

  /* We might have some buffers destroyed after changing state to NULL */

  if (xvimagesink->xcontext == NULL) {

    GST_DEBUG_OBJECT (xvimagesink, "Destroying XvImage after Xcontext");

#ifdef HAVE_XSHM

    /* Need to free the shared memory segment even if the x context

     * was already cleaned up */

    if (xvimage->SHMInfo.shmaddr != ((void *) -1)) {

      shmdt (xvimage->SHMInfo.shmaddr);

    }

#endif

    goto beach;

  }

  g_mutex_lock (xvimagesink->x_lock);

#ifdef HAVE_XSHM

  if (xvimagesink->xcontext->use_xshm) {

    if (xvimage->SHMInfo.shmaddr != ((void *) -1)) {

      GST_DEBUG_OBJECT (xvimagesink, "XServer ShmDetaching from 0x%x id 0x%lx",

          xvimage->SHMInfo.shmid, xvimage->SHMInfo.shmseg);

      XShmDetach (xvimagesink->xcontext->disp, &xvimage->SHMInfo);

      XSync (xvimagesink->xcontext->disp, FALSE);

      shmdt (xvimage->SHMInfo.shmaddr);

    }

    if (xvimage->xvimage)

      XFree (xvimage->xvimage);

  } else

#endif /* HAVE_XSHM */

  {

    if (xvimage->xvimage) {

      if (xvimage->xvimage->data) {

        g_free (xvimage->xvimage->data);

      }

      XFree (xvimage->xvimage);

    }

  }

  XSync (xvimagesink->xcontext->disp, FALSE);

  g_mutex_unlock (xvimagesink->x_lock);

beach:

  GST_OBJECT_UNLOCK (xvimagesink);

  xvimage->xvimagesink = NULL;

  gst_object_unref (xvimagesink);

  GST_MINI_OBJECT_CLASS (xvimage_buffer_parent_class)->

      finalize (GST_MINI_OBJECT (xvimage));

  return;

no_sink:

  {

    GST_WARNING ("no sink found");

    return;

  }

}

static void

gst_xvimage_buffer_finalize (GstXvImageBuffer * xvimage)

{

  GstXvImageSink *xvimagesink;

  gboolean running;

  xvimagesink = xvimage->xvimagesink;

  if (G_UNLIKELY (xvimagesink == NULL))

    goto no_sink;

  g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));

  GST_OBJECT_LOCK (xvimagesink);

  running = xvimagesink->running;

  GST_OBJECT_UNLOCK (xvimagesink);

  /* If our geometry changed we can't reuse that image. */

  if (running == FALSE) {

    GST_LOG_OBJECT (xvimage, "destroy image as sink is shutting down");

    gst_xvimage_buffer_destroy (xvimage);

  } else if ((xvimage->width != xvimagesink->video_width) ||

      (xvimage->height != xvimagesink->video_height)) {

    GST_LOG_OBJECT (xvimage,

        "destroy image as its size changed %dx%d vs current %dx%d",

        xvimage->width, xvimage->height,

        xvimagesink->video_width, xvimagesink->video_height);

    gst_xvimage_buffer_destroy (xvimage);

  } else {

    /* In that case we can reuse the image and add it to our image pool. */

    GST_LOG_OBJECT (xvimage, "recycling image in pool");

    /* need to increment the refcount again to recycle */

    gst_buffer_ref (GST_BUFFER (xvimage));

    g_mutex_lock (xvimagesink->pool_lock);

    xvimagesink->image_pool = g_slist_prepend (xvimagesink->image_pool,

        xvimage);

    g_mutex_unlock (xvimagesink->pool_lock);

  }

  return;

no_sink:

  {

    GST_WARNING ("no sink found");

    return;

  }

}

static void

gst_xvimage_buffer_free (GstXvImageBuffer * xvimage)

{

  /* make sure it is not recycled */

  xvimage->width = -1;

  xvimage->height = -1;

  gst_buffer_unref (GST_BUFFER (xvimage));

}

static void

gst_xvimage_buffer_init (GstXvImageBuffer * xvimage, gpointer g_class)

{

#ifdef HAVE_XSHM

  xvimage->SHMInfo.shmaddr = ((void *) -1);

  xvimage->SHMInfo.shmid = -1;

#endif

}

static void

gst_xvimage_buffer_class_init (gpointer g_class, gpointer class_data)

{

  GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);

  xvimage_buffer_parent_class = g_type_class_peek_parent (g_class);

  mini_object_class->finalize = (GstMiniObjectFinalizeFunction)

      gst_xvimage_buffer_finalize;

}

static GType

gst_xvimage_buffer_get_type (void)

{

  static GType _gst_xvimage_buffer_type;

  if (G_UNLIKELY (_gst_xvimage_buffer_type == 0)) {

    static const GTypeInfo xvimage_buffer_info = {

      sizeof (GstBufferClass),

      NULL,

      NULL,

      gst_xvimage_buffer_class_init,

      NULL,

      NULL,

      sizeof (GstXvImageBuffer),

      0,

      (GInstanceInitFunc) gst_xvimage_buffer_init,

      NULL

    };

    _gst_xvimage_buffer_type = g_type_register_static (GST_TYPE_BUFFER,

        "GstXvImageBuffer", &xvimage_buffer_info, 0);

  }

  return _gst_xvimage_buffer_type;

}

/* X11 stuff */

static gboolean error_caught = FALSE;

static int

gst_xvimagesink_handle_xerror (Display * display, XErrorEvent * xevent)

{

  char error_msg[1024];

  XGetErrorText (display, xevent->error_code, error_msg, 1024);

  GST_DEBUG ("xvimagesink triggered an XError. error: %s", error_msg);

  error_caught = TRUE;

  return 0;

}

#ifdef HAVE_XSHM

/* This function checks that it is actually really possible to create an image

   using XShm */

static gboolean

gst_xvimagesink_check_xshm_calls (GstXContext * xcontext)

{

  XvImage *xvimage;

  XShmSegmentInfo SHMInfo;

  gint size;

  int (*handler) (Display *, XErrorEvent *);

  gboolean result = FALSE;

  gboolean did_attach = FALSE;

  g_return_val_if_fail (xcontext != NULL, FALSE);

  /* Sync to ensure any older errors are already processed */

  XSync (xcontext->disp, FALSE);

  /* Set defaults so we don't free these later unnecessarily */

  SHMInfo.shmaddr = ((void *) -1);

  SHMInfo.shmid = -1;

  /* Setting an error handler to catch failure */

  error_caught = FALSE;

  handler = XSetErrorHandler (gst_xvimagesink_handle_xerror);

  /* Trying to create a 1x1 picture */

  GST_DEBUG ("XvShmCreateImage of 1x1");

  xvimage = XvShmCreateImage (xcontext->disp, xcontext->xv_port_id,

      xcontext->im_format, NULL, 1, 1, &SHMInfo);

  /* Might cause an error, sync to ensure it is noticed */

  XSync (xcontext->disp, FALSE);

  if (!xvimage || error_caught) {

    GST_WARNING ("could not XvShmCreateImage a 1x1 image");

    goto beach;

  }

  size = xvimage->data_size;

  SHMInfo.shmid = shmget (IPC_PRIVATE, size, IPC_CREAT | 0777);

  if (SHMInfo.shmid == -1) {

    GST_WARNING ("could not get shared memory of %d bytes", size);

    goto beach;

  }

  SHMInfo.shmaddr = shmat (SHMInfo.shmid, NULL, 0);

  if (SHMInfo.shmaddr == ((void *) -1)) {

    GST_WARNING ("Failed to shmat: %s", g_strerror (errno));

    /* Clean up the shared memory segment */

    shmctl (SHMInfo.shmid, IPC_RMID, NULL);

    goto beach;

  }

  /* Delete the shared memory segment as soon as we manage to attach.

   * This way, it will be deleted as soon as we detach later, and not

   * leaked if we crash. */

  shmctl (SHMInfo.shmid, IPC_RMID, NULL);

  xvimage->data = SHMInfo.shmaddr;

  SHMInfo.readOnly = FALSE;

  if (XShmAttach (xcontext->disp, &SHMInfo) == 0) {

    GST_WARNING ("Failed to XShmAttach");

    goto beach;

  }

  /* Sync to ensure we see any errors we caused */

  XSync (xcontext->disp, FALSE);

  GST_DEBUG ("XServer ShmAttached to 0x%x, id 0x%lx", SHMInfo.shmid,

      SHMInfo.shmseg);

  if (!error_caught) {

    did_attach = TRUE;

    /* store whether we succeeded in result */

    result = TRUE;

  }

beach:

  /* Sync to ensure we swallow any errors we caused and reset error_caught */

  XSync (xcontext->disp, FALSE);

  error_caught = FALSE;

  XSetErrorHandler (handler);

  if (did_attach) {

    GST_DEBUG ("XServer ShmDetaching from 0x%x id 0x%lx",

        SHMInfo.shmid, SHMInfo.shmseg);

    XShmDetach (xcontext->disp, &SHMInfo);

    XSync (xcontext->disp, FALSE);

  }

  if (SHMInfo.shmaddr != ((void *) -1))

    shmdt (SHMInfo.shmaddr);

  if (xvimage)

    XFree (xvimage);

  return result;

}

#endif /* HAVE_XSHM */

/* This function handles GstXvImage creation depending on XShm availability */

static GstXvImageBuffer *

gst_xvimagesink_xvimage_new (GstXvImageSink * xvimagesink, GstCaps * caps)

{

  GstXvImageBuffer *xvimage = NULL;

  GstStructure *structure = NULL;

  gboolean succeeded = FALSE;

  int (*handler) (Display *, XErrorEvent *);

  g_return_val_if_fail (GST_IS_XVIMAGESINK (xvimagesink), NULL);

  xvimage = (GstXvImageBuffer *) gst_mini_object_new (GST_TYPE_XVIMAGE_BUFFER);

  GST_DEBUG_OBJECT (xvimage, "Creating new XvImageBuffer");

  structure = gst_caps_get_structure (caps, 0);

  if (!gst_structure_get_int (structure, "width", &xvimage->width) ||

      !gst_structure_get_int (structure, "height", &xvimage->height)) {

    GST_WARNING ("failed getting geometry from caps %" GST_PTR_FORMAT, caps);