libs/video-overlay/gstimxxoverlay.c - imx-gst1.0-plugin - Git at Google

 /*
  * Copyright (c) 2013, Freescale Semiconductor, Inc. All rights reserved.
  *
  * 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.
  */

 #include <stdio.h>
 #include <string.h>
 /* for XkbKeycodeToKeysym */
 #include <X11/XKBlib.h>
 #include <gst/video/navigation.h>
 #include "gstimxvideooverlay.h"
 #include "gstimxxoverlay.h"

 #define RGB888TORGB565(rgb)\
     ((((rgb)<<8)>>27<<11)|(((rgb)<<18)>>26<<5)|(((rgb)<<27)>>27))

 GST_DEBUG_CATEGORY_STATIC (imxxoverlay_debug);
 #define GST_CAT_DEFAULT imxxoverlay_debug

 void
 gst_x_video_overlay_interface_init (GstVideoOverlayInterface * iface)
 {
   GST_DEBUG_CATEGORY_INIT (imxxoverlay_debug, "imxxoverlay", 0,
       "IMX X video overlay interface debugging");
 }

 /* This function get the relative coordinates of a window */
 static void
 gst_x_video_overlay_get_window_rect (ImxVideoOverlay * imxxoverlay,
     GstVideoRectangle * rect)
 {
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;
   if (xoverlay && xoverlay->disp && imxxoverlay->video_win) {
     XWindowAttributes attr;
     g_mutex_lock (&xoverlay->mutex);
     XGetWindowAttributes (xoverlay->disp, imxxoverlay->video_win, &attr);
     rect->x = 0;
     rect->y = 0;
     rect->w = attr.width;
     rect->h = attr.height;
     g_mutex_unlock (&xoverlay->mutex);
   }
 }

 /* This function should be called with mutex held */
 static void
 update_video_win (ImxVideoOverlay * imxxoverlay)
 {
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;
   if (!xoverlay || !xoverlay->disp || !imxxoverlay->video_win)
     return;

   Window win = imxxoverlay->video_win;
   Display *dpy = xoverlay->disp;

   /* We need the absolute coordination of the video render area to update the
    * video position, call the parent object provided callback to update the
    * new actual video geometry.
    */
   if (imxxoverlay->running) {
     GstVideoRectangle v_rect = {0};
     XWindowAttributes attr, root_attr;
     Window w;
     gint x = 0, y = 0;
     gint rw, rh;

     XGetWindowAttributes (dpy, win, &attr);
     GST_DEBUG ("%lu: %d:%d:%d:%d", win, attr.x, attr.y, attr.width, attr.height);

     XGetWindowAttributes (dpy, attr.root, &root_attr);
     XTranslateCoordinates (dpy, win, attr.root, 0, 0, &x, &y, &w);

     v_rect.x = x + imxxoverlay->render_rect.x;
     v_rect.y = y + imxxoverlay->render_rect.y;
     if (imxxoverlay->render_rect.w &&
         (imxxoverlay->render_rect.x + imxxoverlay->render_rect.w) < attr.width)
       v_rect.w = imxxoverlay->render_rect.w;
     else
       v_rect.w = attr.width - imxxoverlay->render_rect.x;

     if (imxxoverlay->render_rect.h &&
         (imxxoverlay->render_rect.y + imxxoverlay->render_rect.h) < attr.height)
       v_rect.h = imxxoverlay->render_rect.h;
     else
       v_rect.h = attr.height - imxxoverlay->render_rect.y;

     GST_DEBUG("x:y:w:h, %d:%d:%d:%d", v_rect.x, v_rect.y, v_rect.w, v_rect.h);

     if (v_rect.w <= 0 || v_rect.h <= 0) {
       GST_WARNING("Wrong window or video geometry!");
       return;
     }

     /* Set the color key and fill remain area with black if render area is
      * small than the video window. */
     GC gc = DefaultGC (dpy, DefaultScreen (dpy));
     XSetForeground (dpy, gc, BlackPixel(dpy, DefaultScreen (dpy)));
     XSetBackground (dpy, gc, BlackPixel(dpy, DefaultScreen (dpy)));
     if (imxxoverlay->render_rect.y)
       XFillRectangle (dpy, win, gc, 0, 0, attr.width, imxxoverlay->render_rect.y);
     if (imxxoverlay->render_rect.x)
       XFillRectangle (dpy, win, gc, 0, imxxoverlay->render_rect.y,
         imxxoverlay->render_rect.x, (attr.height - imxxoverlay->render_rect.y));
     rw = attr.width - imxxoverlay->render_rect.x - v_rect.w;
     rh = attr.height - imxxoverlay->render_rect.y - v_rect.h;

     if (rw)
       XFillRectangle (dpy, win, gc, imxxoverlay->render_rect.x + v_rect.w,
           imxxoverlay->render_rect.y, rw, v_rect.h);
     if (rh)
       XFillRectangle (dpy, win, gc, imxxoverlay->render_rect.x,
           imxxoverlay->render_rect.y + v_rect.h,
           attr.width - imxxoverlay->render_rect.x, rh);

     XSetForeground (dpy, gc, RGB888TORGB565(imxxoverlay->colorkey));
     //XClearWindow (dpy, win);
     XFillRectangle (dpy, win, gc, imxxoverlay->render_rect.x,
                     imxxoverlay->render_rect.y, v_rect.w, v_rect.h);
     XSync (dpy, FALSE);

     if (imxxoverlay->update_video_geo)
       imxxoverlay->update_video_geo(imxxoverlay->parent, v_rect);
   }
 }

 #ifdef DEFER_VIDEO_WINDOW_UPDATE
 static gboolean
 update_video_win_with_lock (gpointer data)
 {
   ImxVideoOverlay * imxxoverlay = (ImxVideoOverlay *)(data);
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;
   g_mutex_lock (&xoverlay->mutex);
   update_video_win(imxxoverlay);
   g_mutex_unlock (&xoverlay->mutex);

   /* ONCE */
   return FALSE;
 }
 #endif

 static void
 gst_x_video_overlay_update_video_win(ImxVideoOverlay * imxxoverlay)
 {
   GST_DEBUG ("invoked");
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;
   if (xoverlay) {
 #ifdef DEFER_VIDEO_WINDOW_UPDATE
     if (xoverlay->defer_update_id)
       g_source_remove(xoverlay->defer_update_id);

     xoverlay->defer_update_id =
         g_timeout_add (VIDEO_WIN_UPDATE_DEFER_TIME, update_video_win_with_lock, imxxoverlay);
 #else
     g_mutex_lock (&xoverlay->mutex);
     update_video_win(imxxoverlay);
     g_mutex_unlock (&xoverlay->mutex);
 #endif
   }
 }


 static gboolean
 gst_x_video_overlay_event_refresh (gpointer data)
 {
   ImxVideoOverlay * xo = (ImxVideoOverlay *)(data);
   XEvent e;
   ImxXOverlay *xoverlay = (ImxXOverlay *)xo->private;

   if (!xoverlay)
     return FALSE;

   if (!xo->running)  //Not start yet
     return TRUE;

   GST_LOG ("event refresh\n");
   g_mutex_lock (&xoverlay->mutex);

   /* If the element supports navigation, collect the relevant input
    * events and push them upstream as navigation events */
   if (GST_IS_NAVIGATION (xo->parent)) {
     gboolean pointer_moved = FALSE;

     /* We get all pointer motion events, only the last position is interesting*/
     while (XCheckWindowEvent(xoverlay->disp, xo->video_win, PointerMotionMask,
         &e)) {
       if (MotionNotify == e.type)
         pointer_moved = TRUE;
     }

     if (pointer_moved) {
       GST_DEBUG("pointer moved over window at %d,%d", e.xmotion.x, e.xmotion.y);
       g_mutex_unlock (&xoverlay->mutex);
       gst_navigation_send_mouse_event (GST_NAVIGATION (xo->parent),
           "mouse-move", 0, e.xbutton.x, e.xbutton.y);
       g_mutex_lock (&xoverlay->mutex);
     }

     /* We get all events on our window to throw them upstream */
     while (XCheckWindowEvent (xoverlay->disp, xo->video_win,
       KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask, &e)){
       KeySym keysym;
       const char *key_str = NULL;

       g_mutex_unlock (&xoverlay->mutex);

       switch (e.type) {
       case ButtonPress:
         GST_DEBUG ("button %d pressed over window at %d,%d",
                     e.xbutton.button, e.xbutton.x, e.xbutton.y);
         gst_navigation_send_mouse_event (GST_NAVIGATION (xo->parent),
                 "mouse-button-press", e.xbutton.button,
                 e.xbutton.x, e.xbutton.y);
         break;
       case ButtonRelease:
         GST_DEBUG ("button %d released over window at %d,%d",
                     e.xbutton.button, e.xbutton.x, e.xbutton.y);
         gst_navigation_send_mouse_event (GST_NAVIGATION (xo->parent),
                 "mouse-button-release", e.xbutton.button,
                 e.xbutton.x, e.xbutton.y);
         break;
       case KeyPress:
       case KeyRelease:
         g_mutex_lock (&xoverlay->mutex);
         keysym = XkbKeycodeToKeysym (xoverlay->disp, e.xkey.keycode, 0, 0);
         if (keysym != NoSymbol) {
           key_str = XKeysymToString (keysym);
         } else {
           key_str = "unknown";
         }
         g_mutex_unlock (&xoverlay->mutex);
         GST_DEBUG ("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 (xo->parent),
                 e.type == KeyPress ? "key-press" : "key-release", key_str);
         break;
       default:
         GST_DEBUG ("unhandled X event (%d)", e.type);
       }

       g_mutex_lock (&xoverlay->mutex);
     }
   }

   /* Handle ConfigureNotify */
   while (XCheckWindowEvent(xoverlay->disp, xo->video_win,
           ExposureMask |StructureNotifyMask, &e)) {
     switch (e.type) {
     case ConfigureNotify:
       GST_DEBUG ("ConfiureNotify event");
 #ifdef DEFER_VIDEO_WINDOW_UPDATE
       if (xoverlay->defer_update_id)
         g_source_remove(xoverlay->defer_update_id);

       xoverlay->defer_update_id =
                 g_timeout_add (VIDEO_WIN_UPDATE_DEFER_TIME, update_video_win_with_lock, xo);
 #else
       update_video_win(xo);
 #endif
       break;
     case Expose:
       if (e.xexpose.count > 0)
         break; //ignore repeated Expose event
       GST_DEBUG ("Expose event");
 #ifdef DEFER_VIDEO_WINDOW_UPDATE
       if (xoverlay->defer_update_id)
         g_source_remove(xoverlay->defer_update_id);

       xoverlay->defer_update_id =
                 g_timeout_add (VIDEO_WIN_UPDATE_DEFER_TIME, update_video_win_with_lock, xo);
 #else
       update_video_win(xo);
 #endif
       break;

     default:
       GST_DEBUG ("unknown X event (%d)", e.type);
     }
   }

   g_mutex_unlock (&xoverlay->mutex);

   /* repeat */
   return TRUE;
 }

 static gulong
 gst_x_video_overlay_create_window (ImxVideoOverlay * imxxoverlay)
 {
   GST_DEBUG ("creating window");
   Window win = 0;
 #ifdef ENABLE_PREPARE_WINDOW_INTERFACE
   int width, height;
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;

   if (!xoverlay)
     return 0;

   g_mutex_lock (&xoverlay->mutex);
   width = DisplayWidth(xoverlay->disp, DefaultScreen(xoverlay->disp));
   height = DisplayHeight(xoverlay->disp, DefaultScreen(xoverlay->disp));

   win = XCreateSimpleWindow (xoverlay->disp,
         DefaultRootWindow (xoverlay->disp), 0, 0, width, height, 0, 0,
         BlackPixel (xoverlay->disp, DefaultScreen (xoverlay->disp)));

   GST_DEBUG ("win=%lu", win);

   /* We have to do that to prevent X from redrawing the background on
    * ConfigureNotify. This takes away flickering of video when resizing. */
   XSetWindowBackgroundPixmap (xoverlay->disp, win, None);

   XMapRaised (xoverlay->disp, win);
   XSync (xoverlay->disp, FALSE);

   g_mutex_unlock (&xoverlay->mutex);
 #endif
   return win;
 }

 static void
 gst_x_video_overlay_destroy_window (ImxVideoOverlay * imxxoverlay)
 {
   GST_DEBUG ("internal_win %lu\n", imxxoverlay->internal_win);
 #ifdef ENABLE_PREPARE_WINDOW_INTERFACE
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;

   if (xoverlay && imxxoverlay->internal_win) {
     XDestroyWindow (xoverlay->disp, imxxoverlay->internal_win);
     imxxoverlay->internal_win = 0;
   }
 #endif
 }

 static void
 gst_x_video_overlay_handle_events (ImxVideoOverlay * imxxoverlay,
                                     gboolean handle_events)
 {
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;

   if (xoverlay) {
     g_mutex_lock (&xoverlay->mutex);
     long event_mask = ExposureMask | StructureNotifyMask;
     if (GST_IS_NAVIGATION (imxxoverlay->parent)) {
       event_mask |= PointerMotionMask |
           KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;
     }

     if (handle_events) {
       XSelectInput (xoverlay->disp, imxxoverlay->video_win, event_mask);
     } else {
       XSelectInput (xoverlay->disp, imxxoverlay->video_win, NoEventMask);
     }
     g_mutex_unlock (&xoverlay->mutex);
   }
 }

 void
 gst_x_video_overlay_init(ImxVideoOverlay * imxxoverlay)
 {
   if (imxxoverlay) {
     imxxoverlay->private = g_new0(ImxXOverlay, 1);
     imxxoverlay->update_win_geo = gst_x_video_overlay_update_video_win;
     imxxoverlay->get_win_rect = gst_x_video_overlay_get_window_rect;
     imxxoverlay->create_win = gst_x_video_overlay_create_window;
     imxxoverlay->destroy_win = gst_x_video_overlay_destroy_window;
     imxxoverlay->handle_events = gst_x_video_overlay_handle_events;
     imxxoverlay->event_polling = gst_x_video_overlay_event_refresh;

     const gchar *name = g_getenv ("DISPLAY");
     Display *dpy;

     /* Open the default display */
     if (!name) {
       GST_WARNING ("No $DISPLAY set, open :0\n");
       dpy = XOpenDisplay (":0");
     } else {
       dpy = XOpenDisplay (name);
     }

     if (!dpy) {
       GST_ERROR ("failed to open X display - no overlay");
       return;
     }

     ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;
     xoverlay->disp = dpy;
 #ifdef DEFER_VIDEO_WINDOW_UPDATE
     xoverlay->defer_update_id = 0;
 #endif
     g_mutex_init (&xoverlay->mutex);
     GST_DEBUG ("done");
   }
 }

 void
 gst_x_video_overlay_deinit(ImxVideoOverlay * imxxoverlay)
 {
   ImxXOverlay *xoverlay = (ImxXOverlay *)imxxoverlay->private;
   if (imxxoverlay->video_win)
     XSelectInput (xoverlay->disp, imxxoverlay->video_win, NoEventMask);
   gst_x_video_overlay_destroy_window(imxxoverlay);
   if (xoverlay->disp)
     XCloseDisplay (xoverlay->disp);
   xoverlay->disp = NULL;
   g_mutex_clear (&xoverlay->mutex);
   g_free(xoverlay);
   imxxoverlay->private = NULL;
   GST_DEBUG ("done");
 }
	/*
	* Copyright (c) 2013, Freescale Semiconductor, Inc. All rights reserved.
	*
	* 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.
	*/

	#include <stdio.h>
	#include <string.h>
	/* for XkbKeycodeToKeysym */
	#include <X11/XKBlib.h>
	#include <gst/video/navigation.h>
	#include "gstimxvideooverlay.h"
	#include "gstimxxoverlay.h"

	#define RGB888TORGB565(rgb)\
	((((rgb)<<8)>>27<<11)\|(((rgb)<<18)>>26<<5)\|(((rgb)<<27)>>27))

	GST_DEBUG_CATEGORY_STATIC (imxxoverlay_debug);
	#define GST_CAT_DEFAULT imxxoverlay_debug

	void
	gst_x_video_overlay_interface_init (GstVideoOverlayInterface * iface)
	{
	GST_DEBUG_CATEGORY_INIT (imxxoverlay_debug, "imxxoverlay", 0,
	"IMX X video overlay interface debugging");
	}

	/* This function get the relative coordinates of a window */
	static void
	gst_x_video_overlay_get_window_rect (ImxVideoOverlay * imxxoverlay,
	GstVideoRectangle * rect)
	{
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;
	if (xoverlay && xoverlay->disp && imxxoverlay->video_win) {
	XWindowAttributes attr;
	g_mutex_lock (&xoverlay->mutex);
	XGetWindowAttributes (xoverlay->disp, imxxoverlay->video_win, &attr);
	rect->x = 0;
	rect->y = 0;
	rect->w = attr.width;
	rect->h = attr.height;
	g_mutex_unlock (&xoverlay->mutex);
	}
	}

	/* This function should be called with mutex held */
	static void
	update_video_win (ImxVideoOverlay * imxxoverlay)
	{
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;
	if (!xoverlay \|\| !xoverlay->disp \|\| !imxxoverlay->video_win)
	return;

	Window win = imxxoverlay->video_win;
	Display *dpy = xoverlay->disp;

	/* We need the absolute coordination of the video render area to update the
	* video position, call the parent object provided callback to update the
	* new actual video geometry.
	*/
	if (imxxoverlay->running) {
	GstVideoRectangle v_rect = {0};
	XWindowAttributes attr, root_attr;
	Window w;
	gint x = 0, y = 0;
	gint rw, rh;

	XGetWindowAttributes (dpy, win, &attr);
	GST_DEBUG ("%lu: %d:%d:%d:%d", win, attr.x, attr.y, attr.width, attr.height);

	XGetWindowAttributes (dpy, attr.root, &root_attr);
	XTranslateCoordinates (dpy, win, attr.root, 0, 0, &x, &y, &w);

	v_rect.x = x + imxxoverlay->render_rect.x;
	v_rect.y = y + imxxoverlay->render_rect.y;
	if (imxxoverlay->render_rect.w &&
	(imxxoverlay->render_rect.x + imxxoverlay->render_rect.w) < attr.width)
	v_rect.w = imxxoverlay->render_rect.w;
	else
	v_rect.w = attr.width - imxxoverlay->render_rect.x;

	if (imxxoverlay->render_rect.h &&
	(imxxoverlay->render_rect.y + imxxoverlay->render_rect.h) < attr.height)
	v_rect.h = imxxoverlay->render_rect.h;
	else
	v_rect.h = attr.height - imxxoverlay->render_rect.y;

	GST_DEBUG("x:y:w:h, %d:%d:%d:%d", v_rect.x, v_rect.y, v_rect.w, v_rect.h);

	if (v_rect.w <= 0 \|\| v_rect.h <= 0) {
	GST_WARNING("Wrong window or video geometry!");
	return;
	}

	/* Set the color key and fill remain area with black if render area is
	* small than the video window. */
	GC gc = DefaultGC (dpy, DefaultScreen (dpy));
	XSetForeground (dpy, gc, BlackPixel(dpy, DefaultScreen (dpy)));
	XSetBackground (dpy, gc, BlackPixel(dpy, DefaultScreen (dpy)));
	if (imxxoverlay->render_rect.y)
	XFillRectangle (dpy, win, gc, 0, 0, attr.width, imxxoverlay->render_rect.y);
	if (imxxoverlay->render_rect.x)
	XFillRectangle (dpy, win, gc, 0, imxxoverlay->render_rect.y,
	imxxoverlay->render_rect.x, (attr.height - imxxoverlay->render_rect.y));
	rw = attr.width - imxxoverlay->render_rect.x - v_rect.w;
	rh = attr.height - imxxoverlay->render_rect.y - v_rect.h;

	if (rw)
	XFillRectangle (dpy, win, gc, imxxoverlay->render_rect.x + v_rect.w,
	imxxoverlay->render_rect.y, rw, v_rect.h);
	if (rh)
	XFillRectangle (dpy, win, gc, imxxoverlay->render_rect.x,
	imxxoverlay->render_rect.y + v_rect.h,
	attr.width - imxxoverlay->render_rect.x, rh);

	XSetForeground (dpy, gc, RGB888TORGB565(imxxoverlay->colorkey));
	//XClearWindow (dpy, win);
	XFillRectangle (dpy, win, gc, imxxoverlay->render_rect.x,
	imxxoverlay->render_rect.y, v_rect.w, v_rect.h);
	XSync (dpy, FALSE);

	if (imxxoverlay->update_video_geo)
	imxxoverlay->update_video_geo(imxxoverlay->parent, v_rect);
	}
	}

	#ifdef DEFER_VIDEO_WINDOW_UPDATE
	static gboolean
	update_video_win_with_lock (gpointer data)
	{
	ImxVideoOverlay * imxxoverlay = (ImxVideoOverlay *)(data);
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;
	g_mutex_lock (&xoverlay->mutex);
	update_video_win(imxxoverlay);
	g_mutex_unlock (&xoverlay->mutex);

	/* ONCE */
	return FALSE;
	}
	#endif

	static void
	gst_x_video_overlay_update_video_win(ImxVideoOverlay * imxxoverlay)
	{
	GST_DEBUG ("invoked");
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;
	if (xoverlay) {
	#ifdef DEFER_VIDEO_WINDOW_UPDATE
	if (xoverlay->defer_update_id)
	g_source_remove(xoverlay->defer_update_id);

	xoverlay->defer_update_id =
	g_timeout_add (VIDEO_WIN_UPDATE_DEFER_TIME, update_video_win_with_lock, imxxoverlay);
	#else
	g_mutex_lock (&xoverlay->mutex);
	update_video_win(imxxoverlay);
	g_mutex_unlock (&xoverlay->mutex);
	#endif
	}
	}


	static gboolean
	gst_x_video_overlay_event_refresh (gpointer data)
	{
	ImxVideoOverlay * xo = (ImxVideoOverlay *)(data);
	XEvent e;
	ImxXOverlay xoverlay = (ImxXOverlay )xo->private;

	if (!xoverlay)
	return FALSE;

	if (!xo->running) //Not start yet
	return TRUE;

	GST_LOG ("event refresh\n");
	g_mutex_lock (&xoverlay->mutex);

	/* If the element supports navigation, collect the relevant input
	* events and push them upstream as navigation events */
	if (GST_IS_NAVIGATION (xo->parent)) {
	gboolean pointer_moved = FALSE;

	/* We get all pointer motion events, only the last position is interesting*/
	while (XCheckWindowEvent(xoverlay->disp, xo->video_win, PointerMotionMask,
	&e)) {
	if (MotionNotify == e.type)
	pointer_moved = TRUE;
	}

	if (pointer_moved) {
	GST_DEBUG("pointer moved over window at %d,%d", e.xmotion.x, e.xmotion.y);
	g_mutex_unlock (&xoverlay->mutex);
	gst_navigation_send_mouse_event (GST_NAVIGATION (xo->parent),
	"mouse-move", 0, e.xbutton.x, e.xbutton.y);
	g_mutex_lock (&xoverlay->mutex);
	}

	/* We get all events on our window to throw them upstream */
	while (XCheckWindowEvent (xoverlay->disp, xo->video_win,
	KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask, &e)){
	KeySym keysym;
	const char *key_str = NULL;

	g_mutex_unlock (&xoverlay->mutex);

	switch (e.type) {
	case ButtonPress:
	GST_DEBUG ("button %d pressed over window at %d,%d",
	e.xbutton.button, e.xbutton.x, e.xbutton.y);
	gst_navigation_send_mouse_event (GST_NAVIGATION (xo->parent),
	"mouse-button-press", e.xbutton.button,
	e.xbutton.x, e.xbutton.y);
	break;
	case ButtonRelease:
	GST_DEBUG ("button %d released over window at %d,%d",
	e.xbutton.button, e.xbutton.x, e.xbutton.y);
	gst_navigation_send_mouse_event (GST_NAVIGATION (xo->parent),
	"mouse-button-release", e.xbutton.button,
	e.xbutton.x, e.xbutton.y);
	break;
	case KeyPress:
	case KeyRelease:
	g_mutex_lock (&xoverlay->mutex);
	keysym = XkbKeycodeToKeysym (xoverlay->disp, e.xkey.keycode, 0, 0);
	if (keysym != NoSymbol) {
	key_str = XKeysymToString (keysym);
	} else {
	key_str = "unknown";
	}
	g_mutex_unlock (&xoverlay->mutex);
	GST_DEBUG ("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 (xo->parent),
	e.type == KeyPress ? "key-press" : "key-release", key_str);
	break;
	default:
	GST_DEBUG ("unhandled X event (%d)", e.type);
	}

	g_mutex_lock (&xoverlay->mutex);
	}
	}

	/* Handle ConfigureNotify */
	while (XCheckWindowEvent(xoverlay->disp, xo->video_win,
	ExposureMask \|StructureNotifyMask, &e)) {
	switch (e.type) {
	case ConfigureNotify:
	GST_DEBUG ("ConfiureNotify event");
	#ifdef DEFER_VIDEO_WINDOW_UPDATE
	if (xoverlay->defer_update_id)
	g_source_remove(xoverlay->defer_update_id);

	xoverlay->defer_update_id =
	g_timeout_add (VIDEO_WIN_UPDATE_DEFER_TIME, update_video_win_with_lock, xo);
	#else
	update_video_win(xo);
	#endif
	break;
	case Expose:
	if (e.xexpose.count > 0)
	break; //ignore repeated Expose event
	GST_DEBUG ("Expose event");
	#ifdef DEFER_VIDEO_WINDOW_UPDATE
	if (xoverlay->defer_update_id)
	g_source_remove(xoverlay->defer_update_id);

	xoverlay->defer_update_id =
	g_timeout_add (VIDEO_WIN_UPDATE_DEFER_TIME, update_video_win_with_lock, xo);
	#else
	update_video_win(xo);
	#endif
	break;

	default:
	GST_DEBUG ("unknown X event (%d)", e.type);
	}
	}

	g_mutex_unlock (&xoverlay->mutex);

	/* repeat */
	return TRUE;
	}

	static gulong
	gst_x_video_overlay_create_window (ImxVideoOverlay * imxxoverlay)
	{
	GST_DEBUG ("creating window");
	Window win = 0;
	#ifdef ENABLE_PREPARE_WINDOW_INTERFACE
	int width, height;
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;

	if (!xoverlay)
	return 0;

	g_mutex_lock (&xoverlay->mutex);
	width = DisplayWidth(xoverlay->disp, DefaultScreen(xoverlay->disp));
	height = DisplayHeight(xoverlay->disp, DefaultScreen(xoverlay->disp));

	win = XCreateSimpleWindow (xoverlay->disp,
	DefaultRootWindow (xoverlay->disp), 0, 0, width, height, 0, 0,
	BlackPixel (xoverlay->disp, DefaultScreen (xoverlay->disp)));

	GST_DEBUG ("win=%lu", win);

	/* We have to do that to prevent X from redrawing the background on
	* ConfigureNotify. This takes away flickering of video when resizing. */
	XSetWindowBackgroundPixmap (xoverlay->disp, win, None);

	XMapRaised (xoverlay->disp, win);
	XSync (xoverlay->disp, FALSE);

	g_mutex_unlock (&xoverlay->mutex);
	#endif
	return win;
	}

	static void
	gst_x_video_overlay_destroy_window (ImxVideoOverlay * imxxoverlay)
	{
	GST_DEBUG ("internal_win %lu\n", imxxoverlay->internal_win);
	#ifdef ENABLE_PREPARE_WINDOW_INTERFACE
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;

	if (xoverlay && imxxoverlay->internal_win) {
	XDestroyWindow (xoverlay->disp, imxxoverlay->internal_win);
	imxxoverlay->internal_win = 0;
	}
	#endif
	}

	static void
	gst_x_video_overlay_handle_events (ImxVideoOverlay * imxxoverlay,
	gboolean handle_events)
	{
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;

	if (xoverlay) {
	g_mutex_lock (&xoverlay->mutex);
	long event_mask = ExposureMask \| StructureNotifyMask;
	if (GST_IS_NAVIGATION (imxxoverlay->parent)) {
	event_mask \|= PointerMotionMask \|
	KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask;
	}

	if (handle_events) {
	XSelectInput (xoverlay->disp, imxxoverlay->video_win, event_mask);
	} else {
	XSelectInput (xoverlay->disp, imxxoverlay->video_win, NoEventMask);
	}
	g_mutex_unlock (&xoverlay->mutex);
	}
	}

	void
	gst_x_video_overlay_init(ImxVideoOverlay * imxxoverlay)
	{
	if (imxxoverlay) {
	imxxoverlay->private = g_new0(ImxXOverlay, 1);
	imxxoverlay->update_win_geo = gst_x_video_overlay_update_video_win;
	imxxoverlay->get_win_rect = gst_x_video_overlay_get_window_rect;
	imxxoverlay->create_win = gst_x_video_overlay_create_window;
	imxxoverlay->destroy_win = gst_x_video_overlay_destroy_window;
	imxxoverlay->handle_events = gst_x_video_overlay_handle_events;
	imxxoverlay->event_polling = gst_x_video_overlay_event_refresh;

	const gchar *name = g_getenv ("DISPLAY");
	Display *dpy;

	/* Open the default display */
	if (!name) {
	GST_WARNING ("No $DISPLAY set, open :0\n");
	dpy = XOpenDisplay (":0");
	} else {
	dpy = XOpenDisplay (name);
	}

	if (!dpy) {
	GST_ERROR ("failed to open X display - no overlay");
	return;
	}

	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;
	xoverlay->disp = dpy;
	#ifdef DEFER_VIDEO_WINDOW_UPDATE
	xoverlay->defer_update_id = 0;
	#endif
	g_mutex_init (&xoverlay->mutex);
	GST_DEBUG ("done");
	}
	}

	void
	gst_x_video_overlay_deinit(ImxVideoOverlay * imxxoverlay)
	{
	ImxXOverlay xoverlay = (ImxXOverlay )imxxoverlay->private;
	if (imxxoverlay->video_win)
	XSelectInput (xoverlay->disp, imxxoverlay->video_win, NoEventMask);
	gst_x_video_overlay_destroy_window(imxxoverlay);
	if (xoverlay->disp)
	XCloseDisplay (xoverlay->disp);
	xoverlay->disp = NULL;
	g_mutex_clear (&xoverlay->mutex);
	g_free(xoverlay);
	imxxoverlay->private = NULL;
	GST_DEBUG ("done");
	}