Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Commit FS#8308 (Port of imlib2 based smooth scaling) by Jonas Hurrelmann. It could be made smaller by taking out some special cases, but I'm leaving them in for now because size isn't really a concern until we decide to move it into the core (if we ever do). test_resize now allows to choose between both resize methods for comparison. sliding_puzzle is made to use the smooth scaling.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@17001 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Nicolas Pennequin 2008-04-06 22:30:50 +00:00
parent 9ba80c9641
commit 6aa36c66a3
5 changed files with 492 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
apps/plugins/lib/SOURCES
View file

@ -32,6 +32,7 @@ xlcd_draw.c
xlcd_scroll.c
#if LCD_DEPTH>1
bmp.c
bmp_smooth_scale.c
#endif
#endif
pluginlib_actions.c

6
apps/plugins/lib/bmp.h
View file

@ -35,4 +35,10 @@ int save_bmp_file( char* filename, struct bitmap *bm, struct plugin_api* rb );
*/
void simple_resize_bitmap(struct bitmap *src, struct bitmap *dst);
/**
Advanced image scale from src to dst (bilinear) based on imlib2.
Source and destination dimensions are read from the struct bitmap.
*/
void smooth_resize_bitmap(struct bitmap *src, struct bitmap *dst);
#endif

444
apps/plugins/lib/bmp_smooth_scale.c Normal file
View file

@ -0,0 +1,444 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Code for the scaling algorithm:
* Imlib2 is (C) Carsten Haitzler and various contributors. The MMX code
* is by Willem Monsuwe <willem@stack.nl>. Additional modifications are by
* (C) Daniel M. Duley.
*
* Port to Rockbox
* Copyright (C) 2007 Jonas Hurrelmann (j@outpo.st)
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/*
* Copyright (C) 2004, 2005 Daniel M. Duley
*
* 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.
*
*/
/* OTHER CREDITS:
*
* This is the normal smoothscale method, based on Imlib2's smoothscale.
*
* Originally I took the algorithm used in NetPBM and Qt and added MMX/3dnow
* optimizations. It ran in about 1/2 the time as Qt. Then I ported Imlib's
* C algorithm and it ran at about the same speed as my MMX optimized one...
* Finally I ported Imlib's MMX version and it ran in less than half the
* time as my MMX algorithm, (taking only a quarter of the time Qt does).
* After further optimization it seems to run at around 1/6th.
*
* Changes include formatting, namespaces and other C++'ings, removal of old
* #ifdef'ed code, and removal of unneeded border calculation code.
*
* Imlib2 is (C) Carsten Haitzler and various contributors. The MMX code
* is by Willem Monsuwe <willem@stack.nl>. All other modifications are
* (C) Daniel M. Duley.
*/
#include "bmp.h"
#include "lcd.h"
void smooth_resize_bitmap(struct bitmap *src_bmp, struct bitmap *dest_bmp)
{
fb_data *sptr, *dptr;
int x, y, end;
int val_y = 0, val_x;
const int sw = src_bmp->width;
const int sh = src_bmp->height;
const int dw = dest_bmp->width;
const int dh = dest_bmp->height;
const int inc_x = (sw << 16) / dw;
const int inc_y = (sh << 16) / dh;
const int Cp_x = ((dw << 14) / sw) + 1;
const int Cp_y = ((dh << 14) / sh) + 1;
const int xup_yup = (dw >= sw) + ((dh >= sh) << 1);
const int dow = dw;
const int sow = sw;
fb_data *src = (fb_data*)src_bmp->data;
fb_data *dest = (fb_data*)dest_bmp->data;
int XAP, YAP, INV_YAP, INV_XAP;
int xpoint;
fb_data *ypoint;
end = dw;
/* scaling up both ways */
if (xup_yup == 3) {
/* go through every scanline in the output buffer */
for (y = 0; y < dh; y++) {
/* calculate the source line we'll scan from */
ypoint = src + ((val_y >> 16) * sw);
YAP = ((val_y >> 16) >= (sh - 1)) ? 0 : (val_y >> 8) - ((val_y >> 8) & 0xffffff00);
INV_YAP = 256 - YAP;
val_y += inc_y;
val_x = 0;
dptr = dest + (y * dow);
sptr = ypoint;
if (YAP > 0) {
for (x = 0; x < end; x++) {
int r = 0, g = 0, b = 0;
int rr = 0, gg = 0, bb = 0;
fb_data *pix;
xpoint = (val_x >> 16);
XAP = ((val_x >> 16) >= (sw - 1)) ? 0 : (val_x >> 8) - ((val_x >> 8) & 0xffffff00);
INV_XAP = 256 - XAP;
val_x += inc_x;
if (XAP > 0) {
pix = ypoint + xpoint;
r = RGB_UNPACK_RED(*pix) * INV_XAP;
g = RGB_UNPACK_GREEN(*pix) * INV_XAP;
b = RGB_UNPACK_BLUE(*pix) * INV_XAP;
pix++;
r += RGB_UNPACK_RED(*pix) * XAP;
g += RGB_UNPACK_GREEN(*pix) * XAP;
b += RGB_UNPACK_BLUE(*pix) * XAP;
pix += sow;
rr = RGB_UNPACK_RED(*pix) * XAP;
gg = RGB_UNPACK_GREEN(*pix) * XAP;
bb = RGB_UNPACK_BLUE(*pix) * XAP;
pix--;
rr += RGB_UNPACK_RED(*pix) * INV_XAP;
gg += RGB_UNPACK_GREEN(*pix) * INV_XAP;
bb += RGB_UNPACK_BLUE(*pix) * INV_XAP;
r = ((rr * YAP) + (r * INV_YAP)) >> 16;
g = ((gg * YAP) + (g * INV_YAP)) >> 16;
b = ((bb * YAP) + (b * INV_YAP)) >> 16;
*dptr++ = LCD_RGBPACK(r, g, b);
} else {
pix = ypoint + xpoint;
r = RGB_UNPACK_RED(*pix) * INV_YAP;
g = RGB_UNPACK_GREEN(*pix) * INV_YAP;
b = RGB_UNPACK_BLUE(*pix) * INV_YAP;
pix += sow;
r += RGB_UNPACK_RED(*pix) * YAP;
g += RGB_UNPACK_GREEN(*pix) * YAP;
b += RGB_UNPACK_BLUE(*pix) * YAP;
r >>= 8;
g >>= 8;
b >>= 8;
*dptr++ = LCD_RGBPACK(r, g, b);
}
}
} else {
for (x = 0; x < end; x++) {
int r = 0, g = 0, b = 0;
fb_data *pix;
xpoint = (val_x >> 16);
XAP = ((val_x >> 16) >= (sw - 1)) ? 0 : (val_x >> 8) - ((val_x >> 8) & 0xffffff00);
INV_XAP = 256 - XAP;
val_x += inc_x;
if (XAP > 0) {
pix = ypoint + xpoint;
r = RGB_UNPACK_RED(*pix) * INV_XAP;
g = RGB_UNPACK_GREEN(*pix) * INV_XAP;
b = RGB_UNPACK_BLUE(*pix) * INV_XAP;
pix++;
r += RGB_UNPACK_RED(*pix) * XAP;
g += RGB_UNPACK_GREEN(*pix) * XAP;
b += RGB_UNPACK_BLUE(*pix) * XAP;
r >>= 8;
g >>= 8;
b >>= 8;
*dptr++ = LCD_RGBPACK(r, g, b);
} else
*dptr++ = sptr[xpoint];
}
}
}
}
/* if we're scaling down vertically */
else if (xup_yup == 1) {
/*\ 'Correct' version, with math units prepared for MMXification \ */
int Cy, j;
fb_data *pix;
int r, g, b, rr, gg, bb;
int yap;
/* go through every scanline in the output buffer */
for (y = 0; y < dh; y++) {
ypoint = src + ((val_y >> 16) * sw);
YAP = (((0x100 - ((val_y >> 8) & 0xff)) * Cp_y) >> 8) | (Cp_y << 16);
INV_YAP = 256 - YAP;
val_y += inc_y;
val_x = 0;
Cy = YAP >> 16;
yap = YAP & 0xffff;
dptr = dest + (y * dow);
for (x = 0; x < end; x++) {
xpoint = (val_x >> 16);
XAP = ((val_x >> 16) >= (sw - 1)) ? 0 : (val_x >> 8) - ((val_x >> 8) & 0xffffff00);
INV_XAP = 256 - XAP;
val_x += inc_x;
pix = ypoint + xpoint;
r = (RGB_UNPACK_RED(*pix) * yap) >> 10;
g = (RGB_UNPACK_GREEN(*pix) * yap) >> 10;
b = (RGB_UNPACK_BLUE(*pix) * yap) >> 10;
pix += sow;
for (j = (1 << 14) - yap; j > Cy; j -= Cy) {
r += (RGB_UNPACK_RED(*pix) * Cy) >> 10;
g += (RGB_UNPACK_GREEN(*pix) * Cy) >> 10;
b += (RGB_UNPACK_BLUE(*pix) * Cy) >> 10;
pix += sow;
}
if (j > 0) {
r += (RGB_UNPACK_RED(*pix) * j) >> 10;
g += (RGB_UNPACK_GREEN(*pix) * j) >> 10;
b += (RGB_UNPACK_BLUE(*pix) * j) >> 10;
}
if (XAP > 0) {
pix = ypoint + xpoint + 1;
rr = (RGB_UNPACK_RED(*pix) * yap) >> 10;
gg = (RGB_UNPACK_GREEN(*pix) * yap) >> 10;
bb = (RGB_UNPACK_BLUE(*pix) * yap) >> 10;
pix += sow;
for (j = (1 << 14) - yap; j > Cy; j -= Cy) {
rr += (RGB_UNPACK_RED(*pix) * Cy) >> 10;
gg += (RGB_UNPACK_GREEN(*pix) * Cy) >> 10;
bb += (RGB_UNPACK_BLUE(*pix) * Cy) >> 10;
pix += sow;
}
if (j > 0) {
rr += (RGB_UNPACK_RED(*pix) * j) >> 10;
gg += (RGB_UNPACK_GREEN(*pix) * j) >> 10;
bb += (RGB_UNPACK_BLUE(*pix) * j) >> 10;
}
r = r * INV_XAP;
g = g * INV_XAP;
b = b * INV_XAP;
r = (r + ((rr * XAP))) >> 12;
g = (g + ((gg * XAP))) >> 12;
b = (b + ((bb * XAP))) >> 12;
} else {
r >>= 4;
g >>= 4;
b >>= 4;
}
*dptr = LCD_RGBPACK(r, g, b);
dptr++;
}
}
}
/* if we're scaling down horizontally */
else if (xup_yup == 2) {
/*\ 'Correct' version, with math units prepared for MMXification \ */
int Cx, j;
fb_data *pix;
int r, g, b, rr, gg, bb;
int xap;
/* go through every scanline in the output buffer */
for (y = 0; y < dh; y++) {
ypoint = src + ((val_y >> 16) * sw);
YAP = ((val_y >> 16) >= (sh - 1)) ? 0 : (val_y >> 8) - ((val_y >> 8) & 0xffffff00);
INV_YAP = 256 - YAP;
val_y += inc_y;
val_x = 0;
dptr = dest + (y * dow);
for (x = 0; x < end; x++) {
xpoint = (val_x >> 16);
XAP = (((0x100 - ((val_x >> 8) & 0xff)) * Cp_x) >> 8) | (Cp_x << 16);
INV_XAP = 256 - XAP;
val_x += inc_x;
Cx = XAP >> 16;
xap = XAP & 0xffff;
pix = ypoint + xpoint;
r = (RGB_UNPACK_RED(*pix) * xap) >> 10;
g = (RGB_UNPACK_GREEN(*pix) * xap) >> 10;
b = (RGB_UNPACK_BLUE(*pix) * xap) >> 10;
pix++;
for (j = (1 << 14) - xap; j > Cx; j -= Cx) {
r += (RGB_UNPACK_RED(*pix) * Cx) >> 10;
g += (RGB_UNPACK_GREEN(*pix) * Cx) >> 10;
b += (RGB_UNPACK_BLUE(*pix) * Cx) >> 10;
pix++;
}
if (j > 0) {
r += (RGB_UNPACK_RED(*pix) * j) >> 10;
g += (RGB_UNPACK_GREEN(*pix) * j) >> 10;
b += (RGB_UNPACK_BLUE(*pix) * j) >> 10;
}
if (YAP > 0) {
pix = ypoint + xpoint + sow;
rr = (RGB_UNPACK_RED(*pix) * xap) >> 10;
gg = (RGB_UNPACK_GREEN(*pix) * xap) >> 10;
bb = (RGB_UNPACK_BLUE(*pix) * xap) >> 10;
pix++;
for (j = (1 << 14) - xap; j > Cx; j -= Cx) {
rr += (RGB_UNPACK_RED(*pix) * Cx) >> 10;
gg += (RGB_UNPACK_GREEN(*pix) * Cx) >> 10;
bb += (RGB_UNPACK_BLUE(*pix) * Cx) >> 10;
pix++;
}
if (j > 0) {
rr += (RGB_UNPACK_RED(*pix) * j) >> 10;
gg += (RGB_UNPACK_GREEN(*pix) * j) >> 10;
bb += (RGB_UNPACK_BLUE(*pix) * j) >> 10;
}
r = r * INV_YAP;
g = g * INV_YAP;
b = b * INV_YAP;
r = (r + ((rr * YAP))) >> 12;
g = (g + ((gg * YAP))) >> 12;
b = (b + ((bb * YAP))) >> 12;
} else {
r >>= 4;
g >>= 4;
b >>= 4;
}
*dptr = LCD_RGBPACK(r, g, b);
dptr++;
}
}
}
/* fully optimized (i think) - only change of algorithm can help */
/* if we're scaling down horizontally & vertically */
else {
/*\ 'Correct' version, with math units prepared for MMXification \ */
int Cx, Cy, i, j;
fb_data *pix;
int r, g, b, rx, gx, bx;
int xap, yap;
for (y = 0; y < dh; y++) {
ypoint = src + ((val_y >> 16) * sw);
YAP = (((0x100 - ((val_y >> 8) & 0xff)) * Cp_y) >> 8) | (Cp_y << 16);
INV_YAP = 256 - YAP;
val_y += inc_y;
val_x = 0;
Cy = YAP >> 16;
yap = YAP & 0xffff;
dptr = dest + (y * dow);
for (x = 0; x < end; x++) {
xpoint = (val_x >> 16);
XAP = (((0x100 - ((val_x >> 8) & 0xff)) * Cp_x) >> 8) | (Cp_x << 16);
INV_XAP = 256 - XAP;
val_x += inc_x;
Cx = XAP >> 16;
xap = XAP & 0xffff;
sptr = ypoint + xpoint;
pix = sptr;
sptr += sow;
rx = (RGB_UNPACK_RED(*pix) * xap) >> 9;
gx = (RGB_UNPACK_GREEN(*pix) * xap) >> 9;
bx = (RGB_UNPACK_BLUE(*pix) * xap) >> 9;
pix++;
for (i = (1 << 14) - xap; i > Cx; i -= Cx) {
rx += (RGB_UNPACK_RED(*pix) * Cx) >> 9;
gx += (RGB_UNPACK_GREEN(*pix) * Cx) >> 9;
bx += (RGB_UNPACK_BLUE(*pix) * Cx) >> 9;
pix++;
}
if (i > 0) {
rx += (RGB_UNPACK_RED(*pix) * i) >> 9;
gx += (RGB_UNPACK_GREEN(*pix) * i) >> 9;
bx += (RGB_UNPACK_BLUE(*pix) * i) >> 9;
}
r = (rx * yap) >> 14;
g = (gx * yap) >> 14;
b = (bx * yap) >> 14;
for (j = (1 << 14) - yap; j > Cy; j -= Cy) {
pix = sptr;
sptr += sow;
rx = (RGB_UNPACK_RED(*pix) * xap) >> 9;
gx = (RGB_UNPACK_GREEN(*pix) * xap) >> 9;
bx = (RGB_UNPACK_BLUE(*pix) * xap) >> 9;
pix++;
for (i = (1 << 14) - xap; i > Cx; i -= Cx) {
rx += (RGB_UNPACK_RED(*pix) * Cx) >> 9;
gx += (RGB_UNPACK_GREEN(*pix) * Cx) >> 9;
bx += (RGB_UNPACK_BLUE(*pix) * Cx) >> 9;
pix++;
}
if (i > 0) {
rx += (RGB_UNPACK_RED(*pix) * i) >> 9;
gx += (RGB_UNPACK_GREEN(*pix) * i) >> 9;
bx += (RGB_UNPACK_BLUE(*pix) * i) >> 9;
}
r += (rx * Cy) >> 14;
g += (gx * Cy) >> 14;
b += (bx * Cy) >> 14;
}
if (j > 0) {
pix = sptr;
sptr += sow;
rx = (RGB_UNPACK_RED(*pix) * xap) >> 9;
gx = (RGB_UNPACK_GREEN(*pix) * xap) >> 9;
bx = (RGB_UNPACK_BLUE(*pix) * xap) >> 9;
pix++;
for (i = (1 << 14) - xap; i > Cx; i -= Cx) {
rx += (RGB_UNPACK_RED(*pix) * Cx) >> 9;
gx += (RGB_UNPACK_GREEN(*pix) * Cx) >> 9;
bx += (RGB_UNPACK_BLUE(*pix) * Cx) >> 9;
pix++;
}
if (i > 0) {
rx += (RGB_UNPACK_RED(*pix) * i) >> 9;
gx += (RGB_UNPACK_GREEN(*pix) * i) >> 9;
bx += (RGB_UNPACK_BLUE(*pix) * i) >> 9;
}
r += (rx * j) >> 14;
g += (gx * j) >> 14;
b += (bx * j) >> 14;
}
*dptr = LCD_RGBPACK(r >> 5, g >> 5, b >> 5);
dptr++;
}
}
}
}

2
apps/plugins/sliding_puzzle.c
View file

@ -295,7 +295,7 @@ static bool load_resize_bitmap(void)
FORMAT_NATIVE );
if( rc > 0 )
{
simple_resize_bitmap( &temp_bitmap, &main_bitmap );
smooth_resize_bitmap( &temp_bitmap, &main_bitmap );
puzzle_bmp_ptr = (const fb_data *)img_buf;
rb->strcpy( img_buf_path, filename );
return true;

57
apps/plugins/test_resize.c
View file

@ -36,31 +36,28 @@ const struct button_mapping *plugin_contexts[]
#define NB_ACTION_CONTEXTS sizeof(plugin_contexts)/sizeof(plugin_contexts[0])
/* Key assignement */
#if (CONFIG_KEYPAD == IPOD_1G2G_PAD) \
|| (CONFIG_KEYPAD == IPOD_3G_PAD) \
|| (CONFIG_KEYPAD == IPOD_4G_PAD) \
|| (CONFIG_KEYPAD == SANSA_E200_PAD)
#define SIZE_INCREASE PLA_UP
#define SIZE_INCREASE_REPEAT PLA_UP_REPEAT
#define SIZE_DECREASE PLA_DOWN
#define SIZE_DECREASE_REPEAT PLA_DOWN_REPEAT
#else
#define SIZE_INCREASE PLA_RIGHT
#define SIZE_INCREASE_REPEAT PLA_RIGHT_REPEAT
#define SIZE_DECREASE PLA_LEFT
#define SIZE_DECREASE_REPEAT PLA_LEFT_REPEAT
#endif
#define BUTTON_QUIT PLA_QUIT
#define MAX_OUTPUT_WIDTH 200
#define MAX_OUTPUT_HEIGHT 200
#define WIDTH_INCREASE PLA_RIGHT
#define WIDTH_INCREASE_REPEAT PLA_RIGHT_REPEAT
#define WIDTH_DECREASE PLA_LEFT
#define WIDTH_DECREASE_REPEAT PLA_LEFT_REPEAT
#define BUTTON_QUIT PLA_QUIT
#define CHANGE_MODE PLA_MENU
#define MAX_OUTPUT_WIDTH LCD_WIDTH
#define MAX_OUTPUT_HEIGHT LCD_HEIGHT
static fb_data *b;
static struct bitmap input_bmp;
static struct bitmap output_bmp;
static fb_data input_bmp_data[100*100];
static fb_data input_bmp_data[200*200];
static fb_data output_bmp_data[MAX_OUTPUT_WIDTH*MAX_OUTPUT_HEIGHT];
@ -93,11 +90,22 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
DEBUGF("input_bmp_data starts at %p\n", input_bmp_data);
DEBUGF("output_bmp_data starts at %p\n", output_bmp_data);
int scale_algorithm = 0;
while(1) {
rb->lcd_clear_display();
rb->lcd_bitmap(input_bmp_data, 0, 0, input_bmp.width, input_bmp.height);
simple_resize_bitmap(&input_bmp, &output_bmp);
switch ( scale_algorithm ) {
case 0:
smooth_resize_bitmap(&input_bmp, &output_bmp);
rb->lcd_putsxy(0,0,"smooth_resize_bitmap");
break;
case 1:
simple_resize_bitmap(&input_bmp, &output_bmp);
rb->lcd_putsxy(0,0,"simple_resize_bitmap");
break;
}
rb->lcd_bitmap(output_bmp_data, 0, 100, output_bmp.width,
output_bmp.height);
@ -118,8 +126,23 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
case SIZE_DECREASE:
case SIZE_DECREASE_REPEAT:
if (output_bmp.width >= 2) output_bmp.width -= 2;
if (output_bmp.height >= 2) output_bmp.height -= 2;
if (output_bmp.width > 2) output_bmp.width -= 2;
if (output_bmp.height > 2) output_bmp.height -= 2;
break;
case WIDTH_INCREASE:
case WIDTH_INCREASE_REPEAT:
if (output_bmp.width < MAX_OUTPUT_WIDTH - 2)
output_bmp.width += 2;
break;
case WIDTH_DECREASE:
case WIDTH_DECREASE_REPEAT:
if (output_bmp.width > 2) output_bmp.width -= 2;
break;
case CHANGE_MODE:
scale_algorithm = (scale_algorithm+1)%2;
break;
}
}