gstreamer/gst/videoscale/gstvideoscale.c

/* GStreamer
 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
 *
 * 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.
 */


/*#define DEBUG_ENABLED */
#include <gstvideoscale.h>



/* elementfactory information */
static GstElementDetails videoscale_details = {
  "Video scaler",
  "Filter/Video",
  "LGPL",
  "Resizes video",
  VERSION,
  "Wim Taymans <wim.taymans@chello.be>",
  "(C) 2000",
};

/* GstVideoscale signals and args */
enum {
  /* FILL ME */
  LAST_SIGNAL
};

enum {
  ARG_0,
  ARG_WIDTH,
  ARG_HEIGHT,
  ARG_METHOD,
  /* FILL ME */
};

GST_PAD_TEMPLATE_FACTORY (sink_templ,
  "sink",
  GST_PAD_SINK,
  GST_PAD_ALWAYS,
  GST_CAPS_NEW (
    "videoscale_caps",
    "video/raw",
      "format",		GST_PROPS_FOURCC (GST_MAKE_FOURCC ('I','4','2','0'))
  )
)
  
GST_PAD_TEMPLATE_FACTORY (src_templ,
  "src",
  GST_PAD_SRC,
  GST_PAD_ALWAYS,
  GST_CAPS_NEW (
    "videoscale_caps",
    "video/raw",
      "format",		GST_PROPS_FOURCC (GST_MAKE_FOURCC ('I','4','2','0'))
  )
)

#define GST_TYPE_VIDEOSCALE_METHOD (gst_videoscale_method_get_type())
static GType
gst_videoscale_method_get_type (void)
{
  static GType videoscale_method_type = 0;
  static GEnumValue videoscale_methods[] = {
    { GST_VIDEOSCALE_POINT_SAMPLE, "0", "Point Sample" },
    { GST_VIDEOSCALE_NEAREST,      "1", "Nearest" },
    { GST_VIDEOSCALE_BILINEAR,     "2", "Bilinear" },
    { GST_VIDEOSCALE_BICUBIC,      "3", "Bicubic" },
    { 0, NULL, NULL },
  };
  if (!videoscale_method_type) {
    videoscale_method_type = g_enum_register_static ("GstVideoscaleMethod", videoscale_methods);
  }
  return videoscale_method_type;
}

static void	gst_videoscale_class_init	(GstVideoscaleClass *klass);
static void	gst_videoscale_init		(GstVideoscale *videoscale);

static void	gst_videoscale_set_property		(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void	gst_videoscale_get_property		(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);

static void	gst_videoscale_chain		(GstPad *pad, GstBuffer *buf);

static GstElementClass *parent_class = NULL;
/*static guint gst_videoscale_signals[LAST_SIGNAL] = { 0 }; */

GType
gst_videoscale_get_type (void)
{
  static GType videoscale_type = 0;

  if (!videoscale_type) {
    static const GTypeInfo videoscale_info = {
      sizeof(GstVideoscaleClass),      NULL,
      NULL,
      (GClassInitFunc)gst_videoscale_class_init,
      NULL,
      NULL,
      sizeof(GstVideoscale),
      0,
      (GInstanceInitFunc)gst_videoscale_init,
    };
    videoscale_type = g_type_register_static(GST_TYPE_ELEMENT, "GstVideoscale", &videoscale_info, 0);
  }
  return videoscale_type;
}

static void
gst_videoscale_class_init (GstVideoscaleClass *klass)
{
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass*)klass;
  gstelement_class = (GstElementClass*)klass;

  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_WIDTH,
    g_param_spec_int("width","width","width",
                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_HEIGHT,
    g_param_spec_int("height","height","height",
                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_METHOD,
    g_param_spec_enum("method","method","method",
                      GST_TYPE_VIDEOSCALE_METHOD,0,G_PARAM_READWRITE)); /* CHECKME! */

  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);

  gobject_class->set_property = gst_videoscale_set_property;
  gobject_class->get_property = gst_videoscale_get_property;

}

/*
static GstPadNegotiateReturn
videoscale_negotiate_src (GstPad *pad, GstCaps **caps, gpointer *data)
{
  GstVideoscale *videoscale = GST_VIDEOSCALE (gst_pad_get_parent (pad));

  GST_DEBUG(0,"videoscale_negotiate_src");

  if(*caps==NULL){
    return GST_PAD_NEGOTIATE_FAIL;
  }

  *caps = GST_CAPS_NEW ( "videoscale_caps",
		      "video/raw",
		        "format",	GST_PROPS_FOURCC (videoscale->format),
			"width",	GST_PROPS_INT (videoscale->targetwidth),
			"height",	GST_PROPS_INT (videoscale->targetheight)
		    );

  return GST_PAD_NEGOTIATE_AGREE;
}

static GstPadNegotiateReturn
videoscale_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
{
  GST_DEBUG(0,"videoscale_negotiate_sink");

  if (*caps==NULL)
    return GST_PAD_NEGOTIATE_FAIL;
  
  return GST_PAD_NEGOTIATE_AGREE;
}
*/

static GstPadLinkReturn
gst_videoscale_sinkconnect (GstPad *pad, GstCaps *caps)
{
  GstVideoscale *videoscale;

  GST_DEBUG(0,"gst_videoscale_sinkconnect");
  videoscale = GST_VIDEOSCALE (gst_pad_get_parent (pad));

  if (!GST_CAPS_IS_FIXED (caps)) {
    return GST_PAD_LINK_DELAYED;
  }

  gst_caps_get_fourcc_int (caps, "format", &videoscale->format);
  gst_caps_get_int (caps, "width", &videoscale->width);
  gst_caps_get_int (caps, "height", &videoscale->height);

  gst_videoscale_setup(videoscale);

  GST_DEBUG (0,"target size %d x %d",videoscale->targetwidth,
		videoscale->targetheight);

  GST_DEBUG(0,"width %d",videoscale->targetwidth);
  return gst_pad_try_set_caps (videoscale->srcpad, 
		    GST_CAPS_NEW (
		      "videoscale_src",
		      "video/raw",
		        "format",	GST_PROPS_FOURCC (videoscale->format),
			"width",	GST_PROPS_INT (videoscale->targetwidth),
			"height",	GST_PROPS_INT (videoscale->targetheight)
		    ));
}

static void
gst_videoscale_init (GstVideoscale *videoscale)
{
  GST_DEBUG(0,"gst_videoscale_init");
  videoscale->sinkpad = gst_pad_new_from_template (
		  GST_PAD_TEMPLATE_GET (sink_templ), "sink");
  /*gst_pad_set_negotiate_function(videoscale->sinkpad,videoscale_negotiate_sink); */
  gst_element_add_pad(GST_ELEMENT(videoscale),videoscale->sinkpad);
  gst_pad_set_chain_function(videoscale->sinkpad,gst_videoscale_chain);
  gst_pad_set_link_function(videoscale->sinkpad,gst_videoscale_sinkconnect);

  videoscale->srcpad = gst_pad_new_from_template (
		  GST_PAD_TEMPLATE_GET (src_templ), "src");
  /*gst_pad_set_negotiate_function(videoscale->srcpad,videoscale_negotiate_src); */
  gst_element_add_pad(GST_ELEMENT(videoscale),videoscale->srcpad);

  videoscale->targetwidth = -1;
  videoscale->targetheight = -1;
  videoscale->method = GST_VIDEOSCALE_NEAREST;
  /*videoscale->method = GST_VIDEOSCALE_BILINEAR; */
  /*videoscale->method = GST_VIDEOSCALE_POINT_SAMPLE; */
}


static void
gst_videoscale_chain (GstPad *pad, GstBuffer *buf)
{
  GstVideoscale *videoscale;
  guchar *data;
  gulong size;
  GstBuffer *outbuf;

  GST_DEBUG (0,"gst_videoscale_chain");

  g_return_if_fail (pad != NULL);
  g_return_if_fail (GST_IS_PAD (pad));
  g_return_if_fail (buf != NULL);

  videoscale = GST_VIDEOSCALE (gst_pad_get_parent (pad));
  data = GST_BUFFER_DATA(buf);
  size = GST_BUFFER_SIZE(buf);

  if(!videoscale->scale_cc){
    gst_caps_get_int (gst_pad_get_caps(pad), "format", &videoscale->format);
    gst_videoscale_setup(videoscale);
  }
  GST_DEBUG (0,"gst_videoscale_chain: got buffer of %ld bytes in '%s'",size,
		              GST_OBJECT_NAME (videoscale));
 
GST_DEBUG(0,"size=%ld from=%dx%d to=%dx%d newsize=%d",
	size,
	videoscale->width, videoscale->height,
	videoscale->targetwidth, videoscale->targetheight,
  	videoscale->targetwidth*videoscale->targetheight + videoscale->targetwidth*videoscale->targetheight/2);

  if(videoscale->targetwidth==videoscale->width &&
     videoscale->targetheight==videoscale->height){
	gst_pad_push(videoscale->srcpad, buf);
  }else{
    outbuf = gst_buffer_new();
    /* XXX this is wrong for anything but I420 */
    GST_BUFFER_SIZE(outbuf) = videoscale->targetwidth*videoscale->targetheight +
  			    videoscale->targetwidth*videoscale->targetheight/2;
    GST_BUFFER_DATA(outbuf) = g_malloc (videoscale->targetwidth*videoscale->targetheight*2);
    GST_BUFFER_TIMESTAMP(outbuf) = GST_BUFFER_TIMESTAMP(buf);

    /*g_return_if_fail(videoscale->scale_cc != NULL); */
    videoscale->scale_cc(videoscale, data, GST_BUFFER_DATA(outbuf));

    GST_DEBUG (0,"gst_videoscale_chain: pushing buffer of %d bytes in '%s'",GST_BUFFER_SIZE(outbuf),
		              GST_OBJECT_NAME (videoscale));

    gst_pad_push(videoscale->srcpad, outbuf);

    gst_buffer_unref(buf);
  }
}

static void
gst_videoscale_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  GstVideoscale *src;

  /* it's not null if we got it, but it might not be ours */
  g_return_if_fail(GST_IS_VIDEOSCALE(object));
  src = GST_VIDEOSCALE(object);

  GST_DEBUG(0,"gst_videoscale_set_property");
  switch (prop_id) {
    case ARG_WIDTH:
      src->targetwidth = g_value_get_int (value);
      break;
    case ARG_HEIGHT:
      src->targetheight = g_value_get_int (value);
      break;
    case ARG_METHOD:
      src->method = g_value_get_enum (value);
      break;
    default:
      break;
  }
}

static void
gst_videoscale_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  GstVideoscale *src;

  /* it's not null if we got it, but it might not be ours */
  g_return_if_fail(GST_IS_VIDEOSCALE(object));
  src = GST_VIDEOSCALE(object);

  switch (prop_id) {
    case ARG_WIDTH:
      g_value_set_int (value, src->targetwidth);
      break;
    case ARG_HEIGHT:
      g_value_set_int (value, src->targetheight);
      break;
    case ARG_METHOD:
      g_value_set_enum (value, src->method);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}


static gboolean
plugin_init (GModule *module, GstPlugin *plugin)
{
  GstElementFactory *factory;

  /* create an elementfactory for the videoscale element */
  factory = gst_element_factory_new("videoscale",GST_TYPE_VIDEOSCALE,
                                   &videoscale_details);
  g_return_val_if_fail(factory != NULL, FALSE);

  gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (sink_templ));
  gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (src_templ));

  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));

  return TRUE;
}

GstPluginDesc plugin_desc = {
  GST_VERSION_MAJOR,
  GST_VERSION_MINOR,
  "videoscale",
  plugin_init
};