1 /* GStreamer

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

     3  *

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

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

     6  * License as published by the Free Software Foundation; either

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

     8  *

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

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

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

    12  * Library General Public License for more details.

    13  *

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

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

    16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17  * Boston, MA 02111-1307, USA.

    18  */

    19 

    20 /**

    21  * SECTION:element-ximagesink

    22  *

    23  * <refsect2>

    24  * <para>

    25  * XImageSink renders video frames to a drawable (XWindow) on a local or remote

    26  * display. This element can receive a Window ID from the application through

    27  * the XOverlay interface and will then render video frames in this drawable.

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

    29  * own internal window and render into it.

    30  * </para>

    31  * <title>Scaling</title>

    32  * <para>

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

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

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

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

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

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

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

    40  * at the

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

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

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

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

    45  * </para>

    46  * <title>Events</title>

    47  * <para>

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

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

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

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

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

    53  * Other events are used to handle the drawable appearance even when the data

    54  * is not flowing (GST_STATE_PAUSED). That means that even when the element is

    55  * paused, it will receive expose events from the drawable and draw the latest

    56  * frame with correct borders/aspect-ratio.

    57  * </para>

    58  * <title>Pixel aspect ratio</title>

    59  * <para>

    60  * When changing state to GST_STATE_READY, XImageSink will open a connection to

    61  * the display specified in the

    62  * <link linkend="GstXImageSink--display">display</link> property or the default

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

    64  * the display configuration including the physical display geometry and 

    65  * then calculate the pixel aspect ratio. When caps negotiation will occur, the

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

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

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

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

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

    71  * property.

    72  * </para>

    73  * <title>Examples</title>

    74  * <para>

    75  * Here is a simple pipeline to test reverse negotiation :

    76  * <programlisting>

    77  * gst-launch -v videotestsrc ! queue ! ximagesink

    78  * </programlisting>

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

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

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

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

    83  * </para>

    84  * <para>

    85  * Here is a simple pipeline to test navigation events :

    86  * <programlisting>

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

    88  * </programlisting>

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

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

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

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

    93  * is part of gst-plugins-good.)

    94  * </para>

    95  * <para>

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

    97  * <programlisting>

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

    99  * </programlisting>

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

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

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

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

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

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

   106  * </para>

   107  * </refsect2>

   108  */

   109 

   110 #ifdef HAVE_CONFIG_H

   111 #include "config.h"

   112 #endif

   113 

   114 /* Our interfaces */

   115 #include <gst/interfaces/navigation.h>

   116 #include <gst/interfaces/xoverlay.h>

   117 

   118 /* Object header */

   119 #include "ximagesink.h"

   120 

   121 /* Debugging category */

   122 #include <gst/gstinfo.h>

   123 

   124 GST_DEBUG_CATEGORY_EXTERN (gst_debug_ximagesink);

   125 #define GST_CAT_DEFAULT gst_debug_ximagesink

   126 

   127 typedef struct

   128 {

   129   unsigned long flags;

   130   unsigned long functions;

   131   unsigned long decorations;

   132   long input_mode;

   133   unsigned long status;

   134 }

   135 MotifWmHints, MwmHints;

   136 

   137 #define MWM_HINTS_DECORATIONS   (1L << 1)

   138 

   139 static void gst_ximagesink_reset (GstXImageSink * ximagesink);

   140 static void gst_ximagesink_ximage_destroy (GstXImageSink * ximagesink,

   141     GstXImageBuffer * ximage);

   142 static void gst_ximagesink_xwindow_update_geometry (GstXImageSink * ximagesink,

   143     GstXWindow * xwindow);

   144 static void gst_ximagesink_expose (GstXOverlay * overlay);

   145 

   146 /* ElementFactory information */

   147 static const GstElementDetails gst_ximagesink_details =

   148 GST_ELEMENT_DETAILS ("Video sink",

   149     "Sink/Video",

   150     "A standard X based videosink",

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

   152 

   153 static GstStaticPadTemplate gst_ximagesink_sink_template_factory =

   154 GST_STATIC_PAD_TEMPLATE ("sink",

   155     GST_PAD_SINK,

   156     GST_PAD_ALWAYS,

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

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

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

   160     );

   161 

   162 enum

   163 {

   164   PROP_0,

   165   PROP_DISPLAY,

   166   PROP_SYNCHRONOUS,

   167   PROP_PIXEL_ASPECT_RATIO,

   168   PROP_FORCE_ASPECT_RATIO,

   169   PROP_HANDLE_EVENTS,

   170   PROP_HANDLE_EXPOSE

   171 };

   172 

   173 static GstVideoSinkClass *parent_class = NULL;

   174 

   175 /* ============================================================= */

   176 /*                                                               */

   177 /*                       Private Methods                         */

   178 /*                                                               */

   179 /* ============================================================= */

   180 

   181 /* ximage buffers */

   182 

   183 static GstBufferClass *ximage_buffer_parent_class = NULL;

   184 

   185 #define GST_TYPE_XIMAGE_BUFFER (gst_ximage_buffer_get_type())

   186 

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

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

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

   190 

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

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

   193    supposed to call gst_buffer_unref that's going to call gst_mini_objec_unref

   194    which will handle its own refcount system and call gst_mini_object_free.

   195    gst_mini_object_free will call the class finalize method which is not the 

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

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

   198 static void

   199 gst_ximage_buffer_finalize (GstXImageBuffer * ximage)

   200 {

   201   GstXImageSink *ximagesink = NULL;

   202   gboolean recycled = FALSE;

   203   gboolean running;

   204 

   205   g_return_if_fail (ximage != NULL);

   206 

   207   ximagesink = ximage->ximagesink;

   208   if (G_UNLIKELY (ximagesink == NULL)) {

   209     GST_WARNING_OBJECT (ximagesink, "no sink found");

   210     goto beach;

   211   }

   212 

   213   GST_OBJECT_LOCK (ximagesink);

   214   running = ximagesink->running;

   215   GST_OBJECT_UNLOCK (ximagesink);

   216 

   217   if (running == FALSE) {

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

   219     GST_DEBUG_OBJECT (ximagesink,

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

   221     gst_ximagesink_ximage_destroy (ximagesink, ximage);

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

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

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

   225     GST_DEBUG_OBJECT (ximagesink,

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

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

   228         GST_VIDEO_SINK_WIDTH (ximagesink), GST_VIDEO_SINK_HEIGHT (ximagesink));

   229     gst_ximagesink_ximage_destroy (ximagesink, ximage);

   230   } else {

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

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

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

   234     gst_buffer_ref (GST_BUFFER_CAST (ximage));

   235     g_mutex_lock (ximagesink->pool_lock);

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

   237     g_mutex_unlock (ximagesink->pool_lock);

   238     recycled = TRUE;

   239   }

   240 

   241   if (!recycled)

   242     GST_MINI_OBJECT_CLASS (ximage_buffer_parent_class)->

   243         finalize (GST_MINI_OBJECT (ximage));

   244 

   245 beach:

   246   return;

   247 }

   248 

   249 static void

   250 gst_ximage_buffer_free (GstXImageBuffer * ximage)

   251 {

   252   /* make sure it is not recycled */

   253   ximage->width = -1;

   254   ximage->height = -1;

   255   gst_buffer_unref (GST_BUFFER_CAST (ximage));

   256 }

   257 

   258 static void

   259 gst_ximage_buffer_init (GstXImageBuffer * ximage_buffer, gpointer g_class)

   260 {

   261 #ifdef HAVE_XSHM

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

   263   ximage_buffer->SHMInfo.shmid = -1;

   264 #endif

   265 }

   266 

   267 static void

   268 gst_ximage_buffer_class_init (gpointer g_class, gpointer class_data)

   269 {

   270   GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);

   271 

   272   ximage_buffer_parent_class = g_type_class_peek_parent (g_class);

   273 

   274   mini_object_class->finalize = (GstMiniObjectFinalizeFunction)

   275       gst_ximage_buffer_finalize;

   276 }

   277 

   278 static GType

   279 gst_ximage_buffer_get_type (void)

   280 {

   281   static GType _gst_ximage_buffer_type;

   282 

   283   if (G_UNLIKELY (_gst_ximage_buffer_type == 0)) {

   284     static const GTypeInfo ximage_buffer_info = {

   285       sizeof (GstBufferClass),

   286       NULL,

   287       NULL,

   288       gst_ximage_buffer_class_init,

   289       NULL,

   290       NULL,

   291       sizeof (GstXImageBuffer),

   292       0,

   293       (GInstanceInitFunc) gst_ximage_buffer_init,

   294       NULL

   295     };

   296     _gst_ximage_buffer_type = g_type_register_static (GST_TYPE_BUFFER,

   297         "GstXImageBuffer", &ximage_buffer_info, 0);

   298   }

   299   return _gst_ximage_buffer_type;

   300 }

   301 

   302 /* X11 stuff */

   303 

   304 static gboolean error_caught = FALSE;

   305 

   306 static int

   307 gst_ximagesink_handle_xerror (Display * display, XErrorEvent * xevent)

   308 {

   309   char error_msg[1024];

   310 

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

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

   313   error_caught = TRUE;

   314   return 0;

   315 }

   316 

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

   318 

   319 static gboolean

   320 gst_ximagesink_check_xshm_calls (GstXImageSink * ximagesink,

   321     GstXContext * xcontext)

   322 {

   323   XImage *ximage;

   324   XShmSegmentInfo SHMInfo;

   325   size_t size;

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

   327   gboolean result = FALSE;

   328   gboolean did_attach = FALSE;

   329 

   330   g_return_val_if_fail (xcontext != NULL, FALSE);

   331 

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

   333   XSync (xcontext->disp, FALSE);

   334 

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

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

   337   SHMInfo.shmid = -1;

   338 

   339   /* Setting an error handler to catch failure */

   340   error_caught = FALSE;

   341   handler = XSetErrorHandler (gst_ximagesink_handle_xerror);

   342 

   343   /* Trying to create a 1x1 ximage */

   344   GST_DEBUG ("XShmCreateImage of 1x1");

   345 

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

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

   348 

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

   350   XSync (xcontext->disp, FALSE);

   351   if (!ximage || error_caught) {

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

   353     goto beach;

   354   }

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

   356 

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

   358   if (SHMInfo.shmid == -1) {

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

   360         size);

   361     goto beach;

   362   }

   363 

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

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

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

   367     /* Clean up shm seg */

   368     shmctl (SHMInfo.shmid, IPC_RMID, NULL);

   369     goto beach;

   370   }

   371 

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

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

   374    * leaked if we crash. */

   375   shmctl (SHMInfo.shmid, IPC_RMID, NULL);

   376 

   377   ximage->data = SHMInfo.shmaddr;

   378   SHMInfo.readOnly = FALSE;

   379 

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

   381     GST_WARNING ("Failed to XShmAttach");

   382     goto beach;

   383   }

   384 

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

   386   XSync (xcontext->disp, FALSE);

   387 

   388   if (!error_caught) {

   389     did_attach = TRUE;

   390     /* store whether we succeeded in result */

   391     result = TRUE;

   392   }

   393 

   394 beach:

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

   396   XSync (xcontext->disp, FALSE);

   397   error_caught = FALSE;

   398   XSetErrorHandler (handler);

   399 

   400   if (did_attach) {

   401     XShmDetach (xcontext->disp, &SHMInfo);

   402     XSync (xcontext->disp, FALSE);

   403   }

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

   405     shmdt (SHMInfo.shmaddr);

   406   if (ximage)

   407     XDestroyImage (ximage);

   408   return result;

   409 }

   410 #endif /* HAVE_XSHM */

   411 

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

   413 static GstXImageBuffer *

   414 gst_ximagesink_ximage_new (GstXImageSink * ximagesink, GstCaps * caps)

   415 {

   416   GstXImageBuffer *ximage = NULL;

   417   GstStructure *structure = NULL;

   418   gboolean succeeded = FALSE;

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

   420 

   421   g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);

   422 

   423   ximage = (GstXImageBuffer *) gst_mini_object_new (GST_TYPE_XIMAGE_BUFFER);

   424 

   425   structure = gst_caps_get_structure (caps, 0);

   426 

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

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

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

   430   }

   431 

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

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

   434 

   435   g_mutex_lock (ximagesink->x_lock);

   436 

   437   /* Setting an error handler to catch failure */

   438   error_caught = FALSE;

   439   handler = XSetErrorHandler (gst_ximagesink_handle_xerror);

   440 

   441 #ifdef HAVE_XSHM

   442   if (ximagesink->xcontext->use_xshm) {

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

   444         ximagesink->xcontext->visual,

   445         ximagesink->xcontext->depth,

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

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

   448       g_mutex_unlock (ximagesink->x_lock);

   449       /* Reset error handler */

   450       error_caught = FALSE;

   451       XSetErrorHandler (handler);

   452       /* Push an error */

   453       GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

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

   455               ximage->width, ximage->height),

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

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

   458       goto beach;

   459     }

   460 

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

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

   463     GST_LOG_OBJECT (ximagesink,

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

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

   466 

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

   468         IPC_CREAT | 0777);

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

   470       g_mutex_unlock (ximagesink->x_lock);

   471       GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

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

   473               ximage->width, ximage->height),

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

   475               ximage->size));

   476       goto beach;

   477     }

   478 

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

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

   481       g_mutex_unlock (ximagesink->x_lock);

   482       GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

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

   484               ximage->width, ximage->height),

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

   486       /* Clean up the shared memory segment */

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

   488       goto beach;

   489     }

   490 

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

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

   493      * leaked if we crash. */

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

   495 

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

   497     ximage->SHMInfo.readOnly = FALSE;

   498 

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

   500       g_mutex_unlock (ximagesink->x_lock);

   501       GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

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

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

   504       goto beach;

   505     }

   506 

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

   508   } else

   509 #endif /* HAVE_XSHM */

   510   {

   511     guint allocsize;

   512 

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

   514         ximagesink->xcontext->visual,

   515         ximagesink->xcontext->depth,

   516         ZPixmap, 0, NULL,

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

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

   519       g_mutex_unlock (ximagesink->x_lock);

   520       /* Reset error handler */

   521       error_caught = FALSE;

   522       XSetErrorHandler (handler);

   523       /* Push an error */

   524       GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,

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

   526               ximage->width, ximage->height),

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

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

   529       goto beach;

   530     }

   531 

   532     /* upstream will assume that rowstrides are multiples of 4, but this

   533      * doesn't always seem to be the case with XCreateImage() */

   534     if ((ximage->ximage->bytes_per_line % 4) != 0) {

   535       GST_WARNING_OBJECT (ximagesink, "returned stride not a multiple of 4 as "

   536           "usually assumed");

   537     }

   538 

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

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

   541 

   542     /* alloc a bit more for unexpected strides to avoid crashes upstream.

   543      * FIXME: if we get an unrounded stride, the image will be displayed

   544      * distorted, since all upstream elements assume a rounded stride */

   545     allocsize =

   546         GST_ROUND_UP_4 (ximage->ximage->bytes_per_line) *

   547         ximage->ximage->height;

   548     ximage->ximage->data = g_malloc (allocsize);

   549     GST_LOG_OBJECT (ximagesink,

   550         "non-XShm image size is %" G_GSIZE_FORMAT " (alloced: %u), width %d, "

   551         "stride %d", ximage->size, allocsize, ximage->width,

   552         ximage->ximage->bytes_per_line);

   553 

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

   555   }

   556 

   557   /* Reset error handler */

   558   error_caught = FALSE;

   559   XSetErrorHandler (handler);

   560 

   561   succeeded = TRUE;

   562 

   563   GST_BUFFER_DATA (ximage) = (guchar *) ximage->ximage->data;

   564   GST_BUFFER_SIZE (ximage) = ximage->size;

   565 

   566   /* Keep a ref to our sink */

   567   ximage->ximagesink = gst_object_ref (ximagesink);

   568 

   569   g_mutex_unlock (ximagesink->x_lock);

   570 beach:

   571   if (!succeeded) {

   572     gst_ximage_buffer_free (ximage);

   573     ximage = NULL;

   574   }

   575 

   576   return ximage;

   577 }

   578 

   579 /* This function destroys a GstXImageBuffer handling XShm availability */

   580 static void

   581 gst_ximagesink_ximage_destroy (GstXImageSink * ximagesink,

   582     GstXImageBuffer * ximage)

   583 {

   584   g_return_if_fail (ximage != NULL);

   585   g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));

   586 

   587   /* Hold the object lock to ensure the XContext doesn't disappear */

   588   GST_OBJECT_LOCK (ximagesink);

   589 

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

   591   if (ximagesink->cur_image == ximage) {

   592     ximagesink->cur_image = NULL;

   593   }

   594 

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

   596   if (!ximagesink->xcontext) {

   597     GST_DEBUG_OBJECT (ximagesink, "Destroying XImage after XContext");

   598 #ifdef HAVE_XSHM

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

   600       shmdt (ximage->SHMInfo.shmaddr);

   601     }

   602 #endif

   603     goto beach;

   604   }

   605 

   606   g_mutex_lock (ximagesink->x_lock);

   607 

   608 #ifdef HAVE_XSHM

   609   if (ximagesink->xcontext->use_xshm) {

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

   611       XShmDetach (ximagesink->xcontext->disp, &ximage->SHMInfo);

   612       XSync (ximagesink->xcontext->disp, 0);

   613       shmdt (ximage->SHMInfo.shmaddr);

   614     }

   615     if (ximage->ximage)

   616       XDestroyImage (ximage->ximage);

   617 

   618   } else

   619 #endif /* HAVE_XSHM */

   620   {

   621     if (ximage->ximage) {

   622       XDestroyImage (ximage->ximage);

   623     }

   624   }

   625 

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

   627 

   628   g_mutex_unlock (ximagesink->x_lock);

   629 

   630 beach:

   631   GST_OBJECT_UNLOCK (ximagesink);

   632 

   633   if (ximage->ximagesink) {

   634     /* Release the ref to our sink */

   635     ximage->ximagesink = NULL;

   636     gst_object_unref (ximagesink);

   637   }

   638 

   639   return;

   640 }

   641 

   642 /* We are called with the x_lock taken */

   643 static void

   644 gst_ximagesink_xwindow_draw_borders (GstXImageSink * ximagesink,

   645     GstXWindow * xwindow, GstVideoRectangle rect)

   646 {

   647   g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));

   648   g_return_if_fail (xwindow != NULL);

   649 

   650   XSetForeground (ximagesink->xcontext->disp, xwindow->gc,

   651       ximagesink->xcontext->black);

   652 

   653   /* Left border */

   654   if (rect.x > 0) {

   655     XFillRectangle (ximagesink->xcontext->disp, xwindow->win, xwindow->gc,

   656         0, 0, rect.x, xwindow->height);

   657   }

   658 

   659   /* Right border */

   660   if ((rect.x + rect.w) < xwindow->width) {

   661     XFillRectangle (ximagesink->xcontext->disp, xwindow->win, xwindow->gc,

   662         rect.x + rect.w, 0, xwindow->width, xwindow->height);

   663   }

   664 

   665   /* Top border */

   666   if (rect.y > 0) {

   667     XFillRectangle (ximagesink->xcontext->disp, xwindow->win, xwindow->gc,

   668         0, 0, xwindow->width, rect.y);

   669   }

   670 

   671   /* Bottom border */

   672   if ((rect.y + rect.h) < xwindow->height) {

   673     XFillRectangle (ximagesink->xcontext->disp, xwindow->win, xwindow->gc,

   674         0, rect.y + rect.h, xwindow->width, xwindow->height);

   675   }

   676 }

   677 

   678 /* This function puts a GstXImageBuffer on a GstXImageSink's window */

   679 static gboolean

   680 gst_ximagesink_ximage_put (GstXImageSink * ximagesink, GstXImageBuffer * ximage)

   681 {

   682   GstVideoRectangle src, dst, result;

   683   gboolean draw_border = FALSE;

   684 

   685   g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), FALSE);

   686 

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

   688      concurrently from the data flow thread */

   689   g_mutex_lock (ximagesink->flow_lock);

   690 

   691   if (G_UNLIKELY (ximagesink->xwindow == NULL)) {

   692     g_mutex_unlock (ximagesink->flow_lock);

   693     return FALSE;

   694   }

   695 

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

   697      draw borders only on expose event. */

   698   if (!ximagesink->cur_image) {

   699     draw_border = TRUE;

   700   }

   701 

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

   703   if (ximage && ximagesink->cur_image != ximage) {

   704     if (ximagesink->cur_image) {

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

   706       gst_buffer_unref (ximagesink->cur_image);

   707     }

   708     GST_LOG_OBJECT (ximagesink, "reffing %p as our current image", ximage);

   709     ximagesink->cur_image =

   710         GST_XIMAGE_BUFFER (gst_buffer_ref (GST_BUFFER_CAST (ximage)));

   711   }

   712 

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

   714   if (!ximage) {

   715     draw_border = TRUE;

   716     if (ximagesink->cur_image) {

   717       ximage = ximagesink->cur_image;

   718     } else {

   719       g_mutex_unlock (ximagesink->flow_lock);

   720       return TRUE;

   721     }

   722   }

   723 

   724   gst_ximagesink_xwindow_update_geometry (ximagesink, ximagesink->xwindow);

   725 

   726   src.w = ximage->width;

   727   src.h = ximage->height;

   728   dst.w = ximagesink->xwindow->width;

   729   dst.h = ximagesink->xwindow->height;

   730 

   731   gst_video_sink_center_rect (src, dst, &result, FALSE);

   732 

   733   g_mutex_lock (ximagesink->x_lock);

   734 

   735   if (draw_border) {

   736     gst_ximagesink_xwindow_draw_borders (ximagesink, ximagesink->xwindow,

   737         result);

   738   }

   739 #ifdef HAVE_XSHM

   740   if (ximagesink->xcontext->use_xshm) {

   741     GST_LOG_OBJECT (ximagesink,

   742         "XShmPutImage on %p, src: %d, %d - dest: %d, %d, dim: %dx%d, win %dx%d",

   743         ximage, 0, 0, result.x, result.y, result.w, result.h,

   744         ximagesink->xwindow->width, ximagesink->xwindow->height);

   745     XShmPutImage (ximagesink->xcontext->disp, ximagesink->xwindow->win,

   746         ximagesink->xwindow->gc, ximage->ximage, 0, 0, result.x, result.y,

   747         result.w, result.h, FALSE);

   748   } else

   749 #endif /* HAVE_XSHM */

   750   {

   751     GST_LOG_OBJECT (ximagesink,

   752         "XPutImage on %p, src: %d, %d - dest: %d, %d, dim: %dx%d, win %dx%d",

   753         ximage, 0, 0, result.x, result.y, result.w, result.h,

   754         ximagesink->xwindow->width, ximagesink->xwindow->height);

   755     XPutImage (ximagesink->xcontext->disp, ximagesink->xwindow->win,

   756         ximagesink->xwindow->gc, ximage->ximage, 0, 0, result.x, result.y,

   757         result.w, result.h);

   758   }

   759 

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

   761 

   762   g_mutex_unlock (ximagesink->x_lock);

   763 

   764   g_mutex_unlock (ximagesink->flow_lock);

   765 

   766   return TRUE;

   767 }

   768 

   769 static gboolean

   770 gst_ximagesink_xwindow_decorate (GstXImageSink * ximagesink,

   771     GstXWindow * window)

   772 {

   773   Atom hints_atom = None;

   774   MotifWmHints *hints;

   775 

   776   g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), FALSE);

   777   g_return_val_if_fail (window != NULL, FALSE);

   778 

   779   g_mutex_lock (ximagesink->x_lock);

   780 

   781   hints_atom = XInternAtom (ximagesink->xcontext->disp, "_MOTIF_WM_HINTS", 1);

   782   if (hints_atom == None) {

   783     g_mutex_unlock (ximagesink->x_lock);

   784     return FALSE;

   785   }

   786 

   787   hints = g_malloc0 (sizeof (MotifWmHints));

   788 

   789   hints->flags |= MWM_HINTS_DECORATIONS;

   790   hints->decorations = 1 << 0;

   791 

   792   XChangeProperty (ximagesink->xcontext->disp, window->win,

   793       hints_atom, hints_atom, 32, PropModeReplace,

   794       (guchar *) hints, sizeof (MotifWmHints) / sizeof (long));

   795 

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

   797 

   798   g_mutex_unlock (ximagesink->x_lock);

   799 

   800   g_free (hints);

   801 

   802   return TRUE;

   803 }

   804 

   805 /* This function handles a GstXWindow creation */

   806 static GstXWindow *

   807 gst_ximagesink_xwindow_new (GstXImageSink * ximagesink, gint width, gint height)

   808 {

   809   GstXWindow *xwindow = NULL;

   810   XGCValues values;

   811 

   812   g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);

   813 

   814   xwindow = g_new0 (GstXWindow, 1);

   815 

   816   xwindow->width = width;

   817   xwindow->height = height;

   818   xwindow->internal = TRUE;

   819 

   820   g_mutex_lock (ximagesink->x_lock);

   821 

   822   xwindow->win = XCreateSimpleWindow (ximagesink->xcontext->disp,

   823       ximagesink->xcontext->root,

   824       0, 0, xwindow->width, xwindow->height, 0, 0, ximagesink->xcontext->black);

   825 

   826   /* We have to do that to prevent X from redrawing the background on 

   827      ConfigureNotify. This takes away flickering of video when resizing. */

   828   XSetWindowBackgroundPixmap (ximagesink->xcontext->disp, xwindow->win, None);

   829 

   830   if (ximagesink->handle_events) {

   831     Atom wm_delete;

   832 

   833     XSelectInput (ximagesink->xcontext->disp, xwindow->win, ExposureMask |

   834         StructureNotifyMask | PointerMotionMask | KeyPressMask |

   835         KeyReleaseMask | ButtonPressMask | ButtonReleaseMask);

   836 

   837     /* Tell the window manager we'd like delete client messages instead of

   838      * being killed */

   839     wm_delete = XInternAtom (ximagesink->xcontext->disp,

   840         "WM_DELETE_WINDOW", False);

   841     (void) XSetWMProtocols (ximagesink->xcontext->disp, xwindow->win,

   842         &wm_delete, 1);

   843   }

   844 

   845   xwindow->gc = XCreateGC (ximagesink->xcontext->disp, xwindow->win,

   846       0, &values);

   847 

   848   XMapRaised (ximagesink->xcontext->disp, xwindow->win);

   849 

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

   851 

   852   g_mutex_unlock (ximagesink->x_lock);

   853 

   854   gst_ximagesink_xwindow_decorate (ximagesink, xwindow);

   855 

   856   gst_x_overlay_got_xwindow_id (GST_X_OVERLAY (ximagesink), xwindow->win);

   857 

   858   return xwindow;

   859 }

   860 

   861 /* This function destroys a GstXWindow */

   862 static void

   863 gst_ximagesink_xwindow_destroy (GstXImageSink * ximagesink,

   864     GstXWindow * xwindow)

   865 {

   866   g_return_if_fail (xwindow != NULL);

   867   g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));

   868 

   869   g_mutex_lock (ximagesink->x_lock);

   870 

   871   /* If we did not create that window we just free the GC and let it live */

   872   if (xwindow->internal)

   873     XDestroyWindow (ximagesink->xcontext->disp, xwindow->win);

   874   else

   875     XSelectInput (ximagesink->xcontext->disp, xwindow->win, 0);

   876 

   877   XFreeGC (ximagesink->xcontext->disp, xwindow->gc);

   878 

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

   880 

   881   g_mutex_unlock (ximagesink->x_lock);

   882 

   883   g_free (xwindow);

   884 }

   885 

   886 static void

   887 gst_ximagesink_xwindow_update_geometry (GstXImageSink * ximagesink,

   888     GstXWindow * xwindow)

   889 {

   890   XWindowAttributes attr;

   891 

   892   g_return_if_fail (xwindow != NULL);

   893   g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));

   894 

   895   /* Update the window geometry */

   896   g_mutex_lock (ximagesink->x_lock);

   897 

   898   XGetWindowAttributes (ximagesink->xcontext->disp,

   899       ximagesink->xwindow->win, &attr);

   900 

   901   ximagesink->xwindow->width = attr.width;

   902   ximagesink->xwindow->height = attr.height;

   903 

   904   g_mutex_unlock (ximagesink->x_lock);

   905 }

   906 

   907 static void

   908 gst_ximagesink_xwindow_clear (GstXImageSink * ximagesink, GstXWindow * xwindow)

   909 {

   910   g_return_if_fail (xwindow != NULL);

   911   g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));

   912 

   913   g_mutex_lock (ximagesink->x_lock);

   914 

   915   XSetForeground (ximagesink->xcontext->disp, xwindow->gc,

   916       ximagesink->xcontext->black);

   917 

   918   XFillRectangle (ximagesink->xcontext->disp, xwindow->win, xwindow->gc,

   919       0, 0, xwindow->width, xwindow->height);

   920 

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

   922 

   923   g_mutex_unlock (ximagesink->x_lock);

   924 }

   925 

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

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

   928    and navigation.*/

   929 static void

   930 gst_ximagesink_handle_xevents (GstXImageSink * ximagesink)

   931 {

   932   XEvent e;

   933   guint pointer_x = 0, pointer_y = 0;

   934   gboolean pointer_moved = FALSE;

   935   gboolean exposed = FALSE, configured = FALSE;

   936 

   937   g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));

   938 

   939   /* Then we get all pointer motion events, only the last position is

   940      interesting. */

   941   g_mutex_lock (ximagesink->flow_lock);

   942   g_mutex_lock (ximagesink->x_lock);

   943   while (XCheckWindowEvent (ximagesink->xcontext->disp,

   944           ximagesink->xwindow->win, PointerMotionMask, &e)) {

   945     g_mutex_unlock (ximagesink->x_lock);

   946     g_mutex_unlock (ximagesink->flow_lock);

   947 

   948     switch (e.type) {

   949       case MotionNotify:

   950         pointer_x = e.xmotion.x;

   951         pointer_y = e.xmotion.y;

   952         pointer_moved = TRUE;

   953         break;

   954       default:

   955         break;

   956     }

   957     g_mutex_lock (ximagesink->flow_lock);

   958     g_mutex_lock (ximagesink->x_lock);

   959   }

   960 

   961   if (pointer_moved) {

   962     g_mutex_unlock (ximagesink->x_lock);

   963     g_mutex_unlock (ximagesink->flow_lock);

   964 

   965     GST_DEBUG ("ximagesink pointer moved over window at %d,%d",

   966         pointer_x, pointer_y);

   967     gst_navigation_send_mouse_event (GST_NAVIGATION (ximagesink),

   968         "mouse-move", 0, pointer_x, pointer_y);

   969 

   970     g_mutex_lock (ximagesink->flow_lock);

   971     g_mutex_lock (ximagesink->x_lock);

   972   }

   973 

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

   975   while (XCheckWindowEvent (ximagesink->xcontext->disp,

   976           ximagesink->xwindow->win,

   977           KeyPressMask | KeyReleaseMask |

   978           ButtonPressMask | ButtonReleaseMask, &e)) {

   979     KeySym keysym;

   980 

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

   982     g_mutex_unlock (ximagesink->x_lock);

   983     g_mutex_unlock (ximagesink->flow_lock);

   984 

   985     switch (e.type) {

   986       case ButtonPress:

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

   988            events for interactivity/navigation */

   989         GST_DEBUG ("ximagesink button %d pressed over window at %d,%d",

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

   991         gst_navigation_send_mouse_event (GST_NAVIGATION (ximagesink),

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

   993         break;

   994       case ButtonRelease:

   995         GST_DEBUG ("ximagesink button %d release over window at %d,%d",

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

   997         gst_navigation_send_mouse_event (GST_NAVIGATION (ximagesink),

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

   999         break;

  1000       case KeyPress:

  1001       case KeyRelease:

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

  1003            events for interactivity/navigation */

  1004         GST_DEBUG ("ximagesink key %d pressed over window at %d,%d",

  1005             e.xkey.keycode, e.xkey.x, e.xkey.x);

  1006         g_mutex_lock (ximagesink->x_lock);

  1007         keysym = XKeycodeToKeysym (ximagesink->xcontext->disp,

  1008             e.xkey.keycode, 0);

  1009         g_mutex_unlock (ximagesink->x_lock);

  1010         if (keysym != NoSymbol) {

  1011           char *key_str = NULL;

  1012 

  1013           g_mutex_lock (ximagesink->x_lock);

  1014           key_str = XKeysymToString (keysym);

  1015           g_mutex_unlock (ximagesink->x_lock);

  1016           gst_navigation_send_key_event (GST_NAVIGATION (ximagesink),

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

  1018 

  1019         } else {

  1020           gst_navigation_send_key_event (GST_NAVIGATION (ximagesink),

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

  1022         }

  1023         break;

  1024       default:

  1025         GST_DEBUG_OBJECT (ximagesink, "ximagesink unhandled X event (%d)",

  1026             e.type);

  1027     }

  1028     g_mutex_lock (ximagesink->flow_lock);

  1029     g_mutex_lock (ximagesink->x_lock);

  1030   }

  1031 

  1032   while (XCheckWindowEvent (ximagesink->xcontext->disp,

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

  1034     switch (e.type) {

  1035       case Expose:

  1036         exposed = TRUE;

  1037         break;

  1038       case ConfigureNotify:

  1039         configured = TRUE;

  1040         break;

  1041       default:

  1042         break;

  1043     }

  1044   }

  1045 

  1046   if (ximagesink->handle_expose && (exposed || configured)) {

  1047     g_mutex_unlock (ximagesink->x_lock);

  1048     g_mutex_unlock (ximagesink->flow_lock);

  1049 

  1050     gst_ximagesink_expose (GST_X_OVERLAY (ximagesink));

  1051 

  1052     g_mutex_lock (ximagesink->flow_lock);

  1053     g_mutex_lock (ximagesink->x_lock);

  1054   }

  1055 

  1056   /* Handle Display events */

  1057   while (XPending (ximagesink->xcontext->disp)) {

  1058     XNextEvent (ximagesink->xcontext->disp, &e);

  1059 

  1060     switch (e.type) {

  1061       case ClientMessage:{

  1062         Atom wm_delete;

  1063 

  1064         wm_delete = XInternAtom (ximagesink->xcontext->disp,

  1065             "WM_DELETE_WINDOW", False);

  1066         if (wm_delete == (Atom) e.xclient.data.l[0]) {

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

  1068           GST_ELEMENT_ERROR (ximagesink, RESOURCE, NOT_FOUND,

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

  1070 

  1071           g_mutex_unlock (ximagesink->x_lock);

  1072           gst_ximagesink_xwindow_destroy (ximagesink, ximagesink->xwindow);

  1073           ximagesink->xwindow = NULL;

  1074           g_mutex_lock (ximagesink->x_lock);

  1075         }

  1076         break;

  1077       }

  1078       default:

  1079         break;

  1080     }

  1081   }

  1082 

  1083   g_mutex_unlock (ximagesink->x_lock);

  1084   g_mutex_unlock (ximagesink->flow_lock);

  1085 }

  1086 

  1087 static gpointer

  1088 gst_ximagesink_event_thread (GstXImageSink * ximagesink)

  1089 {

  1090   g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);

  1091 

  1092   GST_OBJECT_LOCK (ximagesink);

  1093   while (ximagesink->running) {

  1094     GST_OBJECT_UNLOCK (ximagesink);

  1095 

  1096     if (ximagesink->xwindow) {

  1097       gst_ximagesink_handle_xevents (ximagesink);

  1098     }

  1099     g_usleep (100000);

  1100 

  1101     GST_OBJECT_LOCK (ximagesink);

  1102   }

  1103   GST_OBJECT_UNLOCK (ximagesink);

  1104 

  1105   return NULL;

  1106 }

  1107 

  1108 /* This function calculates the pixel aspect ratio based on the properties

  1109  * in the xcontext structure and stores it there. */

  1110 static void

  1111 gst_ximagesink_calculate_pixel_aspect_ratio (GstXContext * xcontext)

  1112 {

  1113   static const gint par[][2] = {

  1114     {1, 1},                     /* regular screen */

  1115     {16, 15},                   /* PAL TV */

  1116     {11, 10},                   /* 525 line Rec.601 video */

  1117     {54, 59},                   /* 625 line Rec.601 video */

  1118     {64, 45},                   /* 1280x1024 on 16:9 display */

  1119     {5, 3},                     /* 1280x1024 on 4:3 display */

  1120     {4, 3}                      /*  800x600 on 16:9 display */

  1121   };

  1122   gint i;

  1123   gint index;

  1124   gdouble ratio;

  1125   gdouble delta;

  1126 

  1127 #define DELTA(idx) (ABS (ratio - ((gdouble) par[idx][0] / par[idx][1])))

  1128 

  1129   /* first calculate the "real" ratio based on the X values;

  1130    * which is the "physical" w/h divided by the w/h in pixels of the display */

  1131   ratio = (gdouble) (xcontext->widthmm * xcontext->height)

  1132       / (xcontext->heightmm * xcontext->width);

  1133 

  1134   /* DirectFB's X in 720x576 reports the physical dimensions wrong, so