path: root/gst-libs/gst/cairo/gstcairoformat.c

/* GStreamer
 * Copyright (C) 2009 Benjamin Otte <otte@gnome.org>
 *
 * 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 "gstcairoformat.h"
#include "gstcairoformat-private.h"

#include <string.h>
#include <pixman.h>

#include "gstcairocaps.h"
#include "gstcairocapsany.h"

/* huge map of pixman format => caps */
struct
{
  pixman_format_code_t format;
  GstVideoFormat video_format;
  GstStaticCaps caps;
} formatcaps[] = {
#define GST_CAIRO_CAPS_FORMAT(f, vf, c) { f, vf, GST_STATIC_CAPS (c) },
#include "gstcairocaps2format.h"
#undef GST_CAIRO_CAPS_FORMAT
  /* necessary because otherwise we'd get a comma at the end of an array */
  {
  0,}
};

/**
 * GstCairoFormat:
 *
 * Opaque structure representing a fixed #GstCaps that gst-plugins-cairo can
 * accept. It is use instead of caps because it is more convenient and 
 * provides useful utility functions.
 */

/**
 * GstCairoFormatOption:
 * @GST_CAIRO_FORMAT_FORMAT: operate on colorspaces
 * @GST_CAIRO_FORMAT_WIDTH: operate on width
 * @GST_CAIRO_FORMAT_HEIGHT: operate on height
 * @GST_CAIRO_FORMAT_SIZE: operate on width and height - this option is
 *                         equivalent to listing width and height separately
 * @GST_CAIRO_FORMAT_FRAMERATE: operate on framerate
 * @GST_CAIRO_FORMAT_PAR: operate on pixel aspect ratio
 *
 * Some functions operating on #GstCairoFormat or #GstCaps allow specifying
 * on which parts to operate. This enumeration is used to specify that.
 */

static void
get_format_for_caps (GstCairoFormat * format, GstCaps * caps)
{
  guint i;
  GstCaps *current;
  gboolean can_intersect;

  for (i = 0; i == 0 || formatcaps[i].format != 0; i++) {
    current = gst_static_caps_get (&formatcaps[i].caps);
    can_intersect = gst_caps_can_intersect (current, caps);
    gst_caps_unref (current);
    if (can_intersect) {
      format->format = formatcaps[i].format;
      format->video_format = formatcaps[i].video_format;
      return;
    }
  }
  g_assert_not_reached ();
}

/**
 * gst_cairo_format_new:
 * @caps: caps to parse. The caps must be fixed and valid cairo caps.
 *
 * Parses the fixed @caps into a #GstCairoFormat for easy use during 
 * operation like when using buffers in the given caps.
 *
 * Returns: a new #GstCairoFormat, free with gst_cairo_format_free()
 **/
GstCairoFormat *
gst_cairo_format_new (GstCaps * caps)
{
  GstStructure *structure;
  GstCairoFormat *format;

  g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
  g_return_val_if_fail (gst_caps_is_fixed (caps), NULL);

  format = g_slice_new (GstCairoFormat);
  format->refcount = 1;

  structure = gst_caps_get_structure (caps, 0);

  get_format_for_caps (format, caps);

  if (!gst_structure_get_int (structure, "width", &format->width) ||
      !gst_structure_get_int (structure, "height", &format->height) ||
      !gst_structure_get_fraction (structure, "framerate",
          &format->framerate.num, &format->framerate.denom)) {
    /* It's an application error to pass unparsable caps */
    g_return_val_if_reached (NULL);
  }

  if (!gst_structure_get_fraction (structure, "pixel-aspect-ratio",
          &format->par.num, &format->par.denom)) {
    format->par.num = 0;
    format->par.denom = 0;
  }

  return format;
}

/**
 * gst_cairo_format_copy:
 * @format: the format to copy
 *
 * Creates a copy for the given @format.
 *
 * Returns: a copy of the given @format
 **/
GstCairoFormat *
gst_cairo_format_copy (const GstCairoFormat * format)
{
  GstCairoFormat *copy;

  g_return_val_if_fail (format != NULL, NULL);

  copy = (GstCairoFormat *) format;
  g_atomic_int_inc ((int *) &copy->refcount);

  return copy;
}

/**
 * gst_cairo_format_free:
 * @format: the format to free or %NULL
 *
 * Frees the given @format structure.
 **/
void
gst_cairo_format_free (GstCairoFormat * format)
{
  if (format == NULL)
    return;

  if (!g_atomic_int_dec_and_test ((int *) &format->refcount))
    return;

  g_slice_free (GstCairoFormat, format);
}

/**
 * gst_cairo_format_is_native:
 * @format: a format
 *
 * Checks if the given @format is native. Native formats accept 
 * buffers created using gst_cairo_buffer_new() that allow carrying
 * any #cairo_surface_t.
 *
 * Returns: %TRUE if the format is native
 **/
gboolean
gst_cairo_format_is_native (const GstCairoFormat * format)
{
  return format->format == 0;
}

/**
 * gst_cairo_format_to_caps:
 * @format: the format
 * @fixed: parts of the format to respect
 *
 * Creates a #GstCaps that is as permissible as possible while 
 * having fixed the parts of @format that are in @fixed.
 *
 * Returns: a new #GstCaps conforming to the given @format
 **/
GstCaps *
gst_cairo_format_to_caps (const GstCairoFormat * format,
    GstCairoFormatOption fixed)
{
  GstCaps *caps;

  if (fixed & GST_CAIRO_FORMAT_FORMAT) {
    caps = gst_cairo_caps_any ();
  } else {
    guint i;

    caps = NULL;
    for (i = 0; i == 0 && formatcaps[i].format != 0; i++) {
      if (format->format == formatcaps[i].format) {
        caps = gst_static_caps_get (&formatcaps[i].caps);
        break;
      }
    }
    g_assert (caps != NULL);
  }

  caps = gst_caps_make_writable (caps);

  if (fixed & GST_CAIRO_FORMAT_WIDTH)
    gst_caps_set_simple (caps, "width", G_TYPE_INT, format->width, NULL);
  if (fixed & GST_CAIRO_FORMAT_HEIGHT)
    gst_caps_set_simple (caps, "height", G_TYPE_INT, format->height, NULL);
  if (fixed & GST_CAIRO_FORMAT_FRAMERATE)
    gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION,
        format->framerate.num, format->framerate.denom, NULL);
  if (fixed & GST_CAIRO_FORMAT_PAR && format->par.denom != 0)
    gst_caps_set_simple (caps, "pixel-aspect-ratio", GST_TYPE_FRACTION,
        format->par.num, format->par.denom, NULL);

  return caps;
}

/**
 * gst_cairo_format_get_width:
 * @format: a format
 *
 * Queries the width of a given format
 *
 * Returns: the width in pixels
 **/
guint
gst_cairo_format_get_width (const GstCairoFormat * format)
{
  g_return_val_if_fail (format != NULL, 0);

  return format->width;
}

/**
 * gst_cairo_format_get_height:
 * @format: a format
 *
 * Queries the height of a given format.
 *
 * Returns: the height in pixels
 **/
guint
gst_cairo_format_get_height (const GstCairoFormat * format)
{
  g_return_val_if_fail (format != NULL, 0);

  return format->height;
}

/**
 * gst_cairo_format_get_framerate:
 * @format: a format
 * @numerator: value to store the framerate's numerator
 * @denominator: value to store the framerate's denominator
 *
 * Queries the framerate of the given @format and stores it in the given 
 * values.
 **/
void
gst_cairo_format_get_framerate (const GstCairoFormat * format,
    guint * numerator, guint * denominator)
{
  g_return_if_fail (format != NULL);

  if (numerator)
    *numerator = format->framerate.num;
  if (denominator)
    *denominator = format->framerate.denom;
}

/**
 * gst_cairo_format_get_pixel_aspect_ratio:
 * @format: format to query
 * @numerator: location to store numerator of aspect ratio or %NULL
 * @denominator: location to store denominator of aspect ratio %NULL
 *
 * Queries the pixel aspect ratio of @format. If no format was set, %FALSE 
 * is returned and the aspect ratio is set to 1/1.
 * 
 * Returns: %TRUE if a pixel aspect ratio was set.
 **/
gboolean
gst_cairo_format_get_pixel_aspect_ratio (const GstCairoFormat * format,
    int *numerator, int *denominator)
{
  g_return_val_if_fail (format != NULL, FALSE);

  if (format->par.denom == 0) {
    if (numerator)
      *numerator = 1;
    if (denominator)
      *denominator = 1;
    return FALSE;
  } else {
    if (numerator)
      *numerator = format->par.num;
    if (denominator)
      *denominator = format->par.denom;
    return TRUE;
  }
}

/**
 * gst_cairo_format_get_buffer_size:
 * @format: the format
 *
 * Computes the size buffers passed in the given @format must have.
 * This function must not be called if @format is native 
 *
 * Returns: Size of buffers for this format
 **/
gsize
gst_cairo_format_get_buffer_size (const GstCairoFormat * format)
{
  g_return_val_if_fail (format != NULL, 0);

  if (format->video_format != GST_VIDEO_FORMAT_UNKNOWN)
    return gst_video_format_get_size (format->video_format,
        format->width, format->height);

  switch (format->format) {
    case PIXMAN_g8:
      return GST_ROUND_UP_4 (format->width) * format->height;
    case PIXMAN_nv12:
    case PIXMAN_nv21:
      return GST_ROUND_UP_4 (format->width) * GST_ROUND_UP_2 (format->height) *
          3 / 2;
    default:
      g_assert_not_reached ();
      return 0;
  }
}

gsize
gst_cairo_format_get_offset (const GstCairoFormat * format, guint plane)
{
  g_return_val_if_fail (format != NULL, 0);

  if (format->video_format != GST_VIDEO_FORMAT_UNKNOWN)
    return gst_video_format_get_component_offset (format->video_format, plane,
        format->width, format->height);

  switch (format->format) {
    case PIXMAN_g8:
      return 0;
    case PIXMAN_nv12:
    case PIXMAN_nv21:
      if (plane == 1)
        return GST_ROUND_UP_4 (format->width) * GST_ROUND_UP_2 (format->height);
      else
        return 0;
    default:
      g_assert_not_reached ();
      return 0;
  }
}

gsize
gst_cairo_format_get_stride (const GstCairoFormat * format, guint plane)
{
  g_return_val_if_fail (format != NULL, 0);

  if (format->video_format != GST_VIDEO_FORMAT_UNKNOWN)
    return gst_video_format_get_row_stride (format->video_format, plane,
        format->width);

  switch (format->format) {
    case PIXMAN_g8:
      return GST_ROUND_UP_4 (format->width);
    case PIXMAN_nv12:
    case PIXMAN_nv21:
      return GST_ROUND_UP_4 (format->width);
    default:
      g_assert_not_reached ();
      return 0;
  }
}

pixman_format_code_t
gst_cairo_format_get_pixman_format (const GstCairoFormat * format)
{
  return format->format ? format->format : PIXMAN_a8r8g8b8;
}

/**
 * gst_cairo_format_equal:
 * @a: first format to compare
 * @b: second format to compare
 * @ignore: the settings of the formats that are to be ignored
 *
 * Compares the two formats @a and @b for equality in the all settings but 
 * those in @ignore.
 *
 * Returns: %TRUE if the relevant parts of the formats where equal
 **/
gboolean
gst_cairo_format_equal (const GstCairoFormat * a, const GstCairoFormat * b,
    GstCairoFormatOption ignore)
{
  g_return_val_if_fail (a != NULL, FALSE);
  g_return_val_if_fail (b != NULL, FALSE);

  if (!(ignore & GST_CAIRO_FORMAT_FORMAT) && a->format != b->format)
    return FALSE;

  if (!(ignore & GST_CAIRO_FORMAT_WIDTH) && a->width != b->width)
    return FALSE;

  if (!(ignore & GST_CAIRO_FORMAT_HEIGHT) && a->height != b->height)
    return FALSE;

  if (!(ignore & GST_CAIRO_FORMAT_FRAMERATE) &&
      (a->framerate.num != b->framerate.num ||
          a->framerate.denom != b->framerate.denom))
    return FALSE;

  if (!(ignore & GST_CAIRO_FORMAT_PAR) &&
      (a->par.num != b->par.num || a->par.denom != b->par.denom))
    return FALSE;

  return TRUE;
}