516 lines
18 KiB
C
516 lines
18 KiB
C
/* bitmap_scale.c - Bitmap scaling. */
|
|
/*
|
|
* VasEBoot -- GRand Unified Bootloader
|
|
* Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc.
|
|
*
|
|
* VasEBoot is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* VasEBoot 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with VasEBoot. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <VasEBoot/mm.h>
|
|
#include <VasEBoot/misc.h>
|
|
#include <VasEBoot/video.h>
|
|
#include <VasEBoot/bitmap.h>
|
|
#include <VasEBoot/bitmap_scale.h>
|
|
#include <VasEBoot/types.h>
|
|
#include <VasEBoot/dl.h>
|
|
|
|
VasEBoot_MOD_LICENSE ("GPLv3+");
|
|
|
|
/* Prototypes for module-local functions. */
|
|
static VasEBoot_err_t scale_nn (struct VasEBoot_video_bitmap *dst,
|
|
struct VasEBoot_video_bitmap *src);
|
|
static VasEBoot_err_t scale_bilinear (struct VasEBoot_video_bitmap *dst,
|
|
struct VasEBoot_video_bitmap *src);
|
|
|
|
static VasEBoot_err_t
|
|
verify_source_bitmap (struct VasEBoot_video_bitmap *src)
|
|
{
|
|
/* Verify the simplifying assumptions. */
|
|
if (src == 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"null src bitmap in VasEBoot_video_bitmap_create_scaled");
|
|
if (src->mode_info.red_field_pos % 8 != 0
|
|
|| src->mode_info.green_field_pos % 8 != 0
|
|
|| src->mode_info.blue_field_pos % 8 != 0
|
|
|| src->mode_info.reserved_field_pos % 8 != 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"src format not supported for scale");
|
|
if (src->mode_info.width == 0 || src->mode_info.height == 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"source bitmap has a zero dimension");
|
|
if (src->mode_info.bytes_per_pixel * 8 != src->mode_info.bpp)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"bitmap to scale has inconsistent Bpp and bpp");
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
|
|
static VasEBoot_err_t
|
|
VasEBoot_video_bitmap_scale (struct VasEBoot_video_bitmap *dst,
|
|
struct VasEBoot_video_bitmap *src,
|
|
enum VasEBoot_video_bitmap_scale_method scale_method)
|
|
{
|
|
switch (scale_method)
|
|
{
|
|
case VasEBoot_VIDEO_BITMAP_SCALE_METHOD_FASTEST:
|
|
case VasEBoot_VIDEO_BITMAP_SCALE_METHOD_NEAREST:
|
|
return scale_nn (dst, src);
|
|
case VasEBoot_VIDEO_BITMAP_SCALE_METHOD_BEST:
|
|
case VasEBoot_VIDEO_BITMAP_SCALE_METHOD_BILINEAR:
|
|
return scale_bilinear (dst, src);
|
|
default:
|
|
return VasEBoot_error (VasEBoot_ERR_BUG, "Invalid scale_method value");
|
|
}
|
|
}
|
|
|
|
/* This function creates a new scaled version of the bitmap SRC. The new
|
|
bitmap has dimensions DST_WIDTH by DST_HEIGHT. The scaling algorithm
|
|
is given by SCALE_METHOD. If an error is encountered, the return code is
|
|
not equal to VasEBoot_ERR_NONE, and the bitmap DST is either not created, or
|
|
it is destroyed before this function returns.
|
|
|
|
Supports only direct color modes which have components separated
|
|
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
|
|
But because of this simplifying assumption, the implementation is
|
|
greatly simplified. */
|
|
VasEBoot_err_t
|
|
VasEBoot_video_bitmap_create_scaled (struct VasEBoot_video_bitmap **dst,
|
|
int dst_width, int dst_height,
|
|
struct VasEBoot_video_bitmap *src,
|
|
enum VasEBoot_video_bitmap_scale_method
|
|
scale_method)
|
|
{
|
|
*dst = 0;
|
|
|
|
VasEBoot_err_t err = verify_source_bitmap(src);
|
|
if (err != VasEBoot_ERR_NONE)
|
|
return err;
|
|
if (dst_width <= 0 || dst_height <= 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"requested to scale to a size w/ a zero dimension");
|
|
|
|
/* Create the new bitmap. */
|
|
VasEBoot_err_t ret;
|
|
ret = VasEBoot_video_bitmap_create (dst, dst_width, dst_height,
|
|
src->mode_info.blit_format);
|
|
if (ret != VasEBoot_ERR_NONE)
|
|
return ret; /* Error. */
|
|
|
|
ret = VasEBoot_video_bitmap_scale (*dst, src, scale_method);
|
|
|
|
if (ret == VasEBoot_ERR_NONE)
|
|
{
|
|
/* Success: *dst is now a pointer to the scaled bitmap. */
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
else
|
|
{
|
|
/* Destroy the bitmap and return the error code. */
|
|
VasEBoot_video_bitmap_destroy (*dst);
|
|
*dst = 0;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
static VasEBoot_err_t
|
|
make_h_align (unsigned *x, unsigned *w, unsigned new_w,
|
|
VasEBoot_video_bitmap_h_align_t h_align)
|
|
{
|
|
VasEBoot_err_t ret = VasEBoot_ERR_NONE;
|
|
if (new_w >= *w)
|
|
{
|
|
*x = 0;
|
|
*w = new_w;
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
switch (h_align)
|
|
{
|
|
case VasEBoot_VIDEO_BITMAP_H_ALIGN_LEFT:
|
|
*x = 0;
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_H_ALIGN_CENTER:
|
|
*x = (*w - new_w) / 2;
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_H_ALIGN_RIGHT:
|
|
*x = *w - new_w;
|
|
break;
|
|
default:
|
|
ret = VasEBoot_error (VasEBoot_ERR_BUG, "Invalid h_align value");
|
|
break;
|
|
}
|
|
*w = new_w;
|
|
return ret;
|
|
}
|
|
|
|
static VasEBoot_err_t
|
|
make_v_align (unsigned *y, unsigned *h, unsigned new_h,
|
|
VasEBoot_video_bitmap_v_align_t v_align)
|
|
{
|
|
VasEBoot_err_t ret = VasEBoot_ERR_NONE;
|
|
if (new_h >= *h)
|
|
{
|
|
*y = 0;
|
|
*h = new_h;
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
switch (v_align)
|
|
{
|
|
case VasEBoot_VIDEO_BITMAP_V_ALIGN_TOP:
|
|
*y = 0;
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_V_ALIGN_CENTER:
|
|
*y = (*h - new_h) / 2;
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_V_ALIGN_BOTTOM:
|
|
*y = *h - new_h;
|
|
break;
|
|
default:
|
|
ret = VasEBoot_error (VasEBoot_ERR_BUG, "Invalid v_align value");
|
|
break;
|
|
}
|
|
*h = new_h;
|
|
return ret;
|
|
}
|
|
|
|
VasEBoot_err_t
|
|
VasEBoot_video_bitmap_scale_proportional (struct VasEBoot_video_bitmap **dst,
|
|
int dst_width, int dst_height,
|
|
struct VasEBoot_video_bitmap *src,
|
|
enum VasEBoot_video_bitmap_scale_method
|
|
scale_method,
|
|
VasEBoot_video_bitmap_selection_method_t
|
|
selection_method,
|
|
VasEBoot_video_bitmap_v_align_t v_align,
|
|
VasEBoot_video_bitmap_h_align_t h_align)
|
|
{
|
|
*dst = 0;
|
|
VasEBoot_err_t ret = verify_source_bitmap(src);
|
|
if (ret != VasEBoot_ERR_NONE)
|
|
return ret;
|
|
if (dst_width <= 0 || dst_height <= 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"requested to scale to a size w/ a zero dimension");
|
|
|
|
ret = VasEBoot_video_bitmap_create (dst, dst_width, dst_height,
|
|
src->mode_info.blit_format);
|
|
if (ret != VasEBoot_ERR_NONE)
|
|
return ret; /* Error. */
|
|
|
|
unsigned dx0 = 0;
|
|
unsigned dy0 = 0;
|
|
unsigned dw = dst_width;
|
|
unsigned dh = dst_height;
|
|
unsigned sx0 = 0;
|
|
unsigned sy0 = 0;
|
|
unsigned sw = src->mode_info.width;
|
|
unsigned sh = src->mode_info.height;
|
|
|
|
switch (selection_method)
|
|
{
|
|
case VasEBoot_VIDEO_BITMAP_SELECTION_METHOD_CROP:
|
|
/* Comparing sw/sh VS dw/dh. */
|
|
if (sw * dh < dw * sh)
|
|
ret = make_v_align (&sy0, &sh, sw * dh / dw, v_align);
|
|
else
|
|
ret = make_h_align (&sx0, &sw, sh * dw / dh, h_align);
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_SELECTION_METHOD_PADDING:
|
|
if (sw * dh < dw * sh)
|
|
ret = make_h_align (&dx0, &dw, sw * dh / sh, h_align);
|
|
else
|
|
ret = make_v_align (&dy0, &dh, sh * dw / sw, v_align);
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_SELECTION_METHOD_FITWIDTH:
|
|
if (sw * dh < dw * sh)
|
|
ret = make_v_align (&sy0, &sh, sw * dh / dw, v_align);
|
|
else
|
|
ret = make_v_align (&dy0, &dh, sh * dw / sw, v_align);
|
|
break;
|
|
case VasEBoot_VIDEO_BITMAP_SELECTION_METHOD_FITHEIGHT:
|
|
if (sw * dh < dw * sh)
|
|
ret = make_h_align (&dx0, &dw, sw * dh / sh, h_align);
|
|
else
|
|
ret = make_h_align (&sx0, &sw, sh * dw / dh, h_align);
|
|
break;
|
|
default:
|
|
ret = VasEBoot_error (VasEBoot_ERR_BUG, "Invalid selection_method value");
|
|
break;
|
|
}
|
|
|
|
if (ret == VasEBoot_ERR_NONE)
|
|
{
|
|
/* Backup original data. */
|
|
int src_width_orig = src->mode_info.width;
|
|
int src_height_orig = src->mode_info.height;
|
|
VasEBoot_uint8_t *src_data_orig = src->data;
|
|
int dst_width_orig = (*dst)->mode_info.width;
|
|
int dst_height_orig = (*dst)->mode_info.height;
|
|
VasEBoot_uint8_t *dst_data_orig = (*dst)->data;
|
|
|
|
int dstride = (*dst)->mode_info.pitch;
|
|
int sstride = src->mode_info.pitch;
|
|
/* bytes_per_pixel is the same for both src and dst. */
|
|
int bytes_per_pixel = src->mode_info.bytes_per_pixel;
|
|
|
|
/* Crop src and dst. */
|
|
src->mode_info.width = sw;
|
|
src->mode_info.height = sh;
|
|
src->data = (VasEBoot_uint8_t *) src->data + sx0 * bytes_per_pixel
|
|
+ sy0 * sstride;
|
|
(*dst)->mode_info.width = dw;
|
|
(*dst)->mode_info.height = dh;
|
|
(*dst)->data = (VasEBoot_uint8_t *) (*dst)->data + dx0 * bytes_per_pixel
|
|
+ dy0 * dstride;
|
|
|
|
/* Scale our image. */
|
|
ret = VasEBoot_video_bitmap_scale (*dst, src, scale_method);
|
|
|
|
/* Restore original data. */
|
|
src->mode_info.width = src_width_orig;
|
|
src->mode_info.height = src_height_orig;
|
|
src->data = src_data_orig;
|
|
(*dst)->mode_info.width = dst_width_orig;
|
|
(*dst)->mode_info.height = dst_height_orig;
|
|
(*dst)->data = dst_data_orig;
|
|
}
|
|
|
|
if (ret == VasEBoot_ERR_NONE)
|
|
{
|
|
/* Success: *dst is now a pointer to the scaled bitmap. */
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
else
|
|
{
|
|
/* Destroy the bitmap and return the error code. */
|
|
VasEBoot_video_bitmap_destroy (*dst);
|
|
*dst = 0;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
static VasEBoot_err_t
|
|
verify_bitmaps (struct VasEBoot_video_bitmap *dst, struct VasEBoot_video_bitmap *src)
|
|
{
|
|
/* Verify the simplifying assumptions. */
|
|
if (dst == 0 || src == 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG, "null bitmap in scale function");
|
|
if (dst->mode_info.red_field_pos % 8 != 0
|
|
|| dst->mode_info.green_field_pos % 8 != 0
|
|
|| dst->mode_info.blue_field_pos % 8 != 0
|
|
|| dst->mode_info.reserved_field_pos % 8 != 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"dst format not supported");
|
|
if (src->mode_info.red_field_pos % 8 != 0
|
|
|| src->mode_info.green_field_pos % 8 != 0
|
|
|| src->mode_info.blue_field_pos % 8 != 0
|
|
|| src->mode_info.reserved_field_pos % 8 != 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"src format not supported");
|
|
if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos
|
|
|| dst->mode_info.red_mask_size != src->mode_info.red_mask_size
|
|
|| dst->mode_info.green_field_pos != src->mode_info.green_field_pos
|
|
|| dst->mode_info.green_mask_size != src->mode_info.green_mask_size
|
|
|| dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos
|
|
|| dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size
|
|
|| dst->mode_info.reserved_field_pos !=
|
|
src->mode_info.reserved_field_pos
|
|
|| dst->mode_info.reserved_mask_size !=
|
|
src->mode_info.reserved_mask_size)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG,
|
|
"dst and src not compatible");
|
|
if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel)
|
|
return VasEBoot_error (VasEBoot_ERR_NOT_IMPLEMENTED_YET,
|
|
"dst and src not compatible");
|
|
if (dst->mode_info.width == 0 || dst->mode_info.height == 0
|
|
|| src->mode_info.width == 0 || src->mode_info.height == 0)
|
|
return VasEBoot_error (VasEBoot_ERR_BUG, "bitmap has a zero dimension");
|
|
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
|
|
/* Nearest neighbor bitmap scaling algorithm.
|
|
|
|
Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the
|
|
dimensions of DST. This function uses the nearest neighbor algorithm to
|
|
interpolate the pixels.
|
|
|
|
Supports only direct color modes which have components separated
|
|
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
|
|
But because of this simplifying assumption, the implementation is
|
|
greatly simplified. */
|
|
static VasEBoot_err_t
|
|
scale_nn (struct VasEBoot_video_bitmap *dst, struct VasEBoot_video_bitmap *src)
|
|
{
|
|
VasEBoot_err_t err = verify_bitmaps(dst, src);
|
|
if (err != VasEBoot_ERR_NONE)
|
|
return err;
|
|
|
|
VasEBoot_uint8_t *ddata = dst->data;
|
|
VasEBoot_uint8_t *sdata = src->data;
|
|
unsigned dw = dst->mode_info.width;
|
|
unsigned dh = dst->mode_info.height;
|
|
unsigned sw = src->mode_info.width;
|
|
unsigned sh = src->mode_info.height;
|
|
int dstride = dst->mode_info.pitch;
|
|
int sstride = src->mode_info.pitch;
|
|
/* bytes_per_pixel is the same for both src and dst. */
|
|
int bytes_per_pixel = dst->mode_info.bytes_per_pixel;
|
|
unsigned dy, sy, ystep, yfrac, yover;
|
|
unsigned sx, xstep, xfrac, xover;
|
|
VasEBoot_uint8_t *dptr, *dline_end, *sline;
|
|
|
|
xstep = sw / dw;
|
|
xover = sw % dw;
|
|
ystep = sh / dh;
|
|
yover = sh % dh;
|
|
|
|
for (dy = 0, sy = 0, yfrac = 0; dy < dh; dy++, sy += ystep, yfrac += yover)
|
|
{
|
|
if (yfrac >= dh)
|
|
{
|
|
yfrac -= dh;
|
|
sy++;
|
|
}
|
|
dptr = ddata + dy * dstride;
|
|
dline_end = dptr + dw * bytes_per_pixel;
|
|
sline = sdata + sy * sstride;
|
|
for (sx = 0, xfrac = 0; dptr < dline_end; sx += xstep, xfrac += xover, dptr += bytes_per_pixel)
|
|
{
|
|
VasEBoot_uint8_t *sptr;
|
|
int comp;
|
|
|
|
if (xfrac >= dw)
|
|
{
|
|
xfrac -= dw;
|
|
sx++;
|
|
}
|
|
|
|
/* Get the address of the pixels in src and dst. */
|
|
sptr = sline + sx * bytes_per_pixel;
|
|
|
|
/* Copy the pixel color value. */
|
|
for (comp = 0; comp < bytes_per_pixel; comp++)
|
|
dptr[comp] = sptr[comp];
|
|
}
|
|
}
|
|
return VasEBoot_ERR_NONE;
|
|
}
|
|
|
|
/* Bilinear interpolation image scaling algorithm.
|
|
|
|
Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the
|
|
dimensions of DST. This function uses the bilinear interpolation algorithm
|
|
to interpolate the pixels.
|
|
|
|
Supports only direct color modes which have components separated
|
|
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
|
|
But because of this simplifying assumption, the implementation is
|
|
greatly simplified. */
|
|
static VasEBoot_err_t
|
|
scale_bilinear (struct VasEBoot_video_bitmap *dst, struct VasEBoot_video_bitmap *src)
|
|
{
|
|
VasEBoot_err_t err = verify_bitmaps(dst, src);
|
|
if (err != VasEBoot_ERR_NONE)
|
|
return err;
|
|
|
|
VasEBoot_uint8_t *ddata = dst->data;
|
|
VasEBoot_uint8_t *sdata = src->data;
|
|
unsigned dw = dst->mode_info.width;
|
|
unsigned dh = dst->mode_info.height;
|
|
unsigned sw = src->mode_info.width;
|
|
unsigned sh = src->mode_info.height;
|
|
int dstride = dst->mode_info.pitch;
|
|
int sstride = src->mode_info.pitch;
|
|
/* bytes_per_pixel is the same for both src and dst. */
|
|
int bytes_per_pixel = dst->mode_info.bytes_per_pixel;
|
|
unsigned dy, syf, sy, ystep, yfrac, yover;
|
|
unsigned sxf, sx, xstep, xfrac, xover;
|
|
VasEBoot_uint8_t *dptr, *dline_end, *sline;
|
|
|
|
xstep = (sw << 8) / dw;
|
|
xover = (sw << 8) % dw;
|
|
ystep = (sh << 8) / dh;
|
|
yover = (sh << 8) % dh;
|
|
|
|
for (dy = 0, syf = 0, yfrac = 0; dy < dh; dy++, syf += ystep, yfrac += yover)
|
|
{
|
|
if (yfrac >= dh)
|
|
{
|
|
yfrac -= dh;
|
|
syf++;
|
|
}
|
|
sy = syf >> 8;
|
|
dptr = ddata + dy * dstride;
|
|
dline_end = dptr + dw * bytes_per_pixel;
|
|
sline = sdata + sy * sstride;
|
|
for (sxf = 0, xfrac = 0; dptr < dline_end; sxf += xstep, xfrac += xover, dptr += bytes_per_pixel)
|
|
{
|
|
VasEBoot_uint8_t *sptr;
|
|
int comp;
|
|
|
|
if (xfrac >= dw)
|
|
{
|
|
xfrac -= dw;
|
|
sxf++;
|
|
}
|
|
|
|
/* Get the address of the pixels in src and dst. */
|
|
sx = sxf >> 8;
|
|
sptr = sline + sx * bytes_per_pixel;
|
|
|
|
/* If we have enough space to do so, use bilinear interpolation.
|
|
Otherwise, fall back to nearest neighbor for this pixel. */
|
|
if (sx < sw - 1 && sy < sh - 1)
|
|
{
|
|
/* Do bilinear interpolation. */
|
|
|
|
/* Fixed-point .8 numbers representing the fraction of the
|
|
distance in the x (u) and y (v) direction within the
|
|
box of 4 pixels in the source. */
|
|
unsigned u = sxf & 0xff;
|
|
unsigned v = syf & 0xff;
|
|
|
|
for (comp = 0; comp < bytes_per_pixel; comp++)
|
|
{
|
|
/* Get the component's values for the
|
|
four source corner pixels. */
|
|
unsigned f00 = sptr[comp];
|
|
unsigned f10 = sptr[comp + bytes_per_pixel];
|
|
unsigned f01 = sptr[comp + sstride];
|
|
unsigned f11 = sptr[comp + sstride + bytes_per_pixel];
|
|
|
|
/* Count coeffecients. */
|
|
unsigned c00 = (256 - u) * (256 - v);
|
|
unsigned c10 = u * (256 - v);
|
|
unsigned c01 = (256 - u) * v;
|
|
unsigned c11 = u * v;
|
|
|
|
/* Interpolate. */
|
|
unsigned fxy = c00 * f00 + c01 * f01 + c10 * f10 + c11 * f11;
|
|
fxy = fxy >> 16;
|
|
|
|
dptr[comp] = fxy;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Fall back to nearest neighbor interpolation. */
|
|
/* Copy the pixel color value. */
|
|
for (comp = 0; comp < bytes_per_pixel; comp++)
|
|
dptr[comp] = sptr[comp];
|
|
}
|
|
}
|
|
}
|
|
return VasEBoot_ERR_NONE;
|
|
}
|