From: <ds...@fr...> - 2005-05-29 00:47:09
|
CVS Root: /cvs/gstreamer Module: gst-plugins Changes by: ds Date: Sat May 28 2005 17:47:01 PDT Branch: BRANCH-GSTREAMER-0_8 Log message: * gst/videoscale/Makefile.am: * gst/videoscale/gstvideoscale.c: * gst/videoscale/gstvideoscale.h: * gst/videoscale/videoscale.c: * gst/videoscale/videoscale.h: * gst/videoscale/videoscale_x86.c: * gst/videoscale/videoscale_x86.h: * gst/videoscale/videoscale_x86_asm.s: * gst/videoscale/vs_image.c: * gst/videoscale/vs_image.h: * gst/videoscale/vs_scanline.c: * gst/videoscale/vs_scanline.h: Some days, you just get the urge to rewrite a bunch of code. Today, it was writing new image scaling code that is liboil compatible (although not liboilified yet), and does both nearest and bilinear scaling. Modified files: . : ChangeLog gst/videoscale : Makefile.am gstvideoscale.c gstvideoscale.h Added files: gst/videoscale : vs_image.c vs_image.h vs_scanline.c vs_scanline.h Removed files: gst/videoscale : videoscale.c videoscale.h videoscale_x86.c videoscale_x86.h videoscale_x86_asm.s Links: http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ChangeLog.diff?r1=1.1641.2.201&r2=1.1641.2.202 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/Makefile.am.diff?r1=1.11&r2=1.11.18.1 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/gstvideoscale.c.diff?r1=1.55.2.2&r2=1.55.2.3 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/gstvideoscale.h.diff?r1=1.11&r2=1.11.4.1 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/videoscale.c http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/videoscale.h http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/videoscale_x86.c http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/videoscale_x86.h http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/videoscale_x86_asm.s http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_image.c?rev=1.1.2.1&content-type=text/vnd.viewcvs-markup http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_image.h?rev=1.1.2.1&content-type=text/vnd.viewcvs-markup http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_scanline.c?rev=1.1.2.1&content-type=text/vnd.viewcvs-markup http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_scanline.h?rev=1.1.2.1&content-type=text/vnd.viewcvs-markup ====Begin Diffs==== Index: ChangeLog =================================================================== RCS file: /cvs/gstreamer/gst-plugins/ChangeLog,v retrieving revision 1.1641.2.201 retrieving revision 1.1641.2.202 diff -u -d -r1.1641.2.201 -r1.1641.2.202 --- ChangeLog 26 May 2005 17:34:44 -0000 1.1641.2.201 +++ ChangeLog 29 May 2005 00:46:48 -0000 1.1641.2.202 @@ -1,3 +1,22 @@ +2005-05-28 David Schleef <ds...@sc...> + + * gst/videoscale/Makefile.am: + * gst/videoscale/gstvideoscale.c: + * gst/videoscale/gstvideoscale.h: + * gst/videoscale/videoscale.c: + * gst/videoscale/videoscale.h: + * gst/videoscale/videoscale_x86.c: + * gst/videoscale/videoscale_x86.h: + * gst/videoscale/videoscale_x86_asm.s: + * gst/videoscale/vs_image.c: + * gst/videoscale/vs_image.h: + * gst/videoscale/vs_scanline.c: + * gst/videoscale/vs_scanline.h: + Some days, you just get the urge to rewrite a bunch of code. + Today, it was writing new image scaling code that is liboil + compatible (although not liboilified yet), and does both + nearest and bilinear scaling. 2005-05-26 Arwed v. Merkatz <v.m...@gm...> * ext/spc/Makefile.am: add the .Asm file to SOURCES so they're included Index: Makefile.am RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/Makefile.am,v retrieving revision 1.11 retrieving revision 1.11.18.1 diff -u -d -r1.11 -r1.11.18.1 --- Makefile.am 11 Sep 2003 19:58:00 -0000 1.11 +++ Makefile.am 29 May 2005 00:46:49 -0000 1.11.18.1 @@ -1,20 +1,17 @@ plugin_LTLIBRARIES = libgstvideoscale.la -if HAVE_CPU_I386 -ARCHSRCS = \ - videoscale_x86.c \ - videoscale_x86_asm.s -else -ARCHSRCS = -endif - libgstvideoscale_la_SOURCES = \ - gstvideoscale.c \ - videoscale.c \ - $(ARCHSRCS) + gstvideoscale.c \ + vs_image.c \ + vs_scanline.c + libgstvideoscale_la_CFLAGS = $(GST_CFLAGS) libgstvideoscale_la_LIBADD = libgstvideoscale_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) -noinst_HEADERS = gstvideoscale.h videoscale_x86.h videoscale.h +noinst_HEADERS = \ + gstvideoscale.h \ + vs_image.h \ + vs_scanline.h Index: gstvideoscale.c RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/gstvideoscale.c,v retrieving revision 1.55.2.2 retrieving revision 1.55.2.3 diff -u -d -r1.55.2.2 -r1.55.2.3 --- gstvideoscale.c 22 Apr 2005 15:19:07 -0000 1.55.2.2 +++ gstvideoscale.c 29 May 2005 00:46:49 -0000 1.55.2.3 @@ -22,8 +22,11 @@ #include "config.h" #endif #include "gstvideoscale.h" -#include "videoscale.h" +#include <gst/video/video.h> +#include <string.h> +#include "vs_image.h" /* debug variable definition */ GST_DEBUG_CATEGORY (videoscale_debug); @@ -49,6 +52,37 @@ /* FILL ME */ }; +static GstStaticCaps gst_videoscale_format_caps[] = { + GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBx), + GST_STATIC_CAPS (GST_VIDEO_CAPS_xRGB), + GST_STATIC_CAPS (GST_VIDEO_CAPS_BGRx), + GST_STATIC_CAPS (GST_VIDEO_CAPS_xBGR), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("AYUV")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("YUY2")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("YVYU")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("UYVY")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("Y800")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("YV12")), + GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB_16) +}; +enum +{ + GST_VIDEOSCALE_RGBx = 0, + GST_VIDEOSCALE_xRGB, + GST_VIDEOSCALE_BGRx, + GST_VIDEOSCALE_xBGR, + GST_VIDEOSCALE_AYUV, + GST_VIDEOSCALE_YUY2, + GST_VIDEOSCALE_YVYU, + GST_VIDEOSCALE_UYVY, + GST_VIDEOSCALE_Y, + GST_VIDEOSCALE_I420, + GST_VIDEOSCALE_YV12, + GST_VIDEOSCALE_RGB565 #define GST_TYPE_VIDEOSCALE_METHOD (gst_videoscale_method_get_type()) static GType gst_videoscale_method_get_type (void) @@ -72,16 +106,19 @@ static GstCaps * gst_videoscale_get_capslist (void) { - GstCaps *caps; - int i; + static GstCaps *caps; - caps = gst_caps_new_empty (); - for (i = 0; i < videoscale_n_formats; i++) { - gst_caps_append_structure (caps, - videoscale_get_structure (videoscale_formats + i)); + if (caps == NULL) { + int i; + caps = gst_caps_new_empty (); + for (i = 0; i < G_N_ELEMENTS (gst_videoscale_format_caps); i++) { + gst_caps_append (caps, + gst_caps_copy (gst_static_caps_get (&gst_videoscale_format_caps[i]))); + } } - return caps; + return gst_caps_copy (caps); } static GstPadTemplate * @@ -194,8 +231,8 @@ GstStructure *structure = gst_caps_get_structure (caps, i); gst_structure_set (structure, - "width", GST_TYPE_INT_RANGE, 16, G_MAXINT, - "height", GST_TYPE_INT_RANGE, 16, G_MAXINT, NULL); + "width", GST_TYPE_INT_RANGE, 16, 4096, + "height", GST_TYPE_INT_RANGE, 16, 4096, NULL); gst_structure_remove_field (structure, "pixel-aspect-ratio"); @@ -203,6 +240,24 @@ return caps; +static int +gst_videoscale_get_format (const GstCaps * caps) + int i; + GstCaps *icaps; + for (i = 0; i < G_N_ELEMENTS (gst_videoscale_format_caps); i++) { + icaps = gst_caps_intersect (caps, + gst_static_caps_get (&gst_videoscale_format_caps[i])); + if (!gst_caps_is_empty (icaps)) { + gst_caps_free (icaps); + return i; + gst_caps_free (icaps); + } + return -1; +} static GstPadLinkReturn gst_videoscale_link (GstPad * pad, const GstCaps * caps) @@ -212,7 +267,7 @@ GstPad *otherpad; GstCaps *othercaps, *newcaps; GstStructure *otherstructure, *structure, *newstructure; - struct videoscale_format_struct *format; + int format; int height = 0, width = 0, newwidth, newheight; const GValue *par = NULL, *otherpar; @@ -227,9 +282,9 @@ ret &= gst_structure_get_int (structure, "height", &height); par = gst_structure_get_value (structure, "pixel-aspect-ratio"); - format = videoscale_find_by_structure (structure); + format = gst_videoscale_get_format (caps); - if (!ret || format == NULL) + if (!ret || format == -1) return GST_PAD_LINK_REFUSED; GST_DEBUG_OBJECT (videoscale, @@ -346,7 +401,6 @@ videoscale->to_height = newheight; videoscale->format = format; - gst_videoscale_setup (videoscale); GST_DEBUG_OBJECT (videoscale, "work completed"); @@ -476,8 +530,6 @@ gst_pad_set_getcaps_function (videoscale->srcpad, gst_videoscale_getcaps); gst_pad_set_fixate_function (videoscale->srcpad, gst_videoscale_src_fixate); - videoscale->inited = FALSE; videoscale->method = GST_VIDEOSCALE_NEAREST; /*videoscale->method = GST_VIDEOSCALE_BILINEAR; */ /*videoscale->method = GST_VIDEOSCALE_POINT_SAMPLE; */ @@ -514,51 +566,192 @@ +#define ROUND_UP_2(x) (((x)+1)&~1) +#define ROUND_UP_4(x) (((x)+3)&~3) +#define ROUND_UP_8(x) (((x)+7)&~7) static void gst_videoscale_chain (GstPad * pad, GstData * _data) GstBuffer *buf = GST_BUFFER (_data); GstVideoscale *videoscale; - guchar *data; gulong size; GstBuffer *outbuf; + VSImage dest; + VSImage src; + VSImage dest_u; + VSImage src_u; + VSImage dest_v; + VSImage src_v; + guint8 *tmpbuf; 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)); - g_return_if_fail (videoscale->inited); - data = GST_BUFFER_DATA (buf); - size = GST_BUFFER_SIZE (buf); if (videoscale->passthru) { - GST_LOG_OBJECT (videoscale, "passing through buffer of %ld bytes", size); gst_pad_push (videoscale->srcpad, GST_DATA (buf)); return; GST_LOG_OBJECT (videoscale, - "buffersize=%ld from=%dx%d to=%dx%d fromsize=%ld tosize=%ld", - size, videoscale->from_width, videoscale->from_height, - videoscale->to_width, videoscale->to_height, - videoscale->from_buf_size, videoscale->to_buf_size); + "from=%dx%d to=%dx%d", + videoscale->from_width, videoscale->from_height, + videoscale->to_width, videoscale->to_height); - g_return_if_fail (size == videoscale->from_buf_size); + src.pixels = GST_BUFFER_DATA (buf); + src.width = videoscale->from_width; + src.height = videoscale->from_height; - outbuf = gst_pad_alloc_buffer (videoscale->srcpad, - GST_BUFFER_OFFSET_NONE, videoscale->to_buf_size); + dest.width = videoscale->to_width; + dest.height = videoscale->to_height; + switch (videoscale->format) { + case GST_VIDEOSCALE_RGBx: + case GST_VIDEOSCALE_xRGB: + case GST_VIDEOSCALE_BGRx: + case GST_VIDEOSCALE_xBGR: + case GST_VIDEOSCALE_AYUV: + src.stride = videoscale->from_width * 4; + dest.stride = videoscale->to_width * 4; + size = dest.stride * dest.height; + break; + case GST_VIDEOSCALE_YUY2: + case GST_VIDEOSCALE_YVYU: + case GST_VIDEOSCALE_UYVY: + src.stride = ROUND_UP_4 (videoscale->from_width * 2); + dest.stride = ROUND_UP_4 (videoscale->to_width * 2); + case GST_VIDEOSCALE_Y: + src.stride = ROUND_UP_4 (videoscale->from_width); + dest.stride = ROUND_UP_4 (videoscale->to_width); + case GST_VIDEOSCALE_I420: + case GST_VIDEOSCALE_YV12: + src_u.pixels = src.pixels + ROUND_UP_2 (src.height) * src.stride; + src_u.height = ROUND_UP_2 (src.height) / 2; + src_u.width = ROUND_UP_2 (src.width) / 2; + src_u.stride = ROUND_UP_4 (src.stride / 2); + dest_u.height = ROUND_UP_2 (dest.height) / 2; + dest_u.width = ROUND_UP_2 (dest.width) / 2; + dest_u.stride = ROUND_UP_4 (dest.stride / 2); + memcpy (&src_v, &src_u, sizeof (src_v)); + src_v.pixels = src_u.pixels + src_u.height * src_u.stride; + memcpy (&dest_v, &dest_u, sizeof (dest_v)); + size = dest.stride * ROUND_UP_2 (dest.height) + + 2 * dest_u.stride * dest_u.height; + case GST_VIDEOSCALE_RGB565: + default: + g_warning ("don't know how to scale"); + outbuf = gst_pad_alloc_buffer (videoscale->srcpad, + GST_BUFFER_OFFSET_NONE, dest.stride * dest.height); gst_buffer_stamp (outbuf, buf); - g_return_if_fail (videoscale->format); - GST_LOG_OBJECT (videoscale, "format " GST_FOURCC_FORMAT, - GST_FOURCC_ARGS (videoscale->format->fourcc)); - g_return_if_fail (videoscale->format->scale); + dest.pixels = GST_BUFFER_DATA (outbuf); + dest_u.pixels = dest.pixels + ROUND_UP_2 (dest.height) * dest.stride; + dest_v.pixels = dest_u.pixels + dest_u.height * dest_u.stride; - videoscale->format->scale (videoscale, GST_BUFFER_DATA (outbuf), data); + tmpbuf = g_malloc (dest.stride * 2); + switch (videoscale->method) { + case GST_VIDEOSCALE_NEAREST: + switch (videoscale->format) { + case GST_VIDEOSCALE_RGBx: + case GST_VIDEOSCALE_xRGB: + case GST_VIDEOSCALE_BGRx: + case GST_VIDEOSCALE_xBGR: + case GST_VIDEOSCALE_AYUV: + vs_image_scale_nearest_RGBA (&dest, &src, tmpbuf); + break; + case GST_VIDEOSCALE_YUY2: + case GST_VIDEOSCALE_YVYU: + vs_image_scale_nearest_YUYV (&dest, &src, tmpbuf); + case GST_VIDEOSCALE_UYVY: + vs_image_scale_nearest_UYVY (&dest, &src, tmpbuf); + case GST_VIDEOSCALE_Y: + vs_image_scale_nearest_Y (&dest, &src, tmpbuf); + case GST_VIDEOSCALE_I420: + case GST_VIDEOSCALE_YV12: + vs_image_scale_nearest_Y (&dest_u, &src_u, tmpbuf); + vs_image_scale_nearest_Y (&dest_v, &src_v, tmpbuf); + case GST_VIDEOSCALE_RGB565: + vs_image_scale_nearest_RGB565 (&dest, &src, tmpbuf); + default: + g_warning ("don't know how to scale"); + } + case GST_VIDEOSCALE_BILINEAR: + case GST_VIDEOSCALE_BICUBIC: + vs_image_scale_linear_RGBA (&dest, &src, tmpbuf); + vs_image_scale_linear_YUYV (&dest, &src, tmpbuf); + vs_image_scale_linear_UYVY (&dest, &src, tmpbuf); + vs_image_scale_linear_Y (&dest, &src, tmpbuf); + //memset (dest_u.pixels, 128, dest_u.stride * dest_u.height); + //memset (dest_v.pixels, 128, dest_v.stride * dest_v.height); + vs_image_scale_linear_Y (&dest_u, &src_u, tmpbuf); + vs_image_scale_linear_Y (&dest_v, &src_v, tmpbuf); + vs_image_scale_linear_RGB565 (&dest, &src, tmpbuf); + g_assert_not_reached (); + g_free (tmpbuf); GST_LOG_OBJECT (videoscale, "pushing buffer of %d bytes", GST_BUFFER_SIZE (outbuf)); Index: gstvideoscale.h RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/gstvideoscale.h,v retrieving revision 1.11.4.1 diff -u -d -r1.11 -r1.11.4.1 --- gstvideoscale.h 27 Jul 2004 16:43:20 -0000 1.11 +++ gstvideoscale.h 29 May 2005 00:46:49 -0000 1.11.4.1 @@ -61,7 +61,7 @@ /* video state */ gboolean inited; gint to_width; gint to_height; gint from_width; @@ -74,13 +74,7 @@ GstVideoScaleMethod method; /* private */ - gint from_buf_size; gint to_buf_size; -#if 0 - guchar *temp; - guchar (*filter) (guchar *src, gdouble x, gdouble y, gint sw, gint sh); - guchar copy_row[8192]; -#endif struct _GstVideoscaleClass { --- videoscale.c DELETED --- --- videoscale.h DELETED --- --- videoscale_x86.c DELETED --- --- videoscale_x86.h DELETED --- --- videoscale_x86_asm.s DELETED --- --- NEW FILE: vs_image.c --- /* * Image Scaling Functions * Copyright (c) 2005 David A. Schleef <ds...@sc...> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include <glib.h> #include <string.h> #include "vs_scanline.h" #include "vs_image.h" #define ROUND_UP_2(x) (((x)+1)&~1) #define ROUND_UP_4(x) (((x)+3)&~3) #define ROUND_UP_8(x) (((x)+7)&~7) void vs_image_scale_nearest_RGBA (const VSImage * dest, const VSImage * src, guint8 * tmpbuf) { int acc; int y_increment; int x_increment; int i; int j; int x; int xacc; y_increment = ((src->height - 1) << 16) / (dest->height - 1); x_increment = ((src->width - 1) << 16) / (dest->width - 1); acc = 0; for (i = 0; i < dest->height; i++) { j = acc >> 16; x = acc & 0xffff; xacc = 0; vs_scanline_resample_nearest_RGBA (dest->pixels + i * dest->stride, src->pixels + j * src->stride, dest->width, &xacc, x_increment); acc += y_increment; } } vs_image_scale_linear_RGBA (const VSImage * dest, const VSImage * src, guint8 *tmp1; guint8 *tmp2; int y1; int y2; int dest_size; dest_size = dest->width * 4; tmp1 = tmpbuf; tmp2 = tmpbuf + dest_size; xacc = 0; y2 = -1; vs_scanline_resample_linear_RGBA (tmp1, src->pixels, dest->width, &xacc, x_increment); y1 = 0; if (x == 0) { if (j == y1) { memcpy (dest->pixels + i * dest->stride, tmp1, dest_size); } else if (j == y2) { memcpy (dest->pixels + i * dest->stride, tmp2, dest_size); } else { xacc = 0; vs_scanline_resample_linear_RGBA (tmp1, src->pixels + j * src->stride, dest->width, &xacc, x_increment); y1 = j; } } else { if (j + 1 != y2) { xacc = 0; vs_scanline_resample_linear_RGBA (tmp2, src->pixels + (j + 1) * src->stride, dest->width, &xacc, x_increment); y2 = j + 1; } vs_scanline_merge_linear_RGBA (dest->pixels + i * dest->stride, tmp1, tmp2, dest->width, x); if (j + 1 != y1) { vs_scanline_resample_linear_RGBA (tmp1, y1 = j + 1; tmp2, tmp1, dest->width, x); vs_scanline_resample_linear_RGBA (tmp2, src->pixels + (j + 1) * src->stride, dest->width, &xacc, x_increment); y2 = (j + 1); } /* YUYV */ vs_image_scale_nearest_YUYV (const VSImage * dest, const VSImage * src, int n_quads; n_quads = ROUND_UP_2 (dest->width); vs_scanline_resample_nearest_YUYV (dest->pixels + i * dest->stride, src->pixels + j * src->stride, n_quads, &xacc, x_increment); vs_image_scale_linear_YUYV (const VSImage * dest, const VSImage * src, dest_size = ROUND_UP_4 (dest->width * 2); n_quads = ROUND_UP_2 (dest->width) / 2; vs_scanline_resample_linear_YUYV (tmp1, src->pixels, n_quads, &xacc, vs_scanline_resample_linear_YUYV (tmp1, src->pixels + j * src->stride, n_quads, &xacc, x_increment); vs_scanline_resample_linear_YUYV (tmp2, src->pixels + (j + 1) * src->stride, n_quads, &xacc, x_increment); vs_scanline_merge_linear_YUYV (dest->pixels + i * dest->stride, tmp1, tmp2, n_quads, x); vs_scanline_resample_linear_YUYV (tmp1, tmp2, tmp1, n_quads, x); vs_scanline_resample_linear_YUYV (tmp2, src->pixels + (j + 1) * src->stride, n_quads, &xacc, x_increment); /* UYVY */ vs_image_scale_nearest_UYVY (const VSImage * dest, const VSImage * src, n_quads = (dest->width + 1) / 2; vs_scanline_resample_nearest_UYVY (dest->pixels + i * dest->stride, vs_image_scale_linear_UYVY (const VSImage * dest, const VSImage * src, vs_scanline_resample_linear_UYVY (tmp1, src->pixels, n_quads, &xacc, vs_scanline_resample_linear_UYVY (tmp1, src->pixels + j * src->stride, vs_scanline_resample_linear_UYVY (tmp2, vs_scanline_merge_linear_UYVY (dest->pixels + i * dest->stride, vs_scanline_resample_linear_UYVY (tmp1, vs_scanline_resample_linear_UYVY (tmp2, /* greyscale */ vs_image_scale_nearest_Y (const VSImage * dest, const VSImage * src, vs_scanline_resample_nearest_Y (dest->pixels + i * dest->stride, vs_image_scale_linear_Y (const VSImage * dest, const VSImage * src, dest_size = dest->width; vs_scanline_resample_linear_Y (tmp1, src->pixels, dest->width, &xacc, vs_scanline_resample_linear_Y (tmp1, src->pixels + j * src->stride, vs_scanline_resample_linear_Y (tmp2, vs_scanline_merge_linear_Y (dest->pixels + i * dest->stride, vs_scanline_resample_linear_Y (tmp1, vs_scanline_resample_linear_Y (tmp2, /* RGB565 */ vs_image_scale_nearest_RGB565 (const VSImage * dest, const VSImage * src, vs_scanline_resample_nearest_RGB565 (dest->pixels + i * dest->stride, vs_image_scale_linear_RGB565 (const VSImage * dest, const VSImage * src, dest_size = dest->width * 2; vs_scanline_resample_linear_RGB565 (tmp1, src->pixels, dest->width, &xacc, vs_scanline_resample_linear_RGB565 (tmp1, src->pixels + j * src->stride, vs_scanline_resample_linear_RGB565 (tmp2, vs_scanline_merge_linear_RGB565 (dest->pixels + i * dest->stride, vs_scanline_resample_linear_RGB565 (tmp1, vs_scanline_resample_linear_RGB565 (tmp2, --- NEW FILE: vs_image.h --- #ifndef __VS_IMAGE_H__ #define __VS_IMAGE_H__ G_BEGIN_DECLS typedef struct _VSImage VSImage; struct _VSImage { guint8 *pixels; int width; int height; int stride; }; void vs_image_scale_nearest_RGBA (const VSImage *dest, const VSImage *src, guint8 *tmpbuf); void vs_image_scale_linear_RGBA (const VSImage *dest, const VSImage *src, void vs_image_scale_nearest_YUYV (const VSImage *dest, const VSImage *src, void vs_image_scale_linear_YUYV (const VSImage *dest, const VSImage *src, void vs_image_scale_nearest_UYVY (const VSImage *dest, const VSImage *src, void vs_image_scale_linear_UYVY (const VSImage *dest, const VSImage *src, void vs_image_scale_nearest_Y (const VSImage *dest, const VSImage *src, void vs_image_scale_linear_Y (const VSImage *dest, const VSImage *src, void vs_image_scale_nearest_RGB565 (const VSImage *dest, const VSImage *src, void vs_image_scale_linear_RGB565 (const VSImage *dest, const VSImage *src, G_END_DECLS #endif --- NEW FILE: vs_scanline.c --- /* greyscale, i.e., single componenet */ vs_scanline_downsample_Y (guint8 * dest, guint8 * src, int n) for (i = 0; i < n; i++) { dest[i] = (src[i * 2] + src[i * 2 + 1]) / 2; vs_scanline_resample_nearest_Y (guint8 * dest, guint8 * src, int n, int *accumulator, int increment) int acc = *accumulator; dest[i] = (x < 32768) ? src[j] : src[j + 1]; acc += increment; *accumulator = acc; vs_scanline_resample_linear_Y (guint8 * dest, guint8 * src, int n, dest[i] = (src[j] * (65536 - x) + src[j + 1] * x) >> 16; vs_scanline_merge_linear_Y (guint8 * dest, guint8 * src1, guint8 * src2, int n, int x) dest[i] = (src1[i] * (65536 - x) + src2[i] * x) >> 16; /* RGBA */ vs_scanline_downsample_RGBA (guint8 * dest, guint8 * src, int n) dest[i * 4 + 0] = (src[i * 8 + 0] + src[i * 8 + 4]) / 2; dest[i * 4 + 1] = (src[i * 8 + 1] + src[i * 8 + 5]) / 2; dest[i * 4 + 2] = (src[i * 8 + 2] + src[i * 8 + 6]) / 2; dest[i * 4 + 3] = (src[i * 8 + 3] + src[i * 8 + 7]) / 2; vs_scanline_resample_nearest_RGBA (guint8 * dest, guint8 * src, int n, dest[i * 4 + 0] = (x < 32768) ? src[j * 4 + 0] : src[j * 4 + 4]; dest[i * 4 + 1] = (x < 32768) ? src[j * 4 + 1] : src[j * 4 + 5]; dest[i * 4 + 2] = (x < 32768) ? src[j * 4 + 2] : src[j * 4 + 6]; dest[i * 4 + 3] = (x < 32768) ? src[j * 4 + 3] : src[j * 4 + 7]; vs_scanline_resample_linear_RGBA (guint8 * dest, guint8 * src, int n, dest[i * 4 + 0] = (src[j * 4 + 0] * (65536 - x) + src[j * 4 + 4] * x) >> 16; dest[i * 4 + 1] = (src[j * 4 + 1] * (65536 - x) + src[j * 4 + 5] * x) >> 16; dest[i * 4 + 2] = (src[j * 4 + 2] * (65536 - x) + src[j * 4 + 6] * x) >> 16; dest[i * 4 + 3] = (src[j * 4 + 3] * (65536 - x) + src[j * 4 + 7] * x) >> 16; vs_scanline_merge_linear_RGBA (guint8 * dest, guint8 * src1, guint8 * src2, dest[i * 4 + 0] = (src1[i * 4 + 0] * (65536 - x) + src2[i * 4 + 0] * x) >> 16; dest[i * 4 + 1] = (src1[i * 4 + 1] * (65536 - x) + src2[i * 4 + 1] * x) >> 16; dest[i * 4 + 2] = (src1[i * 4 + 2] * (65536 - x) + src2[i * 4 + 2] * x) >> 16; dest[i * 4 + 3] = (src1[i * 4 + 3] * (65536 - x) + src2[i * 4 + 3] * x) >> 16; /* RGB */ vs_scanline_downsample_RGB (guint8 * dest, guint8 * src, int n) dest[i * 3 + 0] = (src[i * 6 + 0] + src[i * 6 + 3]) / 2; dest[i * 3 + 1] = (src[i * 6 + 1] + src[i * 6 + 4]) / 2; dest[i * 3 + 2] = (src[i * 6 + 2] + src[i * 6 + 5]) / 2; vs_scanline_resample_nearest_RGB (guint8 * dest, guint8 * src, int n, dest[i * 3 + 0] = (x < 32768) ? src[j * 3 + 0] : src[j * 3 + 3]; dest[i * 3 + 1] = (x < 32768) ? src[j * 3 + 1] : src[j * 3 + 4]; dest[i * 3 + 2] = (x < 32768) ? src[j * 3 + 2] : src[j * 3 + 5]; vs_scanline_resample_linear_RGB (guint8 * dest, guint8 * src, int n, dest[i * 3 + 0] = (src[j * 3 + 0] * (65536 - x) + src[j * 3 + 3] * x) >> 16; dest[i * 3 + 1] = (src[j * 3 + 1] * (65536 - x) + src[j * 3 + 4] * x) >> 16; dest[i * 3 + 2] = (src[j * 3 + 2] * (65536 - x) + src[j * 3 + 5] * x) >> 16; vs_scanline_merge_linear_RGB (guint8 * dest, guint8 * src1, guint8 * src2, dest[i * 3 + 0] = (src1[i * 3 + 0] * (65536 - x) + src2[i * 3 + 3] * x) >> 16; dest[i * 3 + 1] = (src1[i * 3 + 1] * (65536 - x) + src2[i * 3 + 4] * x) >> 16; dest[i * 3 + 2] = (src1[i * 3 + 2] * (65536 - x) + src2[i * 3 + 5] * x) >> 16; /* n is the number of bi-pixels */ /* increment is per Y pixel */ vs_scanline_downsample_YUYV (guint8 * dest, guint8 * src, int n) dest[i * 4 + 0] = (src[i * 8 + 0] + src[i * 8 + 2]) / 2; dest[i * 4 + 2] = (src[i * 8 + 4] + src[i * 8 + 6]) / 2; vs_scanline_resample_nearest_YUYV (guint8 * dest, guint8 * src, int n, dest[i * 4 + 0] = (x < 32768) ? src[j * 2 + 0] : src[j * 2 + 2]; j = acc >> 17; x = acc & 0x1ffff; dest[i * 4 + 1] = (x < 65536) ? src[j * 4 + 1] : src[j * 4 + 5]; dest[i * 4 + 3] = (x < 65536) ? src[j * 4 + 3] : src[j * 4 + 7]; dest[i * 4 + 2] = (x < 32768) ? src[j * 2 + 0] : src[j * 2 + 2]; vs_scanline_resample_linear_YUYV (guint8 * dest, guint8 * src, int n, dest[i * 4 + 0] = (src[j * 2 + 0] * (65536 - x) + src[j * 2 + 2] * x) >> 16; (src[j * 4 + 1] * (131072 - x) + src[j * 4 + 5] * x) >> 17; (src[j * 4 + 3] * (131072 - x) + src[j * 4 + 7] * x) >> 17; dest[i * 4 + 2] = (src[j * 2 + 0] * (65536 - x) + src[j * 2 + 2] * x) >> 16; vs_scanline_merge_linear_YUYV (guint8 * dest, guint8 * src1, guint8 * src2, vs_scanline_downsample_UYVY (guint8 * dest, guint8 * src, int n) dest[i * 4 + 1] = (src[i * 8 + 1] + src[i * 8 + 3]) / 2; dest[i * 4 + 3] = (src[i * 8 + 5] + src[i * 8 + 7]) / 2; vs_scanline_resample_nearest_UYVY (guint8 * dest, guint8 * src, int n, dest[i * 4 + 1] = (x < 32768) ? src[j * 2 + 1] : src[j * 2 + 3]; dest[i * 4 + 0] = (x < 65536) ? src[j * 4 + 0] : src[j * 4 + 4]; dest[i * 4 + 2] = (x < 65536) ? src[j * 4 + 2] : src[j * 4 + 6]; dest[i * 4 + 3] = (x < 32768) ? src[j * 2 + 1] : src[j * 2 + 3]; vs_scanline_resample_linear_UYVY (guint8 * dest, guint8 * src, int n, dest[i * 4 + 1] = (src[j * 2 + 1] * (65536 - x) + src[j * 2 + 3] * x) >> 16; (src[j * 4 + 0] * (131072 - x) + src[j * 4 + 4] * x) >> 17; (src[j * 4 + 2] * (131072 - x) + src[j * 4 + 6] * x) >> 17; dest[i * 4 + 3] = (src[j * 2 + 1] * (65536 - x) + src[j * 2 + 3] * x) >> 16; vs_scanline_merge_linear_UYVY (guint8 * dest, guint8 * src1, guint8 * src2, /* note that src and dest are guint16, and thus endian dependent */ #define RGB565_R(x) (((x)&0xf800)>>8 | ((x)&0xf800)>>13) #define RGB565_G(x) (((x)&0x07e0)>>3 | ((x)&0x07e0)>>9) #define RGB565_B(x) (((x)&0x001f)<<3 | ((x)&0x001f)>>2) #define RGB565(r,g,b) \ ((((r)<<8)&0xf800) | (((g)<<3)&0x07e0) | (((b)>>3)&0x001f)) vs_scanline_downsample_RGB565 (guint8 * dest_u8, guint8 * src_u8, int n) guint16 *dest = (guint16 *) dest_u8; guint16 *src = (guint16 *) src_u8; dest[i] = RGB565 ( (RGB565_R (src[i * 2]) + RGB565_R (src[i * 2 + 1])) / 2, (RGB565_G (src[i * 2]) + RGB565_G (src[i * 2 + 1])) / 2, (RGB565_B (src[i * 2]) + RGB565_B (src[i * 2 + 1])) / 2); vs_scanline_resample_nearest_RGB565 (guint8 * dest_u8, guint8 * src_u8, int n, vs_scanline_resample_linear_RGB565 (guint8 * dest_u8, guint8 * src_u8, int n, (RGB565_R (src[j]) * (65536 - x) + RGB565_R (src[j + 1]) * x) >> 16, (RGB565_G (src[j]) * (65536 - x) + RGB565_G (src[j + 1]) * x) >> 16, (RGB565_B (src[j]) * (65536 - x) + RGB565_B (src[j + 1]) * x) >> 16); vs_scanline_merge_linear_RGB565 (guint8 * dest_u8, guint8 * src1_u8, guint8 * src2_u8, int n, int x) guint16 *src1 = (guint16 *) src1_u8; guint16 *src2 = (guint16 *) src2_u8; (RGB565_R (src1[i]) * (65536 - x) + RGB565_R (src2[i]) * x) >> 16, (RGB565_G (src1[i]) * (65536 - x) + RGB565_G (src2[i]) * x) >> 16, (RGB565_B (src1[i]) * (65536 - x) + RGB565_B (src2[i]) * x) >> 16); --- NEW FILE: vs_scanline.h --- #ifndef __VS_SCANLINE_H__ #define __VS_SCANLINE_H__ void vs_scanline_downsample_Y (guint8 *dest, guint8 *src, int n); void vs_scanline_resample_nearest_Y (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_resample_linear_Y (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_Y (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); void vs_scanline_downsample_RGBA (guint8 *dest, guint8 *src, int n); void vs_scanline_resample_nearest_RGBA (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_resample_linear_RGBA (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_RGBA (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); void vs_scanline_downsample_RGB (guint8 *dest, guint8 *src, int n); void vs_scanline_resample_nearest_RGB (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_resample_linear_RGB (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_RGB (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); void vs_scanline_downsample_YUYV (guint8 *dest, guint8 *src, int n); void vs_scanline_resample_nearest_YUYV (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_resample_linear_YUYV (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_YUYV (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); void vs_scanline_downsample_UYVY (guint8 *dest, guint8 *src, int n); void vs_scanline_resample_nearest_UYVY (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_resample_linear_UYVY (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_UYVY (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); void vs_scanline_downsample_RGB565 (guint8 *dest, guint8 *src, int n); void vs_scanline_resample_nearest_RGB565 (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_resample_linear_RGB565 (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_RGB565 (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); |
From: <ds...@fr...> - 2005-06-15 07:43:04
|
CVS Root: /cvs/gstreamer Module: gst-plugins Changes by: ds Date: Wed Jun 15 2005 00:42:54 PDT Branch: BRANCH-GSTREAMER-0_8 Log message: * gst/videoscale/gstvideoscale.c: Add 24-bit and 15-bit RGB * gst/videoscale/vs_image.c: * gst/videoscale/vs_image.h: * gst/videoscale/vs_scanline.c: * gst/videoscale/vs_scanline.h: Modified files: . : ChangeLog gst/videoscale : gstvideoscale.c vs_image.c vs_image.h vs_scanline.c vs_scanline.h Links: http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ChangeLog.diff?r1=1.1641.2.247&r2=1.1641.2.248 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/gstvideoscale.c.diff?r1=1.55.2.4&r2=1.55.2.5 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_image.c.diff?r1=1.1.2.1&r2=1.1.2.2 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_image.h.diff?r1=1.1.2.1&r2=1.1.2.2 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_scanline.c.diff?r1=1.1.2.1&r2=1.1.2.2 http://freedesktop.org/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/videoscale/vs_scanline.h.diff?r1=1.1.2.1&r2=1.1.2.2 ====Begin Diffs==== Index: ChangeLog =================================================================== RCS file: /cvs/gstreamer/gst-plugins/ChangeLog,v retrieving revision 1.1641.2.247 retrieving revision 1.1641.2.248 diff -u -d -r1.1641.2.247 -r1.1641.2.248 --- ChangeLog 14 Jun 2005 22:26:06 -0000 1.1641.2.247 +++ ChangeLog 15 Jun 2005 07:42:42 -0000 1.1641.2.248 @@ -1,3 +1,11 @@ +2005-06-15 David Schleef <ds...@sc...> + + * gst/videoscale/gstvideoscale.c: Add 24-bit and 15-bit RGB + * gst/videoscale/vs_image.c: + * gst/videoscale/vs_image.h: + * gst/videoscale/vs_scanline.c: + * gst/videoscale/vs_scanline.h: 2005-06-15 Martin Soto <mar...@us...> * gst/mpegstream/gstdvddemux.c (gst_dvd_demux_handle_dvd_event): Index: gstvideoscale.c RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/gstvideoscale.c,v retrieving revision 1.55.2.4 retrieving revision 1.55.2.5 diff -u -d -r1.55.2.4 -r1.55.2.5 --- gstvideoscale.c 3 Jun 2005 11:25:45 -0000 1.55.2.4 +++ gstvideoscale.c 15 Jun 2005 07:42:42 -0000 1.55.2.5 @@ -57,6 +57,8 @@ GST_STATIC_CAPS (GST_VIDEO_CAPS_xRGB), GST_STATIC_CAPS (GST_VIDEO_CAPS_BGRx), GST_STATIC_CAPS (GST_VIDEO_CAPS_xBGR), + GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB), + GST_STATIC_CAPS (GST_VIDEO_CAPS_BGR), GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("AYUV")), GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("YUY2")), GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("YVYU")), @@ -64,7 +66,8 @@ GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("Y800")), GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420")), GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("YV12")), - GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB_16) + GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB_16), + GST_STATIC_CAPS (GST_VIDEO_CAPS_RGB_15) }; enum @@ -73,6 +76,8 @@ GST_VIDEOSCALE_xRGB, GST_VIDEOSCALE_BGRx, GST_VIDEOSCALE_xBGR, + GST_VIDEOSCALE_RGB, + GST_VIDEOSCALE_BGR, GST_VIDEOSCALE_AYUV, GST_VIDEOSCALE_YUY2, GST_VIDEOSCALE_YVYU, @@ -80,7 +85,8 @@ GST_VIDEOSCALE_Y, GST_VIDEOSCALE_I420, GST_VIDEOSCALE_YV12, - GST_VIDEOSCALE_RGB565 + GST_VIDEOSCALE_RGB565, + GST_VIDEOSCALE_RGB555 #define GST_TYPE_VIDEOSCALE_METHOD (gst_videoscale_method_get_type()) @@ -618,6 +624,12 @@ dest.stride = videoscale->to_width * 4; size = dest.stride * dest.height; break; + case GST_VIDEOSCALE_RGB: + case GST_VIDEOSCALE_BGR: + src.stride = ROUND_UP_4 (videoscale->from_width * 3); + dest.stride = ROUND_UP_4 (videoscale->to_width * 3); + size = dest.stride * dest.height; + break; case GST_VIDEOSCALE_YUY2: case GST_VIDEOSCALE_YVYU: case GST_VIDEOSCALE_UYVY: @@ -657,6 +669,11 @@ dest.stride = ROUND_UP_4 (videoscale->to_width * 2); + case GST_VIDEOSCALE_RGB555: + src.stride = ROUND_UP_4 (videoscale->from_width * 2); + dest.stride = ROUND_UP_4 (videoscale->to_width * 2); default: g_warning ("don't know how to scale"); gst_buffer_unref (buf); @@ -690,6 +707,10 @@ case GST_VIDEOSCALE_AYUV: vs_image_scale_nearest_RGBA (&dest, &src, tmpbuf); break; + case GST_VIDEOSCALE_RGB: + case GST_VIDEOSCALE_BGR: + vs_image_scale_nearest_RGB (&dest, &src, tmpbuf); + break; case GST_VIDEOSCALE_YUY2: case GST_VIDEOSCALE_YVYU: vs_image_scale_nearest_YUYV (&dest, &src, tmpbuf); @@ -709,6 +730,9 @@ case GST_VIDEOSCALE_RGB565: vs_image_scale_nearest_RGB565 (&dest, &src, tmpbuf); + case GST_VIDEOSCALE_RGB555: + vs_image_scale_nearest_RGB555 (&dest, &src, tmpbuf); default: g_warning ("don't know how to scale"); } @@ -723,6 +747,10 @@ vs_image_scale_linear_RGBA (&dest, &src, tmpbuf); + vs_image_scale_linear_RGB (&dest, &src, tmpbuf); vs_image_scale_linear_YUYV (&dest, &src, tmpbuf); @@ -744,6 +772,9 @@ vs_image_scale_linear_RGB565 (&dest, &src, tmpbuf); + vs_image_scale_linear_RGB555 (&dest, &src, tmpbuf); Index: vs_image.c RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/Attic/vs_image.c,v retrieving revision 1.1.2.1 retrieving revision 1.1.2.2 diff -u -d -r1.1.2.1 -r1.1.2.2 --- vs_image.c 29 May 2005 00:46:49 -0000 1.1.2.1 +++ vs_image.c 15 Jun 2005 07:42:42 -0000 1.1.2.2 @@ -150,6 +150,122 @@ } } +void +vs_image_scale_nearest_RGB (const VSImage * dest, const VSImage * src, + guint8 * tmpbuf) +{ + int acc; + int y_increment; + int x_increment; + int i; + int j; + int x; + int xacc; + y_increment = ((src->height - 1) << 16) / (dest->height - 1); + x_increment = ((src->width - 1) << 16) / (dest->width - 1); + acc = 0; + for (i = 0; i < dest->height; i++) { + j = acc >> 16; + x = acc & 0xffff; + xacc = 0; + vs_scanline_resample_nearest_RGB (dest->pixels + i * dest->stride, + src->pixels + j * src->stride, dest->width, &xacc, x_increment); + acc += y_increment; + } +} +vs_image_scale_linear_RGB (const VSImage * dest, const VSImage * src, + guint8 *tmp1; + guint8 *tmp2; + int y1; + int y2; + int dest_size; + dest_size = dest->width * 3; + tmp1 = tmpbuf; + tmp2 = tmpbuf + dest_size; + xacc = 0; + y2 = -1; + vs_scanline_resample_linear_RGB (tmp1, src->pixels, dest->width, &xacc, + x_increment); + y1 = 0; + if (x == 0) { + if (j == y1) { + memcpy (dest->pixels + i * dest->stride, tmp1, dest_size); + } else if (j == y2) { + memcpy (dest->pixels + i * dest->stride, tmp2, dest_size); + } else { + xacc = 0; + vs_scanline_resample_linear_RGB (tmp1, src->pixels + j * src->stride, + dest->width, &xacc, x_increment); + y1 = j; + } + } else { + if (j + 1 != y2) { + xacc = 0; + vs_scanline_resample_linear_RGB (tmp2, + src->pixels + (j + 1) * src->stride, dest->width, &xacc, + x_increment); + y2 = j + 1; + } + vs_scanline_merge_linear_RGB (dest->pixels + i * dest->stride, + tmp1, tmp2, dest->width, x); + if (j + 1 != y1) { + vs_scanline_resample_linear_RGB (tmp1, + y1 = j + 1; + tmp2, tmp1, dest->width, x); + vs_scanline_resample_linear_RGB (tmp2, + src->pixels + (j + 1) * src->stride, dest->width, &xacc, + x_increment); + y2 = (j + 1); + } /* YUYV */ void @@ -619,3 +735,120 @@ acc += y_increment; +/* RGB555 */ +vs_image_scale_nearest_RGB555 (const VSImage * dest, const VSImage * src, + vs_scanline_resample_nearest_RGB555 (dest->pixels + i * dest->stride, +vs_image_scale_linear_RGB555 (const VSImage * dest, const VSImage * src, + dest_size = dest->width * 2; + vs_scanline_resample_linear_RGB555 (tmp1, src->pixels, dest->width, &xacc, + vs_scanline_resample_linear_RGB555 (tmp1, src->pixels + j * src->stride, + vs_scanline_resample_linear_RGB555 (tmp2, + vs_scanline_merge_linear_RGB555 (dest->pixels + i * dest->stride, + vs_scanline_resample_linear_RGB555 (tmp1, + vs_scanline_resample_linear_RGB555 (tmp2, Index: vs_image.h RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/Attic/vs_image.h,v --- vs_image.h 29 May 2005 00:46:49 -0000 1.1.2.1 +++ vs_image.h 15 Jun 2005 07:42:42 -0000 1.1.2.2 @@ -46,6 +46,11 @@ void vs_image_scale_linear_RGBA (const VSImage *dest, const VSImage *src, guint8 *tmpbuf); +void vs_image_scale_nearest_RGB (const VSImage *dest, const VSImage *src, + guint8 *tmpbuf); +void vs_image_scale_linear_RGB (const VSImage *dest, const VSImage *src, void vs_image_scale_nearest_YUYV (const VSImage *dest, const VSImage *src, void vs_image_scale_linear_YUYV (const VSImage *dest, const VSImage *src, @@ -66,6 +71,11 @@ void vs_image_scale_linear_RGB565 (const VSImage *dest, const VSImage *src, +void vs_image_scale_nearest_RGB555 (const VSImage *dest, const VSImage *src, +void vs_image_scale_linear_RGB555 (const VSImage *dest, const VSImage *src, G_END_DECLS #endif Index: vs_scanline.c RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/Attic/vs_scanline.c,v --- vs_scanline.c 29 May 2005 00:46:49 -0000 1.1.2.1 +++ vs_scanline.c 15 Jun 2005 07:42:42 -0000 1.1.2.2 @@ -536,3 +536,95 @@ (RGB565_B (src1[i]) * (65536 - x) + RGB565_B (src2[i]) * x) >> 16); +/* note that src and dest are guint16, and thus endian dependent */ +#define RGB555_R(x) (((x)&0x7c00)>>8 | ((x)&0x7c00)>>13) +#define RGB555_G(x) (((x)&0x03e0)>>3 | ((x)&0x03e0)>>9) +#define RGB555_B(x) (((x)&0x001f)<<3 | ((x)&0x001f)>>2) +#define RGB555(r,g,b) \ + ((((r)<<7)&0x7c00) | (((g)<<3)&0x03e0) | (((b)>>3)&0x001f)) +vs_scanline_downsample_RGB555 (guint8 * dest_u8, guint8 * src_u8, int n) + guint16 *dest = (guint16 *) dest_u8; + guint16 *src = (guint16 *) src_u8; + for (i = 0; i < n; i++) { + dest[i] = RGB555 ( + (RGB555_R (src[i * 2]) + RGB555_R (src[i * 2 + 1])) / 2, + (RGB555_G (src[i * 2]) + RGB555_G (src[i * 2 + 1])) / 2, + (RGB555_B (src[i * 2]) + RGB555_B (src[i * 2 + 1])) / 2); +vs_scanline_resample_nearest_RGB555 (guint8 * dest_u8, guint8 * src_u8, int n, + int *accumulator, int increment) + int acc = *accumulator; + dest[i] = (x < 32768) ? src[j] : src[j + 1]; + acc += increment; + *accumulator = acc; +vs_scanline_resample_linear_RGB555 (guint8 * dest_u8, guint8 * src_u8, int n, + (RGB555_R (src[j]) * (65536 - x) + RGB555_R (src[j + 1]) * x) >> 16, + (RGB555_G (src[j]) * (65536 - x) + RGB555_G (src[j + 1]) * x) >> 16, + (RGB555_B (src[j]) * (65536 - x) + RGB555_B (src[j + 1]) * x) >> 16); +vs_scanline_merge_linear_RGB555 (guint8 * dest_u8, guint8 * src1_u8, + guint8 * src2_u8, int n, int x) + guint16 *src1 = (guint16 *) src1_u8; + guint16 *src2 = (guint16 *) src2_u8; + (RGB555_R (src1[i]) * (65536 - x) + RGB555_R (src2[i]) * x) >> 16, + (RGB555_G (src1[i]) * (65536 - x) + RGB555_G (src2[i]) * x) >> 16, + (RGB555_B (src1[i]) * (65536 - x) + RGB555_B (src2[i]) * x) >> 16); Index: vs_scanline.h RCS file: /cvs/gstreamer/gst-plugins/gst/videoscale/Attic/vs_scanline.h,v --- vs_scanline.h 29 May 2005 00:46:49 -0000 1.1.2.1 +++ vs_scanline.h 15 Jun 2005 07:42:42 -0000 1.1.2.2 @@ -62,6 +62,11 @@ void vs_scanline_resample_linear_RGB565 (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); void vs_scanline_merge_linear_RGB565 (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); +void vs_scanline_downsample_RGB555 (guint8 *dest, guint8 *src, int n); +void vs_scanline_resample_nearest_RGB555 (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); +void vs_scanline_resample_linear_RGB555 (guint8 *dest, guint8 *src, int n, int *accumulator, int increment); +void vs_scanline_merge_linear_RGB555 (guint8 *dest, guint8 *src1, guint8 *src2, int n, int x); |