imx-weston/clients/gstwestonimagesrc.c

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <unistd.h>

#include "gst/gstinfo.h"
#include "gstwestonimagesrc.h"

// Gtreamer plugin related defines and declarations
GST_DEBUG_CATEGORY_STATIC(gst_westonimagesrc_debug);
#define GST_CAT_DEFAULT gst_westonimagesrc_debug

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS("text/plain; charset=utf-8"));

enum { PROP_0, PROP_FRAMERATE, N_PROPERTIES };

static gboolean gst_westonimagesrc_start(GstBaseSrc *basesrc);
static gboolean gst_westonimagesrc_stop(GstBaseSrc *basesrc);
static GstFlowReturn gst_westonimagesrc_create(GstBaseSrc *basesrc, guint64 offset, guint size, GstBuffer **buf);
static gboolean gst_westonimagesrc_unlock(GstBaseSrc *basesrc);
static gboolean gst_westonimagesrc_unlock_stop(GstBaseSrc *basesrc);

static void gst_westonimagesrc_class_init(GstWestonImageSrcClass *klass);
static void gst_westonimagesrc_init(GstWestonImageSrc *westonimagesrc);
static void gst_westonimagesrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void gst_westonimagesrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);

G_DEFINE_TYPE(GstWestonImageSrc, gst_westonimagesrc, GST_TYPE_BASE_SRC);

static void weston_display_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int width, int height, int refresh);
static void weston_display_handle_geometry(void *data, struct wl_output *wl_output, int x, int y, int physical_width, int physical_height, int subpixel, const char *make,
                                           const char *model, int transform);
static void weston_screenshot_done(void *data, struct weston_screenshooter *screenshooter);
static void weston_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version);
static void weston_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name);

static void weston_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) { /* XXX: unimplemented */ }
static struct wl_buffer *weston_screenshot_create_shm_buffer(int width, int height, void **data_out, struct wl_shm *shm);
static int weston_screenshot_set_buffer_size(struct buffer_size *buff_size, struct wl_list *output_list);

static const struct wl_output_listener output_listener = {weston_display_handle_geometry, weston_display_handle_mode};
static const struct weston_screenshooter_listener screenshooter_listener = {weston_screenshot_done};
static const struct wl_registry_listener registry_listener = {weston_handle_global, weston_handle_global_remove};

static int weston_screenshot_set_buffer_size(struct buffer_size *buff_size, struct wl_list *output_list) {
  struct screenshooter_output *output;
  buff_size->min_x = buff_size->min_y = INT_MAX;
  buff_size->max_x = buff_size->max_y = INT_MIN;
  int position = 0;

  wl_list_for_each_reverse(output, output_list, link) {
    output->offset_x = position;
    position += output->width;
  }

  wl_list_for_each(output, output_list, link) {
    buff_size->min_x = MIN(buff_size->min_x, output->offset_x);
    buff_size->min_y = MIN(buff_size->min_y, output->offset_y);
    buff_size->max_x = MAX(buff_size->max_x, output->offset_x + output->width);
    buff_size->max_y = MAX(buff_size->max_y, output->offset_y + output->height);
  }

  if (buff_size->max_x <= buff_size->min_x || buff_size->max_y <= buff_size->min_y)
    return -1;

  buff_size->width = buff_size->max_x - buff_size->min_x;
  buff_size->height = buff_size->max_y - buff_size->min_y;

  return 0;
}

static struct wl_buffer *weston_screenshot_create_shm_buffer(int width, int height, void **data_out, struct wl_shm *shm) {
  struct wl_shm_pool *pool;
  struct wl_buffer *buffer;
  int fd, size, stride;
  void *data;

  stride = width * 4;
  size = stride * height;

  fd = os_create_anonymous_file(size);
  if (fd < 0) {
    fprintf(stderr, "creating a buffer file for %d B failed: %s\n", size, strerror(errno));
    return NULL;
  }

  data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  if (data == MAP_FAILED) {
    fprintf(stderr, "mmap failed: %s\n", strerror(errno));
    close(fd);
    return NULL;
  }

  pool = wl_shm_create_pool(shm, fd, size);
  close(fd);
  buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_XRGB8888);
  wl_shm_pool_destroy(pool);

  *data_out = data;

  return buffer;
}

static void weston_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
  static struct screenshooter_output *output;
  struct screenshooter_data *sh_data = data;

  if (strcmp(interface, "wl_output") == 0) {

    output = xmalloc(sizeof *output);
    output->output = wl_registry_bind(registry, name, &wl_output_interface, 1);
    wl_list_insert(&sh_data->output_list, &output->link);
    wl_output_add_listener(output->output, &output_listener, output);
  } else if (strcmp(interface, "wl_shm") == 0) {

    sh_data->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
  } else if (strcmp(interface, "weston_screenshooter") == 0) {

    sh_data->screenshooter = wl_registry_bind(registry, name, &weston_screenshooter_interface, 1);
  }
}

static void weston_screenshot_done(void *data, struct weston_screenshooter *screenshooter) {
  struct screenshooter_data *sh_data = data;
  sh_data->buffer_copy_done = 1;
}

static void weston_display_handle_geometry(void *data, struct wl_output *wl_output, int x, int y, int physical_width, int physical_height, int subpixel, const char *make,
                                           const char *model, int transform) {
  struct screenshooter_output *output;
  output = wl_output_get_user_data(wl_output);

  if (wl_output == output->output) {
    output->offset_x = x;
    output->offset_y = y;
  }
}

static void weston_display_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int width, int height, int refresh) {
  struct screenshooter_output *output;
  output = wl_output_get_user_data(wl_output);

  if (wl_output == output->output && (flags & WL_OUTPUT_MODE_CURRENT)) {
    output->width = width;
    output->height = height;
  }
}

static void gst_westonimagesrc_class_init(GstWestonImageSrcClass *klass) {
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
  GstElementClass *gstelement_class = GST_ELEMENT_CLASS(klass);
  GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS(klass);

  gobject_class->set_property = gst_westonimagesrc_set_property;
  gobject_class->get_property = gst_westonimagesrc_get_property;

  gstbasesrc_class->start = GST_DEBUG_FUNCPTR(gst_westonimagesrc_start);
  gstbasesrc_class->stop = GST_DEBUG_FUNCPTR(gst_westonimagesrc_stop);
  gstbasesrc_class->create = GST_DEBUG_FUNCPTR(gst_westonimagesrc_create);
  gstbasesrc_class->unlock = GST_DEBUG_FUNCPTR(gst_westonimagesrc_unlock);
  gstbasesrc_class->unlock_stop = GST_DEBUG_FUNCPTR(gst_westonimagesrc_unlock_stop);

  // Регистрация свойств
  g_object_class_install_property(
      gobject_class, PROP_FRAMERATE,
      g_param_spec_double("framerate", "Frame rate", "Number of hello world messages per second", 0.f, 24.f, 1.f, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  gst_element_class_set_static_metadata(gstelement_class, "WestonImageSrc World Source", "Source", "Generates westonimagesrc world messages", "Your Name <your.email@example.com>");
  gst_element_class_add_static_pad_template(gstelement_class, &src_template);
  GST_DEBUG_CATEGORY_INIT(gst_westonimagesrc_debug, "westonimagesrc", 0, "WestonImageSrc World Plugin");
}

static void gst_westonimagesrc_init(GstWestonImageSrc *westonimagesrc) {
  gst_base_src_set_live(GST_BASE_SRC(westonimagesrc), TRUE);
  gst_base_src_set_format(GST_BASE_SRC(westonimagesrc), GST_FORMAT_TIME);
  gst_base_src_set_blocksize(GST_BASE_SRC(westonimagesrc), 0);

  westonimagesrc->running = FALSE;
  westonimagesrc->timeout_id = 0;
  westonimagesrc->offset = 0;
  westonimagesrc->framerate = 1.f;

  g_mutex_init(&westonimagesrc->lock);
  g_cond_init(&westonimagesrc->cond);

  // Get current display
  display = wl_display_connect(NULL);
  if (display == NULL) {
    fprintf(stderr, "failed to create display: %s\n", strerror(errno));
  }

  wl_list_init(&sh_data.output_list);
  registry = wl_display_get_registry(display);
  wl_registry_add_listener(registry, &registry_listener, &sh_data);
  wl_display_dispatch(display);
  wl_display_roundtrip(display);

  if (sh_data.screenshooter == NULL) {
    fprintf(stderr, "display doesn't support screenshooter\n");
  }

  weston_screenshooter_add_listener(sh_data.screenshooter, &screenshooter_listener, &sh_data);
  weston_screenshot_set_buffer_size(&buff_size, &sh_data.output_list);
}

static void gst_westonimagesrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(object);

  GST_OBJECT_LOCK(westonimagesrc);

  switch (prop_id) {
  case PROP_FRAMERATE: {
    gdouble new_framerate = g_value_get_double(value);

    if (new_framerate != westonimagesrc->framerate) {
      westonimagesrc->framerate = new_framerate;
      g_object_notify(object, "framerate");
    }
    break;
  }

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
    break;
  }

  GST_OBJECT_UNLOCK(westonimagesrc);
}

static void gst_westonimagesrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(object);
  GST_OBJECT_LOCK(westonimagesrc);

  switch (prop_id) {
  case PROP_FRAMERATE:
    g_value_set_double(value, westonimagesrc->framerate);
    break;
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
    break;
  }

  GST_OBJECT_UNLOCK(westonimagesrc);
}

static gboolean gst_westonimagesrc_start(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = TRUE;
  westonimagesrc->offset = 0;
  g_mutex_unlock(&westonimagesrc->lock);

  GST_DEBUG_OBJECT(westonimagesrc, "started");
  return TRUE;
}

static gboolean gst_westonimagesrc_stop(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = FALSE;
  g_cond_signal(&westonimagesrc->cond);
  g_mutex_unlock(&westonimagesrc->lock);

  GST_DEBUG_OBJECT(westonimagesrc, "stopped");
  return TRUE;
}

static GstFlowReturn gst_westonimagesrc_create(GstBaseSrc *basesrc, guint64 offset, guint size, GstBuffer **buf) {
  // Gstreamer related
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);
  GstMapInfo map;
  gchar *message;
  gint message_len;
  GstClockTime timestamp;
  GstBuffer *buffer;

  g_mutex_lock(&westonimagesrc->lock);

  while (westonimagesrc->running) {
    GstClockTime wait_until = g_get_monotonic_time() + (1 / westonimagesrc->framerate) * G_TIME_SPAN_SECOND;

    if (g_cond_wait_until(&westonimagesrc->cond, &westonimagesrc->lock, wait_until)) {
      if (!westonimagesrc->running) {
        g_mutex_unlock(&westonimagesrc->lock);
        return GST_FLOW_FLUSHING;
      }
    }

    if (!westonimagesrc->running) {
      g_mutex_unlock(&westonimagesrc->lock);
      return GST_FLOW_FLUSHING;
    }

    wl_list_for_each(output, &sh_data.output_list, link) {
      output->buffer = weston_screenshot_create_shm_buffer(output->width, output->height, &output->data, sh_data.shm);
      weston_screenshooter_shoot(sh_data.screenshooter, output->output, output->buffer);
      sh_data.buffer_copy_done = 0;
      while (!sh_data.buffer_copy_done)
        wl_display_roundtrip(display);
    }

    message = g_strdup_printf("westonimagesrc world #%lu\n", (gulong)westonimagesrc->offset);
    message_len = strlen(message);

    buffer = gst_buffer_new_allocate(NULL, message_len, NULL);
    gst_buffer_map(buffer, &map, GST_MAP_WRITE);
    memcpy(map.data, message, message_len);
    gst_buffer_unmap(buffer, &map);
    g_free(message);

    timestamp = westonimagesrc->offset * GST_SECOND;
    GST_BUFFER_PTS(buffer) = timestamp;
    GST_BUFFER_DURATION(buffer) = GST_SECOND;
    GST_BUFFER_OFFSET(buffer) = westonimagesrc->offset;
    GST_BUFFER_OFFSET_END(buffer) = westonimagesrc->offset + 1;

    westonimagesrc->offset++;

    *buf = buffer;
    g_mutex_unlock(&westonimagesrc->lock);

    GST_DEBUG_OBJECT(westonimagesrc, "created buffer %" G_GUINT64_FORMAT, westonimagesrc->offset - 1);
    return GST_FLOW_OK;
  }

  g_mutex_unlock(&westonimagesrc->lock);
  return GST_FLOW_FLUSHING;
}

static gboolean gst_westonimagesrc_unlock(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  GST_DEBUG_OBJECT(westonimagesrc, "unlock");
  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = FALSE;
  g_cond_signal(&westonimagesrc->cond);
  g_mutex_unlock(&westonimagesrc->lock);

  return TRUE;
}

static gboolean gst_westonimagesrc_unlock_stop(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  GST_DEBUG_OBJECT(westonimagesrc, "unlock stop");
  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = TRUE;
  g_mutex_unlock(&westonimagesrc->lock);

  return TRUE;
}

static gboolean plugin_init(GstPlugin *plugin) { return gst_element_register(plugin, "westonimagesrc", GST_RANK_NONE, GST_TYPE_WESTONIMAGESRC); }

#ifndef PACKAGE
#  define PACKAGE "westonimagesrc"
#endif

GST_PLUGIN_DEFINE(GST_VERSION_MAJOR, GST_VERSION_MINOR, westonimagesrc, "WestonImageSrc World source plugin", plugin_init, "1.0", "LGPL", "GStreamer", "http://gstreamer.net/")