/* GStreamer

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

 *               <2009>,<2010> Stefan Kost <stefan.kost@nokia.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-xvimagesink

 * @title: xvimagesink

 *

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

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

 * 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 #GstVideoOverlay 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.

 *

 * ## Scaling

 *

 * 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 #GstXvImageSink: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

 *

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

 *

 * ## Pixel aspect ratio

 *

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

 * the display specified in the #GstXvImageSink:display 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

 * #GstXvImageSink:pixel-aspect-ratio property.

 *

 * ## Examples

 * |[

 * gst-launch-1.0 -v videotestsrc ! xvimagesink

 * ]|

 *  A pipeline to test hardware scaling.

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

 * video frames are scaled through hardware (no extra CPU cost). By default

 * the image will never be distorted when scaled, instead black borders will

 * be added if needed.

 * |[

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

 * ]|

 *  Same pipeline with #GstXvImageSink:force-aspect-ratio property set to

 * false. You can observe that no borders are drawn around the scaled image

 * now and it will be distorted to fill the entire frame instead of respecting

 * the aspect ratio.

 * |[

 * gst-launch-1.0 -v videotestsrc ! navigationtest ! xvimagesink

 * ]|

 *  A pipeline to test navigation events.

 * 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

 * |[

 * gst-launch-1.0 -v videotestsrc ! video/x-raw, pixel-aspect-ratio=4/3 ! xvimagesink

 * ]|

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

 * |[

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

 * ]|

 *  Demonstrates how to use the colorbalance interface.

 *

 */

/* for developers: there are two useful tools : xvinfo and xvattr */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

/* Our interfaces */

#include <gst/video/navigation.h>

#include <gst/video/videooverlay.h>

#include <gst/video/colorbalance.h>

/* Helper functions */

#include <gst/video/gstvideometa.h>

/* Object header */

#include "xvimagesink.h"

#include "xvimageallocator.h"

/* Debugging category */

#include <gst/gstinfo.h>

/* for XkbKeycodeToKeysym */

#include <X11/XKBlib.h>

GST_DEBUG_CATEGORY_EXTERN (gst_debug_xv_image_sink);

GST_DEBUG_CATEGORY_EXTERN (CAT_PERFORMANCE);

#define GST_CAT_DEFAULT gst_debug_xv_image_sink

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 gboolean gst_xv_image_sink_open (GstXvImageSink * xvimagesink);

static void gst_xv_image_sink_close (GstXvImageSink * xvimagesink);

static void gst_xv_image_sink_xwindow_update_geometry (GstXvImageSink *

    xvimagesink);

static void gst_xv_image_sink_expose (GstVideoOverlay * overlay);

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

   without X running */

static GstStaticPadTemplate gst_xv_image_sink_sink_template_factory =

GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("video/x-raw, "

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

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

    );

enum

{

  PROP_0,

  PROP_CONTRAST,

  PROP_BRIGHTNESS,

  PROP_HUE,

  PROP_SATURATION,

  PROP_DISPLAY,

  PROP_SYNCHRONOUS,

  PROP_PIXEL_ASPECT_RATIO,

  PROP_FORCE_ASPECT_RATIO,

  PROP_HANDLE_EVENTS,

  PROP_DEVICE,

  PROP_DEVICE_NAME,

  PROP_HANDLE_EXPOSE,

  PROP_DOUBLE_BUFFER,

  PROP_AUTOPAINT_COLORKEY,

  PROP_COLORKEY,

  PROP_DRAW_BORDERS,

  PROP_WINDOW_WIDTH,

  PROP_WINDOW_HEIGHT,

  PROP_LAST

};

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

/*                                                               */

/*                       Public Methods                          */

/*                                                               */

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

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

/*                                             */

/*          Object typing & Creation           */

/*                                             */

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

static void gst_xv_image_sink_navigation_init (GstNavigationInterface * iface);

static void gst_xv_image_sink_video_overlay_init (GstVideoOverlayInterface *

    iface);

static void gst_xv_image_sink_colorbalance_init (GstColorBalanceInterface *

    iface);

#define gst_xv_image_sink_parent_class parent_class

G_DEFINE_TYPE_WITH_CODE (GstXvImageSink, gst_xv_image_sink, GST_TYPE_VIDEO_SINK,

    G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,

        gst_xv_image_sink_navigation_init);

    G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,

        gst_xv_image_sink_video_overlay_init);

    G_IMPLEMENT_INTERFACE (GST_TYPE_COLOR_BALANCE,

        gst_xv_image_sink_colorbalance_init));

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

/*                                                               */

/*                       Private Methods                         */

/*                                                               */

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

/* This function puts a GstXvImage on a GstXvImageSink's window. Returns FALSE

 * if no window was available  */

static gboolean

gst_xv_image_sink_xvimage_put (GstXvImageSink * xvimagesink,

    GstBuffer * xvimage)

{

  GstXvImageMemory *mem;

  GstVideoCropMeta *crop;

  GstVideoRectangle result;

  gboolean draw_border = FALSE;

  GstVideoRectangle src = { 0, };

  GstVideoRectangle dst = { 0, };

  GstVideoRectangle mem_crop;

  GstXWindow *xwindow;

  /* We take the flow_lock. If expose is in there we don't want to run

     concurrently from the data flow thread */

  g_mutex_lock (&xvimagesink->flow_lock);

  if (G_UNLIKELY ((xwindow = xvimagesink->xwindow) == NULL)) {

    g_mutex_unlock (&xvimagesink->flow_lock);

    return FALSE;

  }

  /* Draw borders when displaying the first frame. After this

     draw borders only on expose event or after a size change. */

  if (!xvimagesink->cur_image || xvimagesink->redraw_border) {

    draw_border = xvimagesink->draw_borders;

    xvimagesink->redraw_border = FALSE;

  }

  /* Store a reference to the last image we put, lose the previous one */

  if (xvimage && xvimagesink->cur_image != xvimage) {

    if (xvimagesink->cur_image) {

      GST_LOG_OBJECT (xvimagesink, "unreffing %p", xvimagesink->cur_image);

      gst_buffer_unref (xvimagesink->cur_image);

    }

    GST_LOG_OBJECT (xvimagesink, "reffing %p as our current image", xvimage);

    xvimagesink->cur_image = gst_buffer_ref (xvimage);

  }

  /* Expose sends a NULL image, we take the latest frame */

  if (!xvimage) {

    if (xvimagesink->cur_image) {

      draw_border = TRUE;

      xvimage = xvimagesink->cur_image;

    } else {

      g_mutex_unlock (&xvimagesink->flow_lock);

      return TRUE;

    }

  }

  mem = (GstXvImageMemory *) gst_buffer_peek_memory (xvimage, 0);

  gst_xvimage_memory_get_crop (mem, &mem_crop);

  crop = gst_buffer_get_video_crop_meta (xvimage);

  if (crop) {

    src.x = crop->x + mem_crop.x;

    src.y = crop->y + mem_crop.y;

    src.w = crop->width;

    src.h = crop->height;

    GST_LOG_OBJECT (xvimagesink,

        "crop %dx%d-%dx%d", crop->x, crop->y, crop->width, crop->height);

  } else {

    src = mem_crop;

  }

  if (xvimagesink->keep_aspect) {

    GstVideoRectangle s;

    /* We take the size of the source material as it was negotiated and

     * corrected for DAR. This size can be different from the cropped size in

     * which case the image will be scaled to fit the negotiated size. */

    s.w = GST_VIDEO_SINK_WIDTH (xvimagesink);

    s.h = GST_VIDEO_SINK_HEIGHT (xvimagesink);

    dst.w = xwindow->render_rect.w;

    dst.h = xwindow->render_rect.h;

    gst_video_sink_center_rect (s, dst, &result, TRUE);

    result.x += xwindow->render_rect.x;

    result.y += xwindow->render_rect.y;

  } else {

    memcpy (&result, &xwindow->render_rect, sizeof (GstVideoRectangle));

  }

  gst_xvimage_memory_render (mem, &src, xwindow, &result, draw_border);

  g_mutex_unlock (&xvimagesink->flow_lock);

  return TRUE;

}

static void

gst_xv_image_sink_xwindow_set_title (GstXvImageSink * xvimagesink,

    GstXWindow * xwindow, const gchar * media_title)

{

  if (media_title) {

    g_free (xvimagesink->media_title);

    xvimagesink->media_title = g_strdup (media_title);

  }

  if (xwindow) {

    /* we have a window */

    const gchar *app_name;

    const gchar *title = NULL;

    gchar *title_mem = NULL;

    /* set application name as a title */

    app_name = g_get_application_name ();

    if (app_name && xvimagesink->media_title) {

      title = title_mem = g_strconcat (xvimagesink->media_title, " : ",

          app_name, NULL);

    } else if (app_name) {

      title = app_name;

    } else if (xvimagesink->media_title) {

      title = xvimagesink->media_title;

    }

    gst_xwindow_set_title (xwindow, title);

    g_free (title_mem);

  }

}

/* This function handles a GstXWindow creation

 * The width and height are the actual pixel size on the display */

static GstXWindow *

gst_xv_image_sink_xwindow_new (GstXvImageSink * xvimagesink,

    gint width, gint height)

{

  GstXWindow *xwindow = NULL;

  GstXvContext *context;

  g_return_val_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink), NULL);

  context = xvimagesink->context;

  xwindow = gst_xvcontext_create_xwindow (context, width, height);

  /* set application name as a title */

  gst_xv_image_sink_xwindow_set_title (xvimagesink, xwindow, NULL);

  gst_xwindow_set_event_handling (xwindow, xvimagesink->handle_events);

  gst_video_overlay_got_window_handle (GST_VIDEO_OVERLAY (xvimagesink),

      xwindow->win);

  return xwindow;

}

static void

gst_xv_image_sink_xwindow_update_geometry (GstXvImageSink * xvimagesink)

{

  g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));

  /* Update the window geometry */

  g_mutex_lock (&xvimagesink->flow_lock);

  if (G_LIKELY (xvimagesink->xwindow))

    gst_xwindow_update_geometry (xvimagesink->xwindow);

  g_mutex_unlock (&xvimagesink->flow_lock);

}

/* This function commits our internal colorbalance settings to our grabbed Xv

   port. If the context is not initialized yet it simply returns */

static void

gst_xv_image_sink_update_colorbalance (GstXvImageSink * xvimagesink)

{

  GstXvContext *context;

  g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));

  /* If we haven't initialized the X context we can't update anything */

  if ((context = xvimagesink->context) == NULL)

    return;

  gst_xvcontext_update_colorbalance (context, &xvimagesink->config);

}

/* This function handles XEvents that might be in the queue. It generates

   GstEvent that will be sent upstream in the pipeline to handle interactivity

   and navigation. It will also listen for configure events on the window to

   trigger caps renegotiation so on the fly software scaling can work. */

static void

gst_xv_image_sink_handle_xevents (GstXvImageSink * xvimagesink)

{

  XEvent e;

  gint pointer_x = 0, pointer_y = 0;

  gboolean pointer_moved = FALSE;

  gboolean exposed = FALSE, configured = FALSE;

  g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));

  /* Handle Interaction, produces navigation events */

  /* We get all pointer motion events, only the last position is

     interesting. */

  g_mutex_lock (&xvimagesink->flow_lock);

  g_mutex_lock (&xvimagesink->context->lock);

  while (XCheckWindowEvent (xvimagesink->context->disp,

          xvimagesink->xwindow->win, PointerMotionMask, &e)) {

    g_mutex_unlock (&xvimagesink->context->lock);

    g_mutex_unlock (&xvimagesink->flow_lock);

    switch (e.type) {

      case MotionNotify:

        pointer_x = e.xmotion.x;

        pointer_y = e.xmotion.y;

        pointer_moved = TRUE;

        break;

      default:

        break;

    }

    g_mutex_lock (&xvimagesink->flow_lock);

    g_mutex_lock (&xvimagesink->context->lock);

  }

  if (pointer_moved) {

    g_mutex_unlock (&xvimagesink->context->lock);

    g_mutex_unlock (&xvimagesink->flow_lock);

    GST_DEBUG ("xvimagesink pointer moved over window at %d,%d",

        pointer_x, pointer_y);

    gst_navigation_send_mouse_event (GST_NAVIGATION (xvimagesink),

        "mouse-move", 0, e.xbutton.x, e.xbutton.y);

    g_mutex_lock (&xvimagesink->flow_lock);

    g_mutex_lock (&xvimagesink->context->lock);

  }

  /* We get all events on our window to throw them upstream */

  while (XCheckWindowEvent (xvimagesink->context->disp,

          xvimagesink->xwindow->win,

          KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask,

          &e)) {

    KeySym keysym;

    const char *key_str = NULL;

    /* We lock only for the X function call */

    g_mutex_unlock (&xvimagesink->context->lock);

    g_mutex_unlock (&xvimagesink->flow_lock);

    switch (e.type) {

      case ButtonPress:

        /* Mouse button pressed over our window. We send upstream

           events for interactivity/navigation */

        GST_DEBUG ("xvimagesink button %d pressed over window at %d,%d",

            e.xbutton.button, e.xbutton.x, e.xbutton.y);

        gst_navigation_send_mouse_event (GST_NAVIGATION (xvimagesink),

            "mouse-button-press", e.xbutton.button, e.xbutton.x, e.xbutton.y);

        break;

      case ButtonRelease:

        /* Mouse button released over our window. We send upstream

           events for interactivity/navigation */

        GST_DEBUG ("xvimagesink button %d released over window at %d,%d",

            e.xbutton.button, e.xbutton.x, e.xbutton.y);

        gst_navigation_send_mouse_event (GST_NAVIGATION (xvimagesink),

            "mouse-button-release", e.xbutton.button, e.xbutton.x, e.xbutton.y);

        break;

      case KeyPress:

      case KeyRelease:

        /* Key pressed/released over our window. We send upstream

           events for interactivity/navigation */

        g_mutex_lock (&xvimagesink->context->lock);

        keysym = XkbKeycodeToKeysym (xvimagesink->context->disp,

            e.xkey.keycode, 0, 0);

        if (keysym != NoSymbol) {

          key_str = XKeysymToString (keysym);

        } else {

          key_str = "unknown";

        }

        g_mutex_unlock (&xvimagesink->context->lock);

        GST_DEBUG_OBJECT (xvimagesink,

            "key %d pressed over window at %d,%d (%s)",

            e.xkey.keycode, e.xkey.x, e.xkey.y, key_str);

        gst_navigation_send_key_event (GST_NAVIGATION (xvimagesink),

            e.type == KeyPress ? "key-press" : "key-release", key_str);

        break;

      default:

        GST_DEBUG_OBJECT (xvimagesink, "xvimagesink unhandled X event (%d)",

            e.type);

    }

    g_mutex_lock (&xvimagesink->flow_lock);

    g_mutex_lock (&xvimagesink->context->lock);

  }

  /* Handle Expose */

  while (XCheckWindowEvent (xvimagesink->context->disp,

          xvimagesink->xwindow->win, ExposureMask | StructureNotifyMask, &e)) {

    switch (e.type) {

      case Expose:

        exposed = TRUE;

        break;

      case ConfigureNotify:

        g_mutex_unlock (&xvimagesink->context->lock);

        g_mutex_unlock (&xvimagesink->flow_lock);

        gst_xv_image_sink_xwindow_update_geometry (xvimagesink);

        g_mutex_lock (&xvimagesink->flow_lock);

        g_mutex_lock (&xvimagesink->context->lock);

        configured = TRUE;

        break;

      default:

        break;

    }

  }

  if (xvimagesink->handle_expose && (exposed || configured)) {

    g_mutex_unlock (&xvimagesink->context->lock);

    g_mutex_unlock (&xvimagesink->flow_lock);

    gst_xv_image_sink_expose (GST_VIDEO_OVERLAY (xvimagesink));

    g_mutex_lock (&xvimagesink->flow_lock);

    g_mutex_lock (&xvimagesink->context->lock);

  }

  /* Handle Display events */

  while (XPending (xvimagesink->context->disp)) {

    XNextEvent (xvimagesink->context->disp, &e);

    switch (e.type) {

      case ClientMessage:{

        Atom wm_delete;

        wm_delete = XInternAtom (xvimagesink->context->disp,

            "WM_DELETE_WINDOW", True);

        if (wm_delete != None && wm_delete == (Atom) e.xclient.data.l[0]) {

          /* Handle window deletion by posting an error on the bus */

          GST_ELEMENT_ERROR (xvimagesink, RESOURCE, NOT_FOUND,

              ("Output window was closed"), (NULL));

          g_mutex_unlock (&xvimagesink->context->lock);

          gst_xwindow_destroy (xvimagesink->xwindow);

          xvimagesink->xwindow = NULL;

          g_mutex_lock (&xvimagesink->context->lock);

        }

        break;

      }

      default:

        break;

    }

  }

  g_mutex_unlock (&xvimagesink->context->lock);

  g_mutex_unlock (&xvimagesink->flow_lock);

}

static gpointer

gst_xv_image_sink_event_thread (GstXvImageSink * xvimagesink)

{

  g_return_val_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink), NULL);

  GST_OBJECT_LOCK (xvimagesink);

  while (xvimagesink->running) {

    GST_OBJECT_UNLOCK (xvimagesink);

    if (xvimagesink->xwindow) {

      gst_xv_image_sink_handle_xevents (xvimagesink);

    }

    /* FIXME: do we want to align this with the framerate or anything else? */

    g_usleep (G_USEC_PER_SEC / 20);

    GST_OBJECT_LOCK (xvimagesink);

  }

  GST_OBJECT_UNLOCK (xvimagesink);

  return NULL;

}

static void

gst_xv_image_sink_manage_event_thread (GstXvImageSink * xvimagesink)

{

  GThread *thread = NULL;

  /* don't start the thread too early */

  if (xvimagesink->context == NULL) {

    return;

  }

  GST_OBJECT_LOCK (xvimagesink);

  if (xvimagesink->handle_expose || xvimagesink->handle_events) {

    if (!xvimagesink->event_thread) {

      /* Setup our event listening thread */

      GST_DEBUG_OBJECT (xvimagesink, "run xevent thread, expose %d, events %d",

          xvimagesink->handle_expose, xvimagesink->handle_events);

      xvimagesink->running = TRUE;

      xvimagesink->event_thread = g_thread_try_new ("xvimagesink-events",

          (GThreadFunc) gst_xv_image_sink_event_thread, xvimagesink, NULL);

    }

  } else {

    if (xvimagesink->event_thread) {

      GST_DEBUG_OBJECT (xvimagesink, "stop xevent thread, expose %d, events %d",

          xvimagesink->handle_expose, xvimagesink->handle_events);

      xvimagesink->running = FALSE;

      /* grab thread and mark it as NULL */

      thread = xvimagesink->event_thread;

      xvimagesink->event_thread = NULL;

    }

  }

  GST_OBJECT_UNLOCK (xvimagesink);

  /* Wait for our event thread to finish */

  if (thread)

    g_thread_join (thread);

}

/* Element stuff */

static GstCaps *

gst_xv_image_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)

{

  GstXvImageSink *xvimagesink;

  GstCaps *caps;

  xvimagesink = GST_XV_IMAGE_SINK (bsink);

  if (xvimagesink->context) {

    if (filter)

      return gst_caps_intersect_full (filter, xvimagesink->context->caps,

          GST_CAPS_INTERSECT_FIRST);

    else

      return gst_caps_ref (xvimagesink->context->caps);

  }

  caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (xvimagesink));

  if (filter) {

    GstCaps *intersection;

    intersection =

        gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);

    gst_caps_unref (caps);

    caps = intersection;

  }

  return caps;

}

static GstBufferPool *

gst_xv_image_sink_create_pool (GstXvImageSink * xvimagesink, GstCaps * caps,

    gsize size, gint min)

{

  GstBufferPool *pool;

  GstStructure *config;

  pool = gst_xvimage_buffer_pool_new (xvimagesink->allocator);

  config = gst_buffer_pool_get_config (pool);

  gst_buffer_pool_config_set_params (config, caps, size, min, 0);

  if (!gst_buffer_pool_set_config (pool, config))

    goto config_failed;

  return pool;

config_failed:

  {

    GST_ERROR_OBJECT (xvimagesink, "failed to set config.");

    gst_object_unref (pool);

    return NULL;

  }

}

static gboolean

gst_xv_image_sink_setcaps (GstBaseSink * bsink, GstCaps * caps)

{

  GstXvImageSink *xvimagesink;

  GstXvContext *context;

  GstBufferPool *newpool, *oldpool;

  GstVideoInfo info;

  guint32 im_format = 0;

  gint video_par_n, video_par_d;        /* video's PAR */

  gint display_par_n, display_par_d;    /* display's PAR */

  guint num, den;

  xvimagesink = GST_XV_IMAGE_SINK (bsink);

  context = xvimagesink->context;

  GST_DEBUG_OBJECT (xvimagesink,

      "In setcaps. Possible caps %" GST_PTR_FORMAT ", setting caps %"

      GST_PTR_FORMAT, context->caps, caps);

  if (!gst_caps_can_intersect (context->caps, caps))

    goto incompatible_caps;

  if (!gst_video_info_from_caps (&info, caps))

    goto invalid_format;

  xvimagesink->fps_n = info.fps_n;

  xvimagesink->fps_d = info.fps_d;

  xvimagesink->video_width = info.width;

  xvimagesink->video_height = info.height;

  im_format = gst_xvcontext_get_format_from_info (context, &info;;

  if (im_format == -1)

    goto invalid_format;

  gst_xvcontext_set_colorimetry (context, &info.colorimetry);

  /* get aspect ratio from caps if it's present, and

   * convert video width and height to a display width and height

   * using wd / hd = wv / hv * PARv / PARd */

  /* get video's PAR */

  video_par_n = info.par_n;

  video_par_d = info.par_d;

  /* get display's PAR */

  if (xvimagesink->par) {

    display_par_n = gst_value_get_fraction_numerator (xvimagesink->par);

    display_par_d = gst_value_get_fraction_denominator (xvimagesink->par);

  } else {

    display_par_n = 1;

    display_par_d = 1;

  }

  if (!gst_video_calculate_display_ratio (&num, &den, info.width,

          info.height, video_par_n, video_par_d, display_par_n, display_par_d))

    goto no_disp_ratio;

  GST_DEBUG_OBJECT (xvimagesink,

      "video width/height: %dx%d, calculated display ratio: %d/%d",

      info.width, info.height, num, den);

  /* now find a width x height that respects this display ratio.

   * prefer those that have one of w/h the same as the incoming video

   * using wd / hd = num / den */

  /* start with same height, because of interlaced video */

  /* check hd / den is an integer scale factor, and scale wd with the PAR */

  if (info.height % den == 0) {

    GST_DEBUG_OBJECT (xvimagesink, "keeping video height");

    GST_VIDEO_SINK_WIDTH (xvimagesink) = (guint)

        gst_util_uint64_scale_int (info.height, num, den);

    GST_VIDEO_SINK_HEIGHT (xvimagesink) = info.height;

  } else if (info.width % num == 0) {

    GST_DEBUG_OBJECT (xvimagesink, "keeping video width");

    GST_VIDEO_SINK_WIDTH (xvimagesink) = info.width;

    GST_VIDEO_SINK_HEIGHT (xvimagesink) = (guint)

        gst_util_uint64_scale_int (info.width, den, num);

  } else {

    GST_DEBUG_OBJECT (xvimagesink, "approximating while keeping video height");

    GST_VIDEO_SINK_WIDTH (xvimagesink) = (guint)

        gst_util_uint64_scale_int (info.height, num, den);

    GST_VIDEO_SINK_HEIGHT (xvimagesink) = info.height;

  }

  GST_DEBUG_OBJECT (xvimagesink, "scaling to %dx%d",

      GST_VIDEO_SINK_WIDTH (xvimagesink), GST_VIDEO_SINK_HEIGHT (xvimagesink));

  /* Notify application to set xwindow id now */

  g_mutex_lock (&xvimagesink->flow_lock);

  if (!xvimagesink->xwindow) {

    g_mutex_unlock (&xvimagesink->flow_lock);

    gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (xvimagesink));

  } else {

    g_mutex_unlock (&xvimagesink->flow_lock);

  }

  /* Creating our window and our image with the display size in pixels */

  if (GST_VIDEO_SINK_WIDTH (xvimagesink) <= 0 ||

      GST_VIDEO_SINK_HEIGHT (xvimagesink) <= 0)

    goto no_display_size;

  g_mutex_lock (&xvimagesink->flow_lock);

  if (!xvimagesink->xwindow) {

    xvimagesink->xwindow = gst_xv_image_sink_xwindow_new (xvimagesink,

        GST_VIDEO_SINK_WIDTH (xvimagesink),

        GST_VIDEO_SINK_HEIGHT (xvimagesink));

  }

  if (xvimagesink->pending_render_rect) {

    xvimagesink->pending_render_rect = FALSE;

    gst_xwindow_set_render_rectangle (xvimagesink->xwindow,

        xvimagesink->render_rect.x, xvimagesink->render_rect.y,

        xvimagesink->render_rect.w, xvimagesink->render_rect.h);

  }

  xvimagesink->info = info;

  /* After a resize, we want to redraw the borders in case the new frame size

   * doesn't cover the same area */

  xvimagesink->redraw_border = TRUE;

  /* create a new pool for the new configuration */

  newpool = gst_xv_image_sink_create_pool (xvimagesink, caps, info.size, 2);

  /* we don't activate the internal pool yet as it may not be needed */

  oldpool = xvimagesink->pool;

  xvimagesink->pool = newpool;

  g_mutex_unlock (&xvimagesink->flow_lock);

  /* deactivate and unref the old internal pool */

  if (oldpool) {

    gst_buffer_pool_set_active (oldpool, FALSE);

    gst_object_unref (oldpool);

  }

  return TRUE;

  /* ERRORS */

incompatible_caps:

  {

    GST_ERROR_OBJECT (xvimagesink, "caps incompatible");

    return FALSE;

  }

invalid_format:

  {

    GST_DEBUG_OBJECT (xvimagesink,

        "Could not locate image format from caps %" GST_PTR_FORMAT, caps);

    return FALSE;

  }

no_disp_ratio:

  {

    GST_ELEMENT_ERROR (xvimagesink, CORE, NEGOTIATION, (NULL),

        ("Error calculating the output display ratio of the video."));

    return FALSE;

  }

no_display_size:

  {

    GST_ELEMENT_ERROR (xvimagesink, CORE, NEGOTIATION, (NULL),

        ("Error calculating the output display size of the video."));

    return FALSE;

  }

}

static GstStateChangeReturn

gst_xv_image_sink_change_state (GstElement * element, GstStateChange transition)

{

  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;

  GstXvImageSink *xvimagesink;

  xvimagesink = GST_XV_IMAGE_SINK (element);

  switch (transition) {

    case GST_STATE_CHANGE_NULL_TO_READY:

      if (!gst_xv_image_sink_open (xvimagesink))

        goto error;

      break;

    case GST_STATE_CHANGE_READY_TO_PAUSED:

      break;

    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:

      break;

    case GST_STATE_CHANGE_PAUSED_TO_READY:

      break;

    default:

      break;

  }

  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

  switch (transition) {

    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:

      break;

    case GST_STATE_CHANGE_PAUSED_TO_READY:

      xvimagesink->fps_n = 0;