/* 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-ximagesink

 *

 * <refsect2>

 * <para>

 * XImageSink renders video frames to a drawable (XWindow) on a local or 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>

 * As standard XImage rendering to a drawable is not scaled, XImageSink will use

 * reverse caps negotiation to try to get scaled video frames for the drawable.

 * This is accomplished by asking the peer pad if it accepts some different caps

 * which in most cases implies that there is a scaling element in the pipeline,

 * or that an element generating the video frames can generate them with a 

 * different geometry. This mechanism is handled during buffer allocations, for

 * each allocation request the video sink will check the drawable geometry, look

 * at the

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

 * property, calculate the geometry of desired video frames and then check that

 * the peer pad accept those new caps. If it does it will then allocate a buffer

 * in video memory with this new geometry and return it with the new caps.

 * </para>

 * <title>Events</title>

 * <para>

 * XImageSink 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, XImageSink will open a connection to

 * the display specified in the

 * <link linkend="GstXImageSink--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 caps negotiation will occur, the

 * video sink will set the calculated pixel aspect ratio on the caps to make 

 * sure that incoming video frames will have the correct pixel aspect ratio for

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

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

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

 * property.

 * </para>

 * <title>Examples</title>

 * <para>

 * Here is a simple pipeline to test reverse negotiation :

 * <programlisting>

 * gst-launch -v videotestsrc ! queue ! ximagesink

 * </programlisting>

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

 * scaled buffers of the desired size are going to arrive with a short delay.

 * This illustrates how buffers of desired size are allocated along the way.

 * If you take away the queue, scaling will happen almost immediately.

 * </para>

 * <para>

 * Here is a simple pipeline to test navigation events :

 * <programlisting>

 * gst-launch -v videotestsrc ! navigationtest ! ffmpegcolorspace ! ximagesink

 * </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.)

 * </para>

 * <para>

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

 * <programlisting>

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

 * </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 videoscale 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>

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

/* Our interfaces */

#include <gst/interfaces/navigation.h>

#include <gst/interfaces/xoverlay.h>

/* Object header */

#include "ximagesink.h"

/* Debugging category */

#include <gst/gstinfo.h>

GST_DEBUG_CATEGORY_EXTERN (gst_debug_ximagesink);

#define GST_CAT_DEFAULT gst_debug_ximagesink

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_ximagesink_reset (GstXImageSink * ximagesink);

static void gst_ximagesink_ximage_destroy (GstXImageSink * ximagesink,

    GstXImageBuffer * ximage);

static void gst_ximagesink_xwindow_update_geometry (GstXImageSink * ximagesink,

    GstXWindow * xwindow);

static void gst_ximagesink_expose (GstXOverlay * overlay);

/* ElementFactory information */

static const GstElementDetails gst_ximagesink_details =

GST_ELEMENT_DETAILS ("Video sink",

    "Sink/Video",

    "A standard X based videosink",

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

static GstStaticPadTemplate gst_ximagesink_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 ]")

    );

enum

{

  PROP_0,

  PROP_DISPLAY,

  PROP_SYNCHRONOUS,

  PROP_PIXEL_ASPECT_RATIO,

  PROP_FORCE_ASPECT_RATIO,

  PROP_HANDLE_EVENTS,

  PROP_HANDLE_EXPOSE

};

static GstVideoSinkClass *parent_class = NULL;

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

/*                                                               */

/*                       Private Methods                         */

/*                                                               */

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

/* ximage buffers */

static GstBufferClass *ximage_buffer_parent_class = NULL;

#define GST_TYPE_XIMAGE_BUFFER (gst_ximage_buffer_get_type())

#define GST_IS_XIMAGE_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_XIMAGE_BUFFER))

#define GST_XIMAGE_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_XIMAGE_BUFFER, GstXImageBuffer))

#define GST_XIMAGE_BUFFER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_XIMAGE_BUFFER, GstXImageBufferClass))

/* So some words about GstMiniObject, this is pretty messy...

   GstMiniObject does not use the standard finalizing of GObjects, you are 

   supposed to call gst_buffer_unref that's going to call gst_mini_objec_unref

   which will handle its own refcount system and call gst_mini_object_free.

   gst_mini_object_free will call the class finalize method which is not the 

   one from GObject, after calling this finalize method it will free the object

   instance for you if the refcount is still 0 so you should not chain up */

static void

gst_ximage_buffer_finalize (GstXImageBuffer * ximage)

{

  GstXImageSink *ximagesink = NULL;

  gboolean recycled = FALSE;

  gboolean running;

  g_return_if_fail (ximage != NULL);

  ximagesink = ximage->ximagesink;

  if (G_UNLIKELY (ximagesink == NULL)) {

    GST_WARNING_OBJECT (ximagesink, "no sink found");

    goto beach;

  }

  GST_OBJECT_LOCK (ximagesink);

  running = ximagesink->running;

  GST_OBJECT_UNLOCK (ximagesink);

  if (running == FALSE) {

    /* If the sink is shutting down, need to clear the image */

    GST_DEBUG_OBJECT (ximagesink,

        "destroy image %p because the sink is shutting down", ximage);

    gst_ximagesink_ximage_destroy (ximagesink, ximage);

  } else if ((ximage->width != GST_VIDEO_SINK_WIDTH (ximagesink)) ||

      (ximage->height != GST_VIDEO_SINK_HEIGHT (ximagesink))) {

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

    GST_DEBUG_OBJECT (ximagesink,

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

        ximage, ximage->width, ximage->height,

        GST_VIDEO_SINK_WIDTH (ximagesink), GST_VIDEO_SINK_HEIGHT (ximagesink));

    gst_ximagesink_ximage_destroy (ximagesink, ximage);

  } else {

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

    GST_LOG_OBJECT (ximagesink, "recycling image %p in pool", ximage);

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

    gst_buffer_ref (GST_BUFFER_CAST (ximage));

    g_mutex_lock (ximagesink->pool_lock);

    ximagesink->buffer_pool = g_slist_prepend (ximagesink->buffer_pool, ximage);

    g_mutex_unlock (ximagesink->pool_lock);

    recycled = TRUE;

  }

  if (!recycled)

    GST_MINI_OBJECT_CLASS (ximage_buffer_parent_class)->

        finalize (GST_MINI_OBJECT (ximage));

beach:

  return;

}

static void

gst_ximage_buffer_free (GstXImageBuffer * ximage)

{

  /* make sure it is not recycled */

  ximage->width = -1;

  ximage->height = -1;

  gst_buffer_unref (GST_BUFFER_CAST (ximage));

}

static void

gst_ximage_buffer_init (GstXImageBuffer * ximage_buffer, gpointer g_class)

{

#ifdef HAVE_XSHM

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

  ximage_buffer->SHMInfo.shmid = -1;

#endif

}

static void

gst_ximage_buffer_class_init (gpointer g_class, gpointer class_data)

{

  GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);

  ximage_buffer_parent_class = g_type_class_peek_parent (g_class);

  mini_object_class->finalize = (GstMiniObjectFinalizeFunction)

      gst_ximage_buffer_finalize;

}

static GType

gst_ximage_buffer_get_type (void)

{

  static GType _gst_ximage_buffer_type;

  if (G_UNLIKELY (_gst_ximage_buffer_type == 0)) {

    static const GTypeInfo ximage_buffer_info = {

      sizeof (GstBufferClass),

      NULL,

      NULL,

      gst_ximage_buffer_class_init,

      NULL,

      NULL,

      sizeof (GstXImageBuffer),

      0,

      (GInstanceInitFunc) gst_ximage_buffer_init,

      NULL

    };

    _gst_ximage_buffer_type = g_type_register_static (GST_TYPE_BUFFER,

        "GstXImageBuffer", &ximage_buffer_info, 0);

  }

  return _gst_ximage_buffer_type;

}

/* X11 stuff */

static gboolean error_caught = FALSE;

static int

gst_ximagesink_handle_xerror (Display * display, XErrorEvent * xevent)

{

  char error_msg[1024];

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

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

  error_caught = TRUE;

  return 0;

}

#ifdef HAVE_XSHM                /* Check that XShm calls actually work */

static gboolean

gst_ximagesink_check_xshm_calls (GstXImageSink * ximagesink,

    GstXContext * xcontext)

{

  XImage *ximage;

  XShmSegmentInfo SHMInfo;

  size_t 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_ximagesink_handle_xerror);

  /* Trying to create a 1x1 ximage */

  GST_DEBUG ("XShmCreateImage of 1x1");

  ximage = XShmCreateImage (xcontext->disp, xcontext->visual,

      xcontext->depth, ZPixmap, NULL, &SHMInfo, 1, 1);

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

  XSync (xcontext->disp, FALSE);

  if (!ximage || error_caught) {

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

    goto beach;

  }

  size = ximage->height * ximage->bytes_per_line;

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

  if (SHMInfo.shmid == -1) {

    GST_WARNING ("could not get shared memory of %" G_GSIZE_FORMAT " 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 shm seg */

    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);

  ximage->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);

  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) {

    XShmDetach (xcontext->disp, &SHMInfo);

    XSync (xcontext->disp, FALSE);

  }

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

    shmdt (SHMInfo.shmaddr);

  if (ximage)

    XDestroyImage (ximage);

  return result;

}

#endif /* HAVE_XSHM */

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

static GstXImageBuffer *

gst_ximagesink_ximage_new (GstXImageSink * ximagesink, GstCaps * caps)

{

  GstXImageBuffer *ximage = NULL;

  GstStructure *structure = NULL;

  gboolean succeeded = FALSE;

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

  g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);

  ximage = (GstXImageBuffer *) gst_mini_object_new (GST_TYPE_XIMAGE_BUFFER);

  structure = gst_caps_get_structure (caps, 0);

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

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

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

  }

  GST_DEBUG_OBJECT (ximagesink, "creating image %p (%dx%d)", ximage,

      ximage->width, ximage->height);

  g_mutex_lock (ximagesink->x_lock);

  /* Setting an error handler to catch failure */

  error_caught = FALSE;

  handler = XSetErrorHandler (gst_ximagesink_handle_xerror);

#ifdef HAVE_XSHM

  if (ximagesink->xcontext->use_xshm) {

    ximage->ximage = XShmCreateImage (ximagesink->xcontext->disp,

        ximagesink->xcontext->visual,

        ximagesink->xcontext->depth,

        ZPixmap, NULL, &ximage->SHMInfo, ximage->width, ximage->height);

    if (!ximage->ximage || error_caught) {

      g_mutex_unlock (ximagesink->x_lock);

      /* Reset error handler */

      error_caught = FALSE;

      XSetErrorHandler (handler);

      /* Push an error */

      GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

          ("Failed to create output image buffer of %dx%d pixels",

              ximage->width, ximage->height),

          ("could not XShmCreateImage a %dx%d image",

              ximage->width, ximage->height));

      goto beach;

    }

    /* we have to use the returned bytes_per_line for our shm size */

    ximage->size = ximage->ximage->bytes_per_line * ximage->ximage->height;

    GST_LOG_OBJECT (ximagesink,

        "XShm image size is %" G_GSIZE_FORMAT ", width %d, stride %d",

        ximage->size, ximage->width, ximage->ximage->bytes_per_line);

    ximage->SHMInfo.shmid = shmget (IPC_PRIVATE, ximage->size,

        IPC_CREAT | 0777);

    if (ximage->SHMInfo.shmid == -1) {

      g_mutex_unlock (ximagesink->x_lock);

      GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

          ("Failed to create output image buffer of %dx%d pixels",

              ximage->width, ximage->height),

          ("could not get shared memory of %" G_GSIZE_FORMAT " bytes",

              ximage->size));

      goto beach;

    }

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

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

      g_mutex_unlock (ximagesink->x_lock);

      GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

          ("Failed to create output image buffer of %dx%d pixels",

              ximage->width, ximage->height),

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

      /* Clean up the shared memory segment */

      shmctl (ximage->SHMInfo.shmid, IPC_RMID, NULL);

      goto beach;

    }

    /* Now that we've attached, we can delete the shared memory segment.

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

     * leaked if we crash. */

    shmctl (ximage->SHMInfo.shmid, IPC_RMID, NULL);

    ximage->ximage->data = ximage->SHMInfo.shmaddr;

    ximage->SHMInfo.readOnly = FALSE;

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

      g_mutex_unlock (ximagesink->x_lock);

      GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

          ("Failed to create output image buffer of %dx%d pixels",

              ximage->width, ximage->height), ("Failed to XShmAttach"));

      goto beach;

    }

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

  } else

#endif /* HAVE_XSHM */

  {

    guint allocsize;

    ximage->ximage = XCreateImage (ximagesink->xcontext->disp,

        ximagesink->xcontext->visual,

        ximagesink->xcontext->depth,

        ZPixmap, 0, NULL,

        ximage->width, ximage->height, ximagesink->xcontext->bpp, 0);

    if (!ximage->ximage || error_caught) {

      g_mutex_unlock (ximagesink->x_lock);

      /* Reset error handler */

      error_caught = FALSE;

      XSetErrorHandler (handler);

      /* Push an error */

      GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

          ("Failed to create output image buffer of %dx%d pixels",

              ximage->width, ximage->height),

          ("could not XCreateImage a %dx%d image",

              ximage->width, ximage->height));