gstreamer/sys/ximage/gstximagesrc.c

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

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "ximagesrc.h"

#include <string.h>
#include <stdlib.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>

GST_DEBUG_CATEGORY_STATIC (gst_debug_ximagesrc);
#define GST_CAT_DEFAULT gst_debug_ximagesrc

/* elementfactory information */
static GstElementDetails ximagesrc_details =
GST_ELEMENT_DETAILS ("Ximage video source",
    "Source/Video",
    "Creates a screenshot video stream",
    "Lutz Mueller <lutz@users.sourceforge.net>"
    "Jan Schmidt <thaytan@mad.scientist.com>");

static GstStaticPadTemplate t =
GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("video/x-raw-rgb, "
        "framerate = (fraction) [ 0, MAX ], "
        "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]"));

enum
{
  PROP_0,
  PROP_DISPLAY_NAME,
  PROP_SCREEN_NUM
};

GST_BOILERPLATE (GstXImageSrc, gst_ximagesrc, GstPushSrc, GST_TYPE_PUSH_SRC);

static void gst_ximagesrc_fixate (GstPad * pad, GstCaps * caps);
static void gst_ximagesrc_clear_bufpool (GstXImageSrc * ximagesrc);

/* Called when a buffer is returned from the pipeline */
static void
gst_ximagesrc_return_buf (GstXImageSrc * ximagesrc, GstXImageSrcBuffer * ximage)
{
  /* If our geometry changed we can't reuse that image. */
  if ((ximage->width != ximagesrc->width) ||
      (ximage->height != ximagesrc->height)) {
    GST_DEBUG_OBJECT (ximagesrc,
        "destroy image %p as its size changed %dx%d vs current %dx%d",
        ximage, ximage->width, ximage->height,
        ximagesrc->width, ximagesrc->height);
    g_mutex_lock (ximagesrc->x_lock);
    gst_ximageutil_ximage_destroy (ximagesrc->xcontext, ximage);
    g_mutex_unlock (ximagesrc->x_lock);
  } else {
    /* In that case we can reuse the image and add it to our image pool. */
    GST_LOG_OBJECT (ximagesrc, "recycling image %p in pool", ximage);
    /* need to increment the refcount again to recycle */
    gst_buffer_ref (GST_BUFFER (ximage));
    g_mutex_lock (ximagesrc->pool_lock);
    ximagesrc->buffer_pool = g_slist_prepend (ximagesrc->buffer_pool, ximage);
    g_mutex_unlock (ximagesrc->pool_lock);
  }
}

static gboolean
gst_ximagesrc_open_display (GstXImageSrc * s, const gchar * name)
{
  g_return_val_if_fail (GST_IS_XIMAGESRC (s), FALSE);

  if (s->xcontext != NULL)
    return TRUE;

  g_mutex_lock (s->x_lock);
  s->xcontext = ximageutil_xcontext_get (GST_ELEMENT (s), name);
  s->width = s->xcontext->width;
  s->height = s->xcontext->height;

  /* Always capture root window, for now */
  s->xwindow = s->xcontext->root;

#ifdef HAVE_XFIXES
  /* check if xfixes supported */
  {
    int error_base;

    if (XFixesQueryExtension (s->xcontext->disp, &s->fixes_event_base,
            &error_base)) {
      s->have_xfixes = TRUE;
      GST_DEBUG_OBJECT (s, "X Server supports XFixes");
    } else {
      GST_DEBUG_OBJECT (s, "X Server does not support XFixes");
    }
  }

#ifdef HAVE_XDAMAGE
  /* check if xdamage is supported */
  {
    int error_base;
    long evmask = NoEventMask;

    if (XDamageQueryExtension (s->xcontext->disp, &s->damage_event_base,
            &error_base)) {
      s->damage =
          XDamageCreate (s->xcontext->disp, s->xwindow,
          XDamageReportRawRectangles);
      if (s->damage != None) {
        s->damage_region = XFixesCreateRegion (s->xcontext->disp, NULL, 0);
        if (s->damage_region != None) {
          XGCValues values;

          GST_DEBUG_OBJECT (s, "Using XDamage extension");
          values.subwindow_mode = IncludeInferiors;
          s->damage_copy_gc = XCreateGC (s->xcontext->disp,
              s->xwindow, GCSubwindowMode, &values);
          XSelectInput (s->xcontext->disp, s->xwindow, evmask);

          s->have_xdamage = TRUE;
        } else {
          XDamageDestroy (s->xcontext->disp, s->damage);
          s->damage = None;
        }
      } else
        GST_DEBUG_OBJECT (s, "Could not attach to XDamage");
    } else {
      GST_DEBUG_OBJECT (s, "X Server does not have XDamage extension");
    }
  }
#endif
#endif

  g_mutex_unlock (s->x_lock);

  if (s->xcontext == NULL)
    return FALSE;

  return TRUE;
}

static gboolean
gst_ximagesrc_start (GstBaseSrc * basesrc)
{
  GstXImageSrc *s = GST_XIMAGESRC (basesrc);

  s->last_frame_no = -1;

  return gst_ximagesrc_open_display (s, NULL);
}

static gboolean
gst_ximagesrc_stop (GstBaseSrc * basesrc)
{
  GstXImageSrc *src = GST_XIMAGESRC (basesrc);

  gst_ximagesrc_clear_bufpool (src);

  if (src->xcontext) {
    g_mutex_lock (src->x_lock);
    ximageutil_xcontext_clear (src->xcontext);
    src->xcontext = NULL;
    g_mutex_unlock (src->x_lock);
  }

  return TRUE;
}

static gboolean
gst_ximagesrc_unlock (GstBaseSrc * basesrc)
{
  GstXImageSrc *src = GST_XIMAGESRC (basesrc);

  /* Awaken the create() func if it's waiting on the clock */
  GST_OBJECT_LOCK (src);
  if (src->clock_id) {
    GST_DEBUG_OBJECT (src, "Waking up waiting clock");
    gst_clock_id_unschedule (src->clock_id);
  }
  GST_OBJECT_UNLOCK (src);

  return TRUE;
}

static gboolean
gst_ximagesrc_recalc (GstXImageSrc * src)
{
  if (!src->xcontext)
    return FALSE;

  /* FIXME: Check the display hasn't changed size or something */
  /* We could use XQueryPointer to get only the current window. */
  return TRUE;
}

/* ifdeff'ed to prevent warnings of not being used when xfixes not there */
#ifdef HAVE_XFIXES
static void
composite_pixel (GstXContext * xcontext, guchar * dest, guchar * src)
{
  guint8 r = src[2];
  guint8 g = src[1];
  guint8 b = src[0];
  guint8 a = src[3];
  gint dr, dg, db;
  guint32 color;
  gint r_shift, r_max;
  gint g_shift, g_max;
  gint b_shift, b_max;

  switch (xcontext->bpp) {
    case 8:
      color = *dest;
      break;
    case 16:
      color = GUINT16_FROM_LE (*(guint32 *) (dest));
      break;
    case 32:
      color = GUINT32_FROM_LE (*(guint32 *) (dest));
      break;
    default:
      g_warning ("bpp %d not supported\n", xcontext->bpp);
      color = 0;
  }

  /* FIXME: move the code that finds shift and max in the _link function */
  for (r_shift = 0; !(xcontext->visual->red_mask & (1 << r_shift)); r_shift++);
  for (g_shift = 0; !(xcontext->visual->green_mask & (1 << g_shift));
      g_shift++);
  for (b_shift = 0; !(xcontext->visual->blue_mask & (1 << b_shift)); b_shift++);

  r_max = (xcontext->visual->red_mask >> r_shift);
  b_max = (xcontext->visual->blue_mask >> b_shift);
  g_max = (xcontext->visual->green_mask >> g_shift);

#define RGBXXX_R(x)  (((x)>>r_shift) & (r_max))
#define RGBXXX_G(x)  (((x)>>g_shift) & (g_max))
#define RGBXXX_B(x)  (((x)>>b_shift) & (b_max))

  dr = (RGBXXX_R (color) * 255) / r_max;
  dg = (RGBXXX_G (color) * 255) / g_max;
  db = (RGBXXX_B (color) * 255) / b_max;

  dr = (r * a + (0xff - a) * dr) / 0xff;
  dg = (g * a + (0xff - a) * dg) / 0xff;
  db = (b * a + (0xff - a) * db) / 0xff;

  color = (((dr * r_max) / 255) << r_shift) +
      (((dg * g_max) / 255) << g_shift) + (((db * b_max) / 255) << b_shift);

  switch (xcontext->bpp) {
    case 8:
      *dest = color;
      break;
    case 16:
      *(guint16 *) (dest) = color;
      break;
    case 32:
      *(guint32 *) (dest) = color;
      break;
    default:
      g_warning ("bpp %d not supported\n", xcontext->bpp);
  }
}
#endif

/* Retrieve an XImageSrcBuffer, preferably from our
 * pool of existing images and populate it from the window */
static GstXImageSrcBuffer *
gst_ximagesrc_ximage_get (GstXImageSrc * ximagesrc)
{
  GstXImageSrcBuffer *ximage = NULL;

  g_mutex_lock (ximagesrc->pool_lock);
  while (ximagesrc->buffer_pool != NULL) {
    ximage = ximagesrc->buffer_pool->data;

    if ((ximage->width != ximagesrc->width) ||
        (ximage->height != ximagesrc->height)) {
      gst_ximage_buffer_free (ximage);
    }

    ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
        ximagesrc->buffer_pool);
  }
  g_mutex_unlock (ximagesrc->pool_lock);

  if (ximage == NULL) {
    GstXContext *xcontext;

    GST_DEBUG_OBJECT (ximagesrc, "creating image (%dx%d)",
        ximagesrc->width, ximagesrc->height);

    g_mutex_lock (ximagesrc->x_lock);
    ximage = gst_ximageutil_ximage_new (ximagesrc->xcontext,
        GST_ELEMENT (ximagesrc), ximagesrc->width, ximagesrc->height,
        (BufferReturnFunc) (gst_ximagesrc_return_buf));
    if (ximage == NULL) {
      GST_ELEMENT_ERROR (ximagesrc, RESOURCE, WRITE, (NULL),
          ("could not create a %dx%d ximage", ximage->width, ximage->height));
      g_mutex_unlock (ximagesrc->x_lock);
      return NULL;
    }

    xcontext = ximagesrc->xcontext;

    /* FIXME: Include the PAR */
    gst_buffer_set_caps (GST_BUFFER (ximage),
        gst_caps_new_simple ("video/x-raw-rgb",
            "bpp", G_TYPE_INT, xcontext->bpp,
            "depth", G_TYPE_INT, xcontext->depth,
            "endianness", G_TYPE_INT, xcontext->endianness,
            "red_mask", G_TYPE_INT, xcontext->visual->red_mask,
            "green_mask", G_TYPE_INT, xcontext->visual->green_mask,
            "blue_mask", G_TYPE_INT, xcontext->visual->blue_mask,
            "width", G_TYPE_INT, xcontext->width,
            "height", G_TYPE_INT, xcontext->height,
            "framerate", GST_TYPE_FRACTION, ximagesrc->fps_n, ximagesrc->fps_d,
            NULL));
    g_mutex_unlock (ximagesrc->x_lock);
  }

  g_return_val_if_fail (GST_IS_XIMAGESRC (ximagesrc), NULL);

#ifdef HAVE_XDAMAGE
  if (ximagesrc->have_xdamage) {
    XEvent ev;

    GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XDamage");

    do {
      XNextEvent (ximagesrc->xcontext->disp, &ev);
      if (ev.type == ximagesrc->damage_event_base + XDamageNotify) {
        XDamageNotifyEvent *dev = (XDamageNotifyEvent *) & ev;

#ifdef HAVE_XSHM
        if (ximagesrc->xcontext->use_xshm &&
            dev->area.width == ximagesrc->width &&
            dev->area.height == ximagesrc->height) {
          GST_DEBUG_OBJECT (ximagesrc, "Entire screen was damaged");
          XShmGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
              ximage->ximage, 0, 0, AllPlanes);
          /* No need to collect more events */
          while (XPending (ximagesrc->xcontext->disp)) {
            XNextEvent (ximagesrc->xcontext->disp, &ev);
          }
          break;
        } else
#endif
        {
          GST_LOG_OBJECT (ximagesrc,
              "Retrieving damaged sub-region @ %d,%d size %dx%d",
              dev->area.x, dev->area.y, dev->area.width, dev->area.height);

          XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
              dev->area.x, dev->area.y,
              dev->area.width, dev->area.height,
              AllPlanes, ZPixmap, ximage->ximage, dev->area.x, dev->area.y);
        }
      }
    } while (XPending (ximagesrc->xcontext->disp));
    XDamageSubtract (ximagesrc->xcontext->disp, ximagesrc->damage, None, None);
  } else {
#endif

#ifdef HAVE_XSHM
    if (ximagesrc->xcontext->use_xshm) {
      GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XShm");
      XShmGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
          ximage->ximage, 0, 0, AllPlanes);

    } else
#endif /* HAVE_XSHM */
    {
      GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XGetImage");
      ximage->ximage = XGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow,
          0, 0, ximagesrc->width, ximagesrc->height, AllPlanes, ZPixmap);
    }
#ifdef HAVE_XDAMAGE
  }
#endif

#ifdef HAVE_XFIXES
  if (ximagesrc->show_pointer && ximagesrc->have_xfixes) {
    XFixesCursorImage *cursor_image;

    GST_DEBUG_OBJECT (ximagesrc, "Using XFixes to draw cursor");
    /* get cursor */
    cursor_image = XFixesGetCursorImage (ximagesrc->xcontext->disp);
    if (cursor_image != NULL) {
      int cx, cy, i, j, count;

      cx = cursor_image->x - cursor_image->xhot;
      cy = cursor_image->y - cursor_image->yhot;
      //count = image->width * image->height;
      count = cursor_image->width * cursor_image->height;
      for (i = 0; i < count; i++)
        cursor_image->pixels[i] = GUINT_TO_LE (cursor_image->pixels[i]);

      /* copy those pixels across */
      for (j = cy; j < cy + cursor_image->height && j < ximagesrc->height; j++) {
        for (i = cx; i < cx + cursor_image->width && i < ximagesrc->width; i++) {
          guint8 *src, *dest;

          src =
              (guint8 *) & (cursor_image->pixels[((j -
                          cy) * cursor_image->width + (i - cx))]);
          dest =
              (guint8 *) & (ximage->ximage->data[(j * ximagesrc->width +
                      i) * (ximagesrc->xcontext->bpp / 8)]);

          composite_pixel (ximagesrc->xcontext, (guint8 *) dest,
              (guint8 *) src);
        }
      }
    }
  }
#endif

  return ximage;
}

static GstFlowReturn
gst_ximagesrc_create (GstPushSrc * bs, GstBuffer ** buf)
{
  GstXImageSrc *s = GST_XIMAGESRC (bs);
  GstXImageSrcBuffer *image;
  GstClockTime base_time;
  GstClockTime next_capture_ts;
  GstClockTime dur;
  gint64 next_frame_no;

  if (!gst_ximagesrc_recalc (s)) {
    /* FIXME: Post error on the bus */
    return GST_FLOW_ERROR;
  }

  if (s->fps_n <= 0 || s->fps_d <= 0)
    return GST_FLOW_NOT_NEGOTIATED;     /* FPS must be > 0 */

  /* Now, we might need to wait for the next multiple of the fps 
   * before capturing */

  GST_OBJECT_LOCK (s);
  base_time = GST_ELEMENT_CAST (s)->base_time;
  next_capture_ts = gst_clock_get_time (GST_ELEMENT_CLOCK (s));
  next_capture_ts -= base_time;

  /* Figure out which 'frame number' position we're at, based on the cur time
   * and frame rate */
  next_frame_no = gst_util_uint64_scale (next_capture_ts,
      s->fps_n, GST_SECOND * s->fps_d);
  if (next_frame_no == s->last_frame_no) {
    GstClockID id;
    GstClockReturn ret;

    /* Need to wait for the next frame */
    next_frame_no += 1;

    /* Figure out what the next frame time is */
    next_capture_ts = gst_util_uint64_scale (next_frame_no,
        s->fps_d * GST_SECOND, s->fps_n);

    id = gst_clock_new_single_shot_id (GST_ELEMENT_CLOCK (s),
        next_capture_ts + base_time);
    s->clock_id = id;

    /* release the object lock while waiting */
    GST_OBJECT_UNLOCK (s);

    GST_DEBUG_OBJECT (s, "Waiting for next frame time %" G_GUINT64_FORMAT,
        next_capture_ts);
    ret = gst_clock_id_wait (id, NULL);
    GST_OBJECT_LOCK (s);

    gst_clock_id_unref (id);
    s->clock_id = NULL;
    if (ret == GST_CLOCK_UNSCHEDULED) {
      /* Got woken up by the unlock function */
      GST_OBJECT_UNLOCK (s);
      return GST_FLOW_WRONG_STATE;
    }
    /* Duration is a complete 1/fps frame duration */
    dur = gst_util_uint64_scale_int (GST_SECOND, s->fps_d, s->fps_n);
  } else {
    GstClockTime next_frame_ts;

    GST_DEBUG_OBJECT (s, "No need to wait for next frame time %"
        G_GUINT64_FORMAT " next frame = %" G_GINT64_FORMAT " prev = %"
        G_GINT64_FORMAT, next_capture_ts, next_frame_no, s->last_frame_no);
    next_frame_ts = gst_util_uint64_scale (next_frame_no + 1,
        s->fps_d * GST_SECOND, s->fps_n);
    /* Frame duration is from now until the next expected capture time */
    dur = next_frame_ts - next_capture_ts;
  }
  s->last_frame_no = next_frame_no;
  GST_OBJECT_UNLOCK (s);

  image = gst_ximagesrc_ximage_get (s);
  if (!image)
    return GST_FLOW_ERROR;

  *buf = GST_BUFFER (image);
  GST_BUFFER_TIMESTAMP (*buf) = next_capture_ts;
  GST_BUFFER_DURATION (*buf) = dur;

  return GST_FLOW_OK;
}

static void
gst_ximagesrc_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstXImageSrc *src = GST_XIMAGESRC (object);

  switch (prop_id) {
    case PROP_DISPLAY_NAME:

      g_free (src->display_name);
      src->display_name = g_strdup (g_value_get_string (value));

      // src->screen_num = MIN (src->screen_num, ScreenCount (src->display) - 1);
      break;
    case PROP_SCREEN_NUM:
      src->screen_num = g_value_get_uint (value);
      // src->screen_num = MIN (src->screen_num, ScreenCount (src->display) - 1);
      break;
    default:
      break;
  }
}

static void
gst_ximagesrc_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
{
  GstXImageSrc *src = GST_XIMAGESRC (object);

  switch (prop_id) {
    case PROP_DISPLAY_NAME:
      if (src->xcontext)
        g_value_set_string (value, DisplayString (src->xcontext->disp));
      else
        g_value_set_string (value, src->display_name);

      break;
    case PROP_SCREEN_NUM:
      g_value_set_uint (value, src->screen_num);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_ximagesrc_clear_bufpool (GstXImageSrc * ximagesrc)
{
  g_mutex_lock (ximagesrc->pool_lock);
  while (ximagesrc->buffer_pool != NULL) {
    GstXImageSrcBuffer *ximage = ximagesrc->buffer_pool->data;

    gst_ximage_buffer_free (ximage);

    ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
        ximagesrc->buffer_pool);
  }
  g_mutex_unlock (ximagesrc->pool_lock);
}

static void
gst_ximagesrc_base_init (gpointer g_class)
{
  GstElementClass *ec = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details (ec, &ximagesrc_details);
  gst_element_class_add_pad_template (ec, gst_static_pad_template_get (&t));
}

static void
gst_ximagesrc_dispose (GObject * object)
{
  /* Drop references in the buffer_pool */
  gst_ximagesrc_clear_bufpool (GST_XIMAGESRC (object));
}

static void
gst_ximagesrc_finalize (GObject * object)
{
  GstXImageSrc *src = GST_XIMAGESRC (object);

  if (src->xcontext)
    ximageutil_xcontext_clear (src->xcontext);

  g_mutex_free (src->pool_lock);
  g_mutex_free (src->x_lock);

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static GstCaps *
gst_ximagesrc_get_caps (GstBaseSrc * bs)
{
  GstXImageSrc *s = GST_XIMAGESRC (bs);
  GstXContext *xcontext;

  if ((!s->xcontext) && (!gst_ximagesrc_open_display (s, NULL)))
    return gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SRC (s)->
            srcpad));

  if (!gst_ximagesrc_recalc (s))
    return gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SRC (s)->
            srcpad));

  xcontext = s->xcontext;

  /* FIXME: Add PAR */
  return gst_caps_new_simple ("video/x-raw-rgb",
      "bpp", G_TYPE_INT, xcontext->bpp,
      "depth", G_TYPE_INT, xcontext->depth,
      "endianness", G_TYPE_INT, xcontext->endianness,
      "red_mask", G_TYPE_INT, xcontext->visual->red_mask,
      "green_mask", G_TYPE_INT, xcontext->visual->green_mask,
      "blue_mask", G_TYPE_INT, xcontext->visual->blue_mask,
      "width", G_TYPE_INT, xcontext->width,
      "height", G_TYPE_INT, xcontext->height,
      "framerate", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, NULL);
}

static gboolean
gst_ximagesrc_set_caps (GstBaseSrc * bs, GstCaps * caps)
{
  GstXImageSrc *s = GST_XIMAGESRC (bs);
  GstStructure *structure;
  const GValue *new_fps;

  /* If not yet opened, disallow setcaps until later */
  if (!s->xcontext)
    return FALSE;

  /* The only thing that can change is the framerate downstream wants */
  structure = gst_caps_get_structure (caps, 0);
  new_fps = gst_structure_get_value (structure, "framerate");
  if (!new_fps)
    return FALSE;

  /* Store this FPS for use when generating buffers */
  s->fps_n = gst_value_get_fraction_numerator (new_fps);
  s->fps_d = gst_value_get_fraction_denominator (new_fps);

  GST_DEBUG_OBJECT (s, "peer wants %d/%d fps", s->fps_n, s->fps_d);

  return TRUE;
}

static void
gst_ximagesrc_fixate (GstPad * pad, GstCaps * caps)
{
  gint i;
  GstStructure *structure;

  for (i = 0; i < gst_caps_get_size (caps); ++i) {
    structure = gst_caps_get_structure (caps, i);

    gst_structure_fixate_field_nearest_fraction (structure, "framerate", 25, 1);
  }
}

static void
gst_ximagesrc_class_init (GstXImageSrcClass * klass)
{
  GObjectClass *gc = G_OBJECT_CLASS (klass);
  GstBaseSrcClass *bc = GST_BASE_SRC_CLASS (klass);
  GstPushSrcClass *push_class = GST_PUSH_SRC_CLASS (klass);

  gc->set_property = gst_ximagesrc_set_property;
  gc->get_property = gst_ximagesrc_get_property;
  gc->dispose = gst_ximagesrc_dispose;
  gc->finalize = gst_ximagesrc_finalize;

  g_object_class_install_property (gc, PROP_DISPLAY_NAME,
      g_param_spec_string ("display_name", "Display", "X Display name", NULL,
          G_PARAM_READWRITE));
  g_object_class_install_property (gc, PROP_SCREEN_NUM,
      g_param_spec_uint ("screen_num", "Screen number", "X Screen number",
          0, G_MAXINT, 0, G_PARAM_READWRITE));

  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);

  push_class->create = gst_ximagesrc_create;
  bc->get_caps = gst_ximagesrc_get_caps;
  bc->set_caps = gst_ximagesrc_set_caps;
  bc->start = gst_ximagesrc_start;
  bc->stop = gst_ximagesrc_stop;
  bc->unlock = gst_ximagesrc_unlock;
}

static void
gst_ximagesrc_init (GstXImageSrc * ximagesrc, GstXImageSrcClass * klass)
{
  gst_base_src_set_live (GST_BASE_SRC (ximagesrc), TRUE);
  gst_pad_set_fixatecaps_function (GST_BASE_SRC_PAD (ximagesrc),
      gst_ximagesrc_fixate);

  ximagesrc->pool_lock = g_mutex_new ();
  ximagesrc->x_lock = g_mutex_new ();
}

static gboolean
plugin_init (GstPlugin * plugin)
{
  gboolean ret;

  GST_DEBUG_CATEGORY_INIT (gst_debug_ximagesrc, "ximagesrc", 0,
      "ximagesrc element debug");

  ret = gst_element_register (plugin, "ximagesrc", GST_RANK_NONE,
      GST_TYPE_XIMAGESRC);

  return ret;
}

GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
    GST_VERSION_MINOR,
    "ximagesrc",
    "XFree86 video input plugin based on standard Xlib calls",
    plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN)