build a scaling-enabled bitmap loader in pluginlib for mono bitmap targets, and use it in the test greylib scaler plugin

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@19671 a1c6a512-1295-4272-9138-f99709370657

9 files changed, 188 insertions, 50 deletions

diff --git a/apps/plugins/lib/SOURCES b/apps/plugins/lib/SOURCES
index d21f21af15..c8c1553dc8 100644
--- a/apps/plugins/lib/SOURCES
+++ b/apps/plugins/lib/SOURCES
@@ -4,6 +4,10 @@ fixedpoint.c
 playback_control.c
 rgb_hsv.c
 #if defined(HAVE_LCD_BITMAP) && (LCD_DEPTH < 4)
+#if LCD_DEPTH == 1
+core_bmp.c
+core_resize.c
+#endif
 grey_core.c
 grey_draw.c
 grey_parm.c
diff --git a/apps/plugins/lib/bmp.c b/apps/plugins/lib/bmp.c
index a8ebbffc27..85e996c5e2 100644
--- a/apps/plugins/lib/bmp.c
+++ b/apps/plugins/lib/bmp.c
@@ -87,6 +87,8 @@ int save_bmp_file( char* filename, struct bitmap *bm, const struct plugin_api* r
 }
 #endif
 
+#include "../../recorder/bmp.c"
+
 /**
    Very simple image scale from src to dst (nearest neighbour).
    Source and destination dimensions are read from the struct bitmap.
diff --git a/apps/plugins/lib/core_bmp.c b/apps/plugins/lib/core_bmp.c
new file mode 100644
index 0000000000..28d70b1bb8
--- /dev/null
+++ b/apps/plugins/lib/core_bmp.c
@@ -0,0 +1,24 @@
+/***************************************************************************
+*             __________               __   ___.
+*   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+*   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+*   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+*   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+*                     \/            \/     \/    \/            \/
+* $Id$
+*
+* This is a wrapper for the core bmp.c
+*
+* This program 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 2
+* of the License, or (at your option) any later version.
+*
+* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+* KIND, either express or implied.
+*
+****************************************************************************/
+
+#include <plugin.h>
+#include "../../recorder/bmp.c"
+
diff --git a/apps/plugins/lib/core_resize.c b/apps/plugins/lib/core_resize.c
new file mode 100644
index 0000000000..099d4079ed
--- /dev/null
+++ b/apps/plugins/lib/core_resize.c
@@ -0,0 +1,24 @@
+/***************************************************************************
+*             __________               __   ___.
+*   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+*   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+*   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+*   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+*                     \/            \/     \/    \/            \/
+* $Id$
+*
+* This is a wrapper for the core bmp.c
+*
+* This program 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 2
+* of the License, or (at your option) any later version.
+*
+* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+* KIND, either express or implied.
+*
+****************************************************************************/
+
+#include <plugin.h>
+#include "../../recorder/resize.c"
+
diff --git a/apps/plugins/test_greylib_bitmap_scale.c b/apps/plugins/test_greylib_bitmap_scale.c
index f8a7bb92cc..3d6f81f91e 100644
--- a/apps/plugins/test_greylib_bitmap_scale.c
+++ b/apps/plugins/test_greylib_bitmap_scale.c
@@ -22,6 +22,12 @@
 #include "plugin.h"
 #include "lib/grey.h"
 
+#if LCD_DEPTH == 1
+#define BMP_LOAD read_bmp_file
+#else
+#define BMP_LOAD rb->read_bmp_file
+#endif
+
 PLUGIN_HEADER
 GREY_INFO_STRUCT
 static unsigned char grey_bm_buf[LCD_WIDTH * LCD_HEIGHT + 
@@ -30,6 +36,8 @@ static unsigned char grey_display_buf[2*LCD_WIDTH * LCD_HEIGHT];
 
 static const struct plugin_api* rb; /* global api struct pointer */
 
+MEM_FUNCTION_WRAPPERS(rb)
+
 /* this is the plugin entry point */
 enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter)
 {
@@ -47,9 +55,14 @@ enum plugin_status plugin_start(const struct plugin_api* api, const void* parame
 
     rb->strcpy(filename, parameter);
 
-    ret = rb->read_bmp_file(filename, &grey_bm, sizeof(grey_bm_buf),
-                            FORMAT_NATIVE|FORMAT_RESIZE|FORMAT_KEEP_ASPECT,
-                            &format_grey);
+#if LCD_DEPTH == 1
+    bmp_init(rb);
+    resize_init(rb);
+#endif
+
+    ret = BMP_LOAD(filename, &grey_bm, sizeof(grey_bm_buf),
+                   FORMAT_NATIVE|FORMAT_RESIZE|FORMAT_KEEP_ASPECT,
+                   &format_grey);
     
     if(ret < 1)
     {
diff --git a/apps/recorder/bmp.c b/apps/recorder/bmp.c
index 86c057a907..01b57d2116 100644
--- a/apps/recorder/bmp.c
+++ b/apps/recorder/bmp.c
@@ -42,7 +42,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include "inttypes.h"
+#ifndef PLUGIN
 #include "debug.h"
+#endif
 #include "lcd.h"
 #include "file.h"
 #ifdef HAVE_REMOTE_LCD
@@ -58,7 +60,6 @@
 #include "system.h"
 #include "bmp.h"
 #include "resize.h"
-#include "debug.h"
 #else
 #undef DEBUGF
 #define DEBUGF(...)
@@ -71,6 +72,19 @@
 #pragma pack (push, 2)
 #endif
 
+#ifndef PLUGIN
+#define API(x) x
+#else
+#define API(x) rb->x
+
+static const struct plugin_api *rb;
+
+void bmp_init(const struct plugin_api * api)
+{
+    rb = api;
+}
+#endif
+
 /* BMP header structure */
 struct bmp_header {
     uint16_t type;          /* signature - 'BM' */
@@ -123,13 +137,15 @@ static const struct uint8_rgb bitfields[3][3] = {
     },
 };
 
-#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
+#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
 /* the full 16x16 Bayer dither matrix may be calculated quickly with this table
 */
 const unsigned char dither_table[16] =
     {   0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255 };
 #endif
 
+#ifndef PLUGIN
 #if ((LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)) \
  || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH == 2) \
      && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED))
@@ -137,6 +153,7 @@ const unsigned short vi_pattern[4] = {
     0x0101, 0x0100, 0x0001, 0x0000
 };
 #endif
+#endif
 
 /******************************************************************************
  * read_bmp_file()
@@ -151,7 +168,7 @@ int read_bmp_file(const char* filename,
                   const struct custom_format *cformat)
 {
     int fd, ret;
-    fd = open(filename, O_RDONLY);
+    fd = API(open)(filename, O_RDONLY);
 
     /* Exit if file opening failed */
     if (fd < 0) {
@@ -163,7 +180,7 @@ int read_bmp_file(const char* filename,
            filename, !!(format & FORMAT_REMOTE), !!(format & FORMAT_RESIZE),
            !!(format & FORMAT_KEEP_ASPECT));
     ret = read_bmp_fd(fd, bm, maxsize, format, cformat);
-    close(fd);
+    API(close)(fd);
     return ret;
 }
 
@@ -182,7 +199,8 @@ struct bmp_args {
     short depth;
     unsigned char buf[BM_MAX_WIDTH * 4];
     struct uint8_rgb *palette;
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
     int cur_row;
     int cur_col;
     struct img_part part;
@@ -195,7 +213,8 @@ static unsigned int read_part_line(struct bmp_args *ba)
     const int read_width = ba->read_width;
     const int width = ba->width;
     const int depth = ba->depth;
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
     int cur_row = ba->cur_row;
     int cur_col = ba->cur_col;
 #endif
@@ -207,7 +226,8 @@ static unsigned int read_part_line(struct bmp_args *ba)
     int ret;
     int i, cols, len;
 
-#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
+#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
     cols = MIN(width - cur_col,(int)BM_MAX_WIDTH);
     BDEBUGF("reading %d cols (width: %d, max: %d)\n",cols,width,BM_MAX_WIDTH);
     len = (cols * (depth == 15 ? 16 : depth) + 7) >> 3;
@@ -217,13 +237,16 @@ static unsigned int read_part_line(struct bmp_args *ba)
 #endif
     ibuf = ((unsigned char *)buf) + (BM_MAX_WIDTH << 2) - len;
     BDEBUGF("read_part_line: cols=%d len=%d\n",cols,len);
-    ret = read(fd, ibuf, len);
+    ret = API(read)(fd, ibuf, len);
     if (ret != len)
     {
         DEBUGF("read_part_line: error reading image, read returned %d "
                "expected %d\n", ret, len);
+#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
         BDEBUGF("cur_row: %d cur_col: %d cols: %d len: %d\n", cur_row, cur_col,
                 cols, len);
+#endif
         return 0;
     }
     while (ibuf < ba->buf + (BM_MAX_WIDTH << 2))
@@ -282,15 +305,17 @@ static unsigned int read_part_line(struct bmp_args *ba)
         }
     }
 
-#if !defined(HAVE_LCD_COLOR) && \
-        (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
+#if (!defined(HAVE_LCD_COLOR) && \
+    (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))) || \
+    defined(PLUGIN)
     ibuf = ba->buf;
     buf = (struct uint8_rgb*)ba->buf;
     while (ibuf < ba->buf + cols)
         *ibuf++ = brightness(*buf++);
 #endif
 
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
     cur_col += cols;
     if (cur_col == width)
     {
@@ -299,9 +324,10 @@ static unsigned int read_part_line(struct bmp_args *ba)
         if (pad > 0)
         {
             BDEBUGF("seeking %d bytes to next line\n",pad);
-            lseek(fd, pad, SEEK_CUR);
+            API(lseek)(fd, pad, SEEK_CUR);
         }
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
         cur_col = 0;
         BDEBUGF("read_part_line: completed row %d\n", cur_row);
         cur_row += 1;
@@ -313,7 +339,8 @@ static unsigned int read_part_line(struct bmp_args *ba)
     return cols;
 }
 
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
 static struct img_part *store_part_bmp(void *args)
 {
     struct bmp_args *ba = (struct bmp_args *)args;
@@ -363,13 +390,14 @@ int read_bmp_fd(int fd,
     struct uint8_rgb palette[256];
     struct rowset rset;
     struct dim src_dim;
-#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
-    bool remote = false;
+#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) \
+    || defined(PLUGIN)
     unsigned int resize = IMG_NORESIZE;
     bool dither = false;
     bool transparent = false;
 
 #ifdef HAVE_REMOTE_LCD
+    bool remote = false;
     if (format & FORMAT_REMOTE) {
         remote = true;
 #if LCD_REMOTE_DEPTH == 1
@@ -394,7 +422,7 @@ int read_bmp_fd(int fd,
 #endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
 
     /* read fileheader */
-    ret = read(fd, &bmph, sizeof(struct bmp_header));
+    ret = API(read)(fd, &bmph, sizeof(struct bmp_header));
     if (ret < 0) {
         return ret * 10 - 2;
     }
@@ -433,14 +461,17 @@ int read_bmp_fd(int fd,
     {
         resize &= ~IMG_RESIZE;
         resize |= IMG_NORESIZE;
+#ifdef HAVE_REMOTE_LCD
         remote = 0;
+#endif
     }
-#else
+#elif !defined(PLUGIN)
     if (src_dim.width > BM_MAX_WIDTH)
             return -6;
 #endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
 
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
     if (resize & IMG_RESIZE) {
         if(format & FORMAT_KEEP_ASPECT) {
             /* keep aspect ratio.. */
@@ -463,7 +494,8 @@ int read_bmp_fd(int fd,
         bm->width = src_dim.width;
         bm->height = src_dim.height;
 
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
     }
 #endif
 
@@ -499,7 +531,7 @@ int read_bmp_fd(int fd,
         int i;
         union rgb_union pal;
         for (i = 0; i < numcolors; i++) {
-            if (read(fd, &pal, sizeof(pal)) != (int)sizeof(pal))
+            if (API(read)(fd, &pal, sizeof(pal)) != (int)sizeof(pal))
             {
                 DEBUGF("read_bmp_fd: Can't read color palette\n");
                 return -7;
@@ -557,20 +589,24 @@ int read_bmp_fd(int fd,
     }
 
     /* Search to the beginning of the image data */
-    lseek(fd, (off_t)letoh32(bmph.off_bits), SEEK_SET);
+    API(lseek)(fd, (off_t)letoh32(bmph.off_bits), SEEK_SET);
 
-    memset(bitmap, 0, totalsize);
+    API(memset)(bitmap, 0, totalsize);
 
     struct bmp_args ba = {
         .fd = fd, .padded_width = padded_width, .read_width = read_width,
         .width = src_dim.width, .depth = depth, .palette = palette,
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
         .cur_row = 0, .cur_col = 0, .part = {0,0}
 #endif
     };
 
-#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
+#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
+#if LCD_DEPTH > 1
     if (resize || cformat)
+#endif
     {
         if (resize_on_load(bm, dither, &src_dim, &rset,
                            bitmap + totalsize, maxsize - totalsize,
@@ -579,10 +615,12 @@ int read_bmp_fd(int fd,
         else
             return 0;
     }
-
+#ifndef PLUGIN
     int fb_width = BM_WIDTH(bm->width,bm->format,remote);
+#endif
 #endif /* LCD_DEPTH */
 
+#ifndef PLUGIN
     int col, row;
 
     /* loop to read rows and put them to buffer */
@@ -718,4 +756,5 @@ int read_bmp_fd(int fd,
         }
     }
     return totalsize; /* return the used buffer size. */
+#endif
 }
diff --git a/apps/recorder/bmp.h b/apps/recorder/bmp.h
index c53f295dfb..946bc6f8b8 100644
--- a/apps/recorder/bmp.h
+++ b/apps/recorder/bmp.h
@@ -52,7 +52,8 @@ struct rowset {
     short rowstop;
 };
 
-#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
+#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) || \
+    defined(PLUGIN)
 extern const unsigned char dither_table[16];
 #define DITHERY(y) (dither_table[(y) & 15] & 0xAA)
 #define DITHERX(x) (dither_table[(x) & 15])
@@ -67,7 +68,7 @@ extern const unsigned char dither_table[16];
 */
 static inline unsigned brightness(struct uint8_rgb color)
 {
-#if LCD_DEPTH > 1
+#if LCD_DEPTH > 1 || defined(PLUGIN)
     return (77 * (unsigned)color.red + 150 * (unsigned)color.green
               + 29 * (unsigned)color.blue) / 256;
 #else
@@ -211,4 +212,9 @@ int read_bmp_fd(int fd,
                 int maxsize,
                 int format,
                 const struct custom_format *cformat);
+#ifdef PLUGIN
+struct plugin_api;
+void bmp_init(const struct plugin_api * api);
+#endif
+
 #endif
diff --git a/apps/recorder/resize.c b/apps/recorder/resize.c
index 5c9f7a6dd6..6e5e9c4efb 100644
--- a/apps/recorder/resize.c
+++ b/apps/recorder/resize.c
@@ -36,7 +36,9 @@
 #include <string.h>
 #include <general.h>
 #include "inttypes.h"
+#ifndef PLUGIN
 #include "debug.h"
+#endif
 #include "lcd.h"
 #include "file.h"
 #ifdef HAVE_REMOTE_LCD
@@ -50,15 +52,26 @@
 #ifndef __PCTOOL__
 #include "config.h"
 #include "system.h"
-#include "bmp.h"
-#include "resize.h"
+#include <bmp.h>
 #include "resize.h"
-#include "debug.h"
 #else
 #undef DEBUGF
 #define DEBUGF(...)
 #endif
 
+#ifndef PLUGIN
+#define API(x) x
+#else
+#define API(x) rb->x
+
+static const struct plugin_api *rb;
+
+void resize_init(const struct plugin_api *api)
+{
+    rb = api;
+}
+#endif
+
 /* calculate the maximum dimensions which will preserve the aspect ration of
    src while fitting in the constraints passed in dst, and store result in dst,
    returning 0 if rounding and 1 if not rounding.
@@ -141,7 +154,7 @@ static bool scale_h_area(void *out_line_ptr,
     oxe = 0;
     mul = 0;
     /* give other tasks a chance to run */
-    yield();
+    API(yield)();
     for (ix = 0; ix < (unsigned int)ctx->src->width; ix++)
     {
         oxe += ctx->bm->width;
@@ -244,11 +257,11 @@ static inline bool scale_v_area(struct rowset *rset, struct scaler_context *ctx)
 #ifdef HAVE_LCD_COLOR
     uint32_t *rowacc = (uint32_t *) ctx->buf,
              *rowtmp = rowacc + 3 * ctx->bm->width;
-    memset((void *)ctx->buf, 0, ctx->bm->width * 2 * sizeof(struct uint32_rgb));
+    API(memset)((void *)ctx->buf, 0, ctx->bm->width * 2 * sizeof(struct uint32_rgb));
 #else
     uint32_t *rowacc = (uint32_t *) ctx->buf,
              *rowtmp = rowacc + ctx->bm->width;
-    memset((void *)ctx->buf, 0, ctx->bm->width * 2 * sizeof(uint32_t));
+    API(memset)((void *)ctx->buf, 0, ctx->bm->width * 2 * sizeof(uint32_t));
 #endif
     SDEBUGF("scale_v_area\n");
     /* zero the accumulator and temp rows */
@@ -285,9 +298,9 @@ static inline bool scale_v_area(struct rowset *rset, struct scaler_context *ctx)
             ctx->output_row(oy, (void*)rowacc, ctx);
             /* clear accumulator row, store partial coverage for next row */
 #ifdef HAVE_LCD_COLOR
-            memset((void *)rowacc, 0, ctx->bm->width * sizeof(uint32_t) * 3);
+            API(memset)((void *)rowacc, 0, ctx->bm->width * sizeof(uint32_t) * 3);
 #else
-            memset((void *)rowacc, 0, ctx->bm->width * sizeof(uint32_t));
+            API(memset)((void *)rowacc, 0, ctx->bm->width * sizeof(uint32_t));
 #endif
             mul = oye;
             oy += rset->rowstep;
@@ -333,7 +346,7 @@ static bool scale_h_linear(void *out_line_ptr, struct scaler_context *ctx,
     /* The error is set so that values are initialized on the first pass. */
     ixe = ctx->bm->width - 1;
     /* give other tasks a chance to run */
-    yield();
+    API(yield)();
     for (ox = 0; ox < (uint32_t)ctx->bm->width; ox++)
     {
 #ifdef HAVE_LCD_COLOR
@@ -500,8 +513,8 @@ static inline bool scale_v_linear(struct rowset *rset,
 }
 #endif /* HAVE_UPSCALER */
 
-static void output_row_native(uint32_t row, void * row_in,
-                              struct scaler_context *ctx)
+#ifndef PLUGIN
+void output_row_native(uint32_t row, void * row_in, struct scaler_context *ctx)
 {
     int col;
     int fb_width = BM_WIDTH(ctx->bm->width,FORMAT_NATIVE,0);
@@ -511,7 +524,7 @@ static void output_row_native(uint32_t row, void * row_in,
 #else
     uint32_t *qp = (uint32_t*)row_in;
 #endif
-    SDEBUGF("output_row: y: %d in: %p\n",row, row_in);
+    SDEBUGF("output_row: y: %lu in: %p\n",row, row_in);
 #if LCD_DEPTH == 2
 #if LCD_PIXELFORMAT == HORIZONTAL_PACKING
                 /* greyscale iPods */
@@ -591,6 +604,7 @@ static void output_row_native(uint32_t row, void * row_in,
                 }
 #endif /* LCD_DEPTH */
 }
+#endif
 
 int resize_on_load(struct bitmap *bm, bool dither, struct dim *src,
                    struct rowset *rset, unsigned char *buf, unsigned int len,
@@ -615,8 +629,10 @@ int resize_on_load(struct bitmap *bm, bool dither, struct dim *src,
     uint8_t sc_buf[(needed <= len  || needed > MAX_SC_STACK_ALLOC) ?
                    0 : needed];
 #endif
-    len = (unsigned int)align_buffer(PUN_PTR(void**, &buf), len,
+#if CONFIG_CODEC == SWCODEC
+    len = (unsigned int)API(align_buffer)(PUN_PTR(void**, &buf), len,
                                          sizeof(uint32_t));
+#endif
     if (needed > len)
     {
 #if MAX_SC_STACK_ALLOC
@@ -642,7 +658,9 @@ int resize_on_load(struct bitmap *bm, bool dither, struct dim *src,
     }
 
     struct scaler_context ctx;
-    cpu_boost(true);
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    API(cpu_boost)(true);
+#endif
     ctx.store_part = store_part;
     ctx.args = args;
 #if MAX_SC_STACK_ALLOC
@@ -654,10 +672,11 @@ int resize_on_load(struct bitmap *bm, bool dither, struct dim *src,
     ctx.bm = bm;
     ctx.src = src;
     ctx.dither = dither;
+#ifndef PLUGIN
+    ctx.output_row = output_row_native;
     if (format)
+#endif
         ctx.output_row = format->output_row;
-    else
-        ctx.output_row = output_row_native;
 #ifdef HAVE_UPSCALER
     if (sw > dw)
     {
@@ -678,7 +697,9 @@ int resize_on_load(struct bitmap *bm, bool dither, struct dim *src,
     else
         ret = scale_v_linear(rset, &ctx);
 #endif
-    cpu_boost(false);
+#ifdef HAVE_ADJUSTABLE_CPU_FREQ
+    API(cpu_boost)(false);
+#endif
     if (!ret)
         return 0;
     return 1;
diff --git a/apps/recorder/resize.h b/apps/recorder/resize.h
index ca7e6326d0..9b52a7aa65 100644
--- a/apps/recorder/resize.h
+++ b/apps/recorder/resize.h
@@ -45,8 +45,7 @@
 
 struct img_part {
     int len;
-#if !defined(HAVE_LCD_COLOR) && \
-        (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
+#if !defined(HAVE_LCD_COLOR)    
     uint8_t *buf;
 #else
     struct uint8_rgb* buf;
@@ -95,4 +94,10 @@ int resize_on_load(struct bitmap *bm, bool dither,
                    const struct custom_format *cformat,
                    struct img_part* (*store_part)(void *args),
                    void *args);
+
+#ifdef PLUGIN
+struct plugin_api;
+void resize_init(const struct plugin_api *api);
+#endif
+
 #endif /* _RESIZE_H_ */