1 files changed, 418 insertions, 502 deletions

diff --git a/apps/recorder/resize.c b/apps/recorder/resize.c
index e41501032a..3c1d34f046 100644
--- a/apps/recorder/resize.c
+++ b/apps/recorder/resize.c
@@ -59,15 +59,45 @@
 #define DEBUGF(...)
 #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.
+*/
+int recalc_dimension(struct dim *dst, struct dim *src)
+{
+    int tmp;
+    if (dst->width <= 0)
+        dst->width = LCD_WIDTH;
+    if (dst->height <= 0)
+        dst->height = LCD_HEIGHT;
+#ifndef HAVE_UPSCALER
+    if (dst->width > src->width || dst->height > src->height)
+    {
+        dst->width = src->width;
+        dst->height = src->height;
+    }
+    if (src->width == dst->width && src->height == dst->height)
+        return 1;
+#endif
+    tmp = (src->width * dst->height + (src->height >> 1)) / src->height;
+    if (tmp > dst->width)
+        dst->height = (src->height * dst->width + (src->width >> 1))
+                      / src->width;
+    else
+        dst->width = tmp;
+    return src->width == dst->width && src->height == dst->height;
+}
+
 /* All of these scalers use variations of Bresenham's algorithm to convert from
-   their input to output coordinates. The color scalers have the error value
-   shifted so that it is a useful input to the scaling algorithm.
+   their input to output coordinates.  The error value is shifted from the
+   "classic" version such that it is a useful input to the scaling calculation.
 */
 
 #ifdef HAVE_LCD_COLOR
 /* dither + pack on channel of RGB565, R an B share a packing macro */
 #define PACKRB(v, delta)  ((31 * v + (v >> 3) + delta) >> 8)
 #define PACKG(g, delta) ((63 * g + (g >> 2) + delta) >> 8)
+#endif
 
 /* read new img_part unconditionally, return false on failure */
 #define FILL_BUF_INIT(img_part, store_part, args) { \
@@ -84,183 +114,204 @@
         return false; \
 }
 
-struct uint32_rgb {
-    uint32_t r;
-    uint32_t g;
-    uint32_t b;
-};
-
+/* struct which containers various parameters shared between vertical scaler,
+   horizontal scaler, and row output
+*/
 struct scaler_context {
-    uint32_t divmul;
+    uint32_t divisor;
     uint32_t round;
-    struct img_part* (*store_part)(void *);
-    long last_tick;
+    struct bitmap *bm;
+    struct dim *src;
     unsigned char *buf;
+    bool dither;
     int len;
     void *args;
+    struct img_part* (*store_part)(void *);
+    void (*output_row)(uint32_t,void*,struct scaler_context*);
+    bool (*h_scaler)(void*,struct scaler_context*, bool);
 };
 
 /* Set up rounding and scale factors for horizontal area scaler */
-static void scale_h_area_setup(struct bitmap *bm, struct dim *src,
-                               struct scaler_context *ctx)
+static inline void scale_h_area_setup(struct scaler_context *ctx)
 {
-    (void) bm;
 /* sum is output value * src->width */
-    ctx->divmul = ((src->width - 1 + 0x80000000U) / src->width) << 1;
-    ctx->round = (src->width + 1) >> 1;
+    SDEBUGF("scale_h_area_setup\n");
+    ctx->divisor = ctx->src->width;
 }
 
 /* horizontal area average scaler */
-static bool scale_h_area(struct bitmap *bm, struct dim *src,
-                         struct uint32_rgb *out_line,
+static bool scale_h_area(void *out_line_ptr,
                          struct scaler_context *ctx, bool accum)
 {
     SDEBUGF("scale_h_area\n");
     unsigned int ix, ox, oxe, mul;
-    struct uint32_rgb rgbvalacc = { 0, 0, 0 }, 
-                      rgbvaltmp = { 0, 0, 0 };
+#ifdef HAVE_LCD_COLOR
+    struct uint32_rgb rgbvalacc = { 0, 0, 0 },
+                      rgbvaltmp = { 0, 0, 0 },
+                      *out_line = (struct uint32_rgb *)out_line_ptr;
+#else
+    uint32_t acc = 0, tmp = 0, *out_line = (uint32_t*)out_line_ptr;
+#endif
     struct img_part *part;
     FILL_BUF_INIT(part,ctx->store_part,ctx->args);
     ox = 0;
     oxe = 0;
     mul = 0;
-    for (ix = 0; ix < (unsigned int)src->width; ix++)
+    /* give other tasks a chance to run */
+    yield();
+    for (ix = 0; ix < (unsigned int)ctx->src->width; ix++)
     {
-        oxe += bm->width;
+        oxe += ctx->bm->width;
         /* end of current area has been reached */
-        if (oxe >= (unsigned int)src->width)
+        /* fill buffer if needed */
+        FILL_BUF(part,ctx->store_part,ctx->args);
+#ifdef HAVE_LCD_COLOR
+        if (oxe >= (unsigned int)ctx->src->width)
         {
-            /* yield if we haven't since last tick */
-            if (ctx->last_tick != current_tick)
-            {
-                yield();
-                ctx->last_tick = current_tick;
-            }
             /* "reset" error, which now represents partial coverage of next
                pixel by the next area
             */
-            oxe -= src->width;
+            oxe -= ctx->src->width;
+
             /* add saved partial pixel from start of area */
-            rgbvalacc.r = rgbvalacc.r * bm->width + rgbvaltmp.r * mul;
-            rgbvalacc.g = rgbvalacc.g * bm->width + rgbvaltmp.g * mul;
-            rgbvalacc.b = rgbvalacc.b * bm->width + rgbvaltmp.b * mul;
-            /* fill buffer if needed */
-            FILL_BUF(part,ctx->store_part,ctx->args);
+            rgbvalacc.r = rgbvalacc.r * ctx->bm->width + rgbvaltmp.r * mul;
+            rgbvalacc.g = rgbvalacc.g * ctx->bm->width + rgbvaltmp.g * mul;
+            rgbvalacc.b = rgbvalacc.b * ctx->bm->width + rgbvaltmp.b * mul;
+
             /* get new pixel , then add its partial coverage to this area */
             rgbvaltmp.r = part->buf->red;
             rgbvaltmp.g = part->buf->green;
             rgbvaltmp.b = part->buf->blue;
-            part->buf++;
-            part->len--;
-            mul = bm->width - oxe;
+            mul = ctx->bm->width - oxe;
             rgbvalacc.r += rgbvaltmp.r * mul;
             rgbvalacc.g += rgbvaltmp.g * mul;
             rgbvalacc.b += rgbvaltmp.b * mul;
-            /* round, divide, and either store or accumulate to output row */
-            out_line[ox].r = (accum ? out_line[ox].r : 0) +
-                             ((rgbvalacc.r + ctx->round) *
-                             (uint64_t)ctx->divmul >> 32);
-            out_line[ox].g = (accum ? out_line[ox].g : 0) +
-                             ((rgbvalacc.g + ctx->round) *
-                             (uint64_t)ctx->divmul >> 32);
-            out_line[ox].b = (accum ? out_line[ox].b : 0) +
-                             ((rgbvalacc.b + ctx->round) *
-                             (uint64_t)ctx->divmul >> 32);
+            /* store or accumulate to output row */
+            if (accum)
+            {
+                rgbvalacc.r += out_line[ox].r;
+                rgbvalacc.g += out_line[ox].g;
+                rgbvalacc.b += out_line[ox].b;
+            }
+            out_line[ox].r = rgbvalacc.r;
+            out_line[ox].g = rgbvalacc.g;
+            out_line[ox].b = rgbvalacc.b;
             /* reset accumulator */
             rgbvalacc.r = 0;
             rgbvalacc.g = 0;
             rgbvalacc.b = 0;
-            mul = bm->width - mul;
+            mul = ctx->bm->width - mul;
             ox += 1;
         /* inside an area */
         } else {
-            /* fill buffer if needed */
-            FILL_BUF(part,ctx->store_part,ctx->args);
             /* add pixel value to accumulator */
             rgbvalacc.r += part->buf->red;
             rgbvalacc.g += part->buf->green;
             rgbvalacc.b += part->buf->blue;
-            part->buf++;
-            part->len--;
         }
+#else
+        if (oxe >= (unsigned int)ctx->src->width)
+        {
+            /* "reset" error, which now represents partial coverage of next
+               pixel by the next area
+            */
+            oxe -= ctx->src->width;
+
+            /* add saved partial pixel from start of area */
+            acc = acc * ctx->bm->width + tmp * mul;
+
+            /* get new pixel , then add its partial coverage to this area */
+            tmp = *(part->buf);
+            mul = ctx->bm->width - oxe;
+            acc += tmp * mul;
+            /* round, divide, and either store or accumulate to output row */
+            if (accum)
+            {
+                acc += out_line[ox];
+            }
+            out_line[ox] = acc;
+            /* reset accumulator */
+            acc = 0;
+            mul = ctx->bm->width - mul;
+            ox += 1;
+        /* inside an area */
+        } else {
+            /* add pixel value to accumulator */
+            acc += *(part->buf);
+        }
+#endif
+        part->buf++;
+        part->len--;
     }
     return true;
 }
 
 /* vertical area average scaler */
-static bool scale_v_area(struct bitmap *bm, bool dither, struct dim *src,
-                         struct rowset *rset,
-                         bool (*h_scaler)(struct bitmap*, struct dim*,
-                                          struct uint32_rgb*,
-                                          struct scaler_context*, bool),
-                         struct scaler_context *ctx)
+static inline bool scale_v_area(struct rowset *rset, struct scaler_context *ctx)
 {
-    uint32_t mul, divmul, x, oy, iy, oye, round;
-    int delta = 127, r, g, b;
-    fb_data *row, *pix;
+    uint32_t mul, x, oy, iy, oye;
 
     /* Set up rounding and scale factors */
-    divmul = ((src->height - 1 + 0x80000000U) / src->height) << 1;
-    round = (src->height + 1) >> 1;
+    ctx->divisor *= ctx->src->height;
+    ctx->round = ctx->divisor >> 1;
+    ctx->divisor = ((ctx->divisor - 1 + 0x80000000U) / ctx->divisor) << 1;
     mul = 0;
-    oy = 0;
+    oy = rset->rowstart;
     oye = 0;
-    struct uint32_rgb *rowacc = (struct uint32_rgb *)(ctx->buf),
-                      *rowtmp = rowacc + bm->width;
-
+#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));
+#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));
+#endif
     SDEBUGF("scale_v_area\n");
     /* zero the accumulator and temp rows */
-    memset((void *)ctx->buf, 0, bm->width * 2 * sizeof(struct uint32_rgb));
-    row = (fb_data *)(bm->data) + bm->width * rset->rowstart;
-    for (iy = 0; iy < (unsigned int)src->height; iy++)
+    for (iy = 0; iy < (unsigned int)ctx->src->height; iy++)
     {
-        oye += bm->height;
+        oye += ctx->bm->height;
         /* end of current area has been reached */
-        if (oye >= (unsigned int)src->height)
+        if (oye >= (unsigned int)ctx->src->height)
         {
             /* "reset" error, which now represents partial coverage of the next
                row by the next area
             */
-            oye -= src->height;
+            oye -= ctx->src->height;
             /* add stored partial row to accumulator */
-            for (x = 0; x < 3 *(unsigned int)bm->width; x++)
-                ((uint32_t*)rowacc)[x] = ((uint32_t*)rowacc)[x] *
-                                        bm->height + mul *
-                                        ((uint32_t*)rowtmp)[x];
+#ifdef HAVE_LCD_COLOR
+            for (x = 0; x < 3 * (unsigned int)ctx->bm->width; x++)
+#else
+            for (x = 0; x < (unsigned int)ctx->bm->width; x++)
+#endif
+                rowacc[x] = rowacc[x] * ctx->bm->height + mul * rowtmp[x];
             /* store new scaled row in temp row */
-            if(!h_scaler(bm, src, rowtmp, ctx, false))
+            if(!ctx->h_scaler(rowtmp, ctx, false))
                 return false;
             /* add partial coverage by new row to this area, then round and
                scale to final value
             */
-            mul = bm->height - oye;
-            for (x = 0; x < 3 *(unsigned int)bm->width; x++)
-            {
-                ((uint32_t*)rowacc)[x] += mul * ((uint32_t*)rowtmp)[x];
-                ((uint32_t*)rowacc)[x] = (round +
-                                        ((uint32_t*)rowacc)[x]) *
-                                        (uint64_t)divmul >> 32;
-            }
-            /* convert to RGB565 in output bitmap */
-            pix = row;
-            for (x = 0; x < (unsigned int)bm->width; x++)
-            {
-                if (dither)
-                    delta = dither_mat(x & 0xf, oy & 0xf);
-                r = PACKRB(rowacc[x].r,delta);
-                g = PACKG(rowacc[x].g,delta);
-                b = PACKRB(rowacc[x].b,delta);
-                *pix++ = LCD_RGBPACK_LCD(r, g, b);
-            }
+            mul = ctx->bm->height - oye;
+#ifdef HAVE_LCD_COLOR
+            for (x = 0; x < 3 * (unsigned int)ctx->bm->width; x++)
+#else
+            for (x = 0; x < (unsigned int)ctx->bm->width; x++)
+#endif
+                rowacc[x] += mul * rowtmp[x];
+            ctx->output_row(oy, (void*)rowacc, ctx);
             /* clear accumulator row, store partial coverage for next row */
-            memset((void *)rowacc, 0, bm->width * sizeof(struct uint32_rgb));
+#ifdef HAVE_LCD_COLOR
+            memset((void *)rowacc, 0, ctx->bm->width * sizeof(uint32_t) * 3);
+#else
+            memset((void *)rowacc, 0, ctx->bm->width * sizeof(uint32_t));
+#endif
             mul = oye;
-            row += bm->width * rset->rowstep;
-            oy += 1;
+            oy += rset->rowstep;
         /* inside an area */
         } else {
             /* accumulate new scaled row to rowacc */
-            if (!h_scaler(bm, src, rowacc, ctx, true))
+            if (!ctx->h_scaler(rowacc, ctx, true))
                 return false;
         }
     }
@@ -272,53 +323,52 @@ static bool scale_v_area(struct bitmap *bm, bool dither, struct dim *src,
    is bm->width - 1, so that the first and last pixels in the row align
    exactly between input and output
 */
-static void scale_h_linear_setup(struct bitmap *bm, struct dim *src,
-                                   struct scaler_context *ctx)
+static inline void scale_h_linear_setup(struct scaler_context *ctx)
 {
-    (void) src;
-    ctx->divmul = ((bm->width - 2 + 0x80000000U) / (bm->width - 1)) << 1;
-    ctx->round = bm->width >> 1;
+    ctx->divisor = ctx->bm->width - 1;
 }
 
 /* horizontal linear scaler */
-static bool scale_h_linear(struct bitmap *bm, struct dim *src,
-                             struct uint32_rgb *out_line,
-                             struct scaler_context *ctx, bool accum) 
+static bool scale_h_linear(void *out_line_ptr, struct scaler_context *ctx,
+                           bool accum)
 {
     unsigned int ix, ox, ixe;
     /* type x = x is an ugly hack for hiding an unitialized data warning. The
        values are conditionally initialized before use, but other values are
        set such that this will occur before these are used.
     */
-    struct uint32_rgb rgbval=rgbval, rgbinc=rgbinc;
+#ifdef HAVE_LCD_COLOR
+    struct uint32_rgb rgbval=rgbval, rgbinc=rgbinc,
+                      *out_line = (struct uint32_rgb*)out_line_ptr;
+#else
+    uint32_t val=val, inc=inc, *out_line = (uint32_t*)out_line_ptr;
+#endif
     struct img_part *part;
     SDEBUGF("scale_h_linear\n");
     FILL_BUF_INIT(part,ctx->store_part,ctx->args);
     ix = 0;
     /* The error is set so that values are initialized on the first pass. */
-    ixe = bm->width - 1;
-    for (ox = 0; ox < (uint32_t)bm->width; ox++) {
-        if (ixe >= ((uint32_t)bm->width - 1))
+    ixe = ctx->bm->width - 1;
+    /* give other tasks a chance to run */
+    yield();
+    for (ox = 0; ox < (uint32_t)ctx->bm->width; ox++)
+    {
+#ifdef HAVE_LCD_COLOR
+        if (ixe >= ((uint32_t)ctx->bm->width - 1))
         {
-            /* yield once each tick */
-            if (ctx->last_tick != current_tick)
-            {
-                yield();
-                ctx->last_tick = current_tick;
-            }
-            /* Store the new "current" pixel value in rgbval, and the color 
+            /* Store the new "current" pixel value in rgbval, and the color
                step value in rgbinc.
             */
-            ixe -= (bm->width - 1);
+            ixe -= (ctx->bm->width - 1);
             rgbinc.r = -(part->buf->red);
             rgbinc.g = -(part->buf->green);
             rgbinc.b = -(part->buf->blue);
-            rgbval.r = (part->buf->red) * (bm->width - 1);
-            rgbval.g = (part->buf->green) * (bm->width - 1);
-            rgbval.b = (part->buf->blue) * (bm->width - 1);
+            rgbval.r = (part->buf->red) * (ctx->bm->width - 1);
+            rgbval.g = (part->buf->green) * (ctx->bm->width - 1);
+            rgbval.b = (part->buf->blue) * (ctx->bm->width - 1);
             ix += 1;
             /* If this wasn't the last pixel, add the next one to rgbinc. */
-            if (ix < (uint32_t)src->width) {
+            if (ix < (uint32_t)ctx->src->width) {
                 part->buf++;
                 part->len--;
                 /* Fetch new pixels if needed */
@@ -334,448 +384,314 @@ static bool scale_h_linear(struct bitmap *bm, struct dim *src,
                 rgbval.b += rgbinc.b * ixe;
             }
             /* Now multiple the color increment to its proper value */
-            rgbinc.r *= src->width - 1;
-            rgbinc.g *= src->width - 1;
-            rgbinc.b *= src->width - 1;
+            rgbinc.r *= ctx->src->width - 1;
+            rgbinc.g *= ctx->src->width - 1;
+            rgbinc.b *= ctx->src->width - 1;
+        } else {
+            rgbval.r += rgbinc.r;
+            rgbval.g += rgbinc.g;
+            rgbval.b += rgbinc.b;
         }
         /* round and scale values, and accumulate or store to output */
-        out_line[ox].r = (accum ? out_line[ox].r : 0) +
-                         ((rgbval.r + ctx->round) *
-                         (uint64_t)ctx->divmul >> 32);
-        out_line[ox].g = (accum ? out_line[ox].g : 0) +
-                         ((rgbval.g + ctx->round) *
-                         (uint64_t)ctx->divmul >> 32);
-        out_line[ox].b = (accum ? out_line[ox].b : 0) +
-                         ((rgbval.b + ctx->round) *
-                         (uint64_t)ctx->divmul >> 32);
-        rgbval.r += rgbinc.r;
-        rgbval.g += rgbinc.g;
-        rgbval.b += rgbinc.b;
-        ixe += src->width - 1;
+        if (accum)
+        {
+            out_line[ox].r += rgbval.r;
+            out_line[ox].g += rgbval.g;
+            out_line[ox].b += rgbval.b;
+        } else {
+            out_line[ox].r = rgbval.r;
+            out_line[ox].g = rgbval.g;
+            out_line[ox].b = rgbval.b;
+        }
+#else
+        if (ixe >= ((uint32_t)ctx->bm->width - 1))
+        {
+            /* Store the new "current" pixel value in rgbval, and the color
+               step value in rgbinc.
+            */
+            ixe -= (ctx->bm->width - 1);
+            val = *(part->buf);
+            inc = -val;
+            val *= (ctx->bm->width - 1);
+            ix += 1;
+            /* If this wasn't the last pixel, add the next one to rgbinc. */
+            if (ix < (uint32_t)ctx->src->width) {
+                part->buf++;
+                part->len--;
+                /* Fetch new pixels if needed */
+                FILL_BUF(part,ctx->store_part,ctx->args);
+                inc += *(part->buf);
+                /* Add a partial step to rgbval, in this pixel isn't precisely
+                   aligned with the new source pixel
+                */
+                val += inc * ixe;
+            }
+            /* Now multiply the color increment to its proper value */
+            inc *= ctx->src->width - 1;
+        } else
+            val += inc;
+        /* round and scale values, and accumulate or store to output */
+        if (accum)
+        {
+            out_line[ox] += val;
+        } else {
+            out_line[ox] = val;
+        }
+#endif
+        ixe += ctx->src->width - 1;
     }
     return true;
 }
 
 /* vertical linear scaler */
-static bool scale_v_linear(struct bitmap *bm, bool dither, struct dim *src,
-                           struct rowset *rset,
-                           bool (*h_scaler)(struct bitmap*, struct dim*,
-                                            struct uint32_rgb*,
-                                            struct scaler_context*, bool),
-                           struct scaler_context *ctx)
+static inline bool scale_v_linear(struct rowset *rset,
+                                  struct scaler_context *ctx)
 {
-    uint32_t mul, divmul, x, oy, iy, iye, round;
-    int delta = 127;
-    struct uint32_rgb p;
-    fb_data *row, *pix;
+    uint32_t mul, x, iy, iye;
+    int32_t oy;
     /* Set up scale and rounding factors, the divisor is bm->height - 1 */
-    divmul = ((bm->height - 2 + 0x80000000U) / (bm->height - 1)) << 1;
-    round = bm->height >> 1; 
-    mul = 0;
-    iy = 0;
-    iye = bm->height - 1;
+    ctx->divisor *= (ctx->bm->height - 1);
+    ctx->round = ctx->divisor >> 1;
+    ctx->divisor = ((ctx->divisor - 1 + 0x80000000U) / ctx->divisor) << 1;
     /* Set up our two temp buffers. The names are generic because they'll be
        swapped each time a new input row is read
     */
-    struct uint32_rgb *crow1 = (struct uint32_rgb *)(ctx->buf),
-                      *crow2 = crow1 + bm->width,
-                      *t;
+#ifdef HAVE_LCD_COLOR
+    uint32_t *rowinc = (uint32_t *)(ctx->buf),
+             *rowval = rowinc + 3 * ctx->bm->width,
+             *rowtmp = rowval + 3 * ctx->bm->width;
+#else
+    uint32_t *rowinc = (uint32_t *)(ctx->buf),
+             *rowval = rowinc + ctx->bm->width,
+             *rowtmp = rowval + ctx->bm->width;
+#endif
 
     SDEBUGF("scale_v_linear\n");
-    row = (fb_data *)(bm->data) + bm->width * rset->rowstart;
-    /* get first scaled row in crow2 */
-    if(!h_scaler(bm, src, crow2, ctx, false))
+    mul = 0;
+    iy = 0;
+    iye = ctx->bm->height - 1;
+    /* get first scaled row in rowtmp */
+    if(!ctx->h_scaler((void*)rowtmp, ctx, false))
         return false;
-    for (oy = 0; oy < (uint32_t)bm->height; oy++)
+    for (oy = rset->rowstart; oy != rset->rowstop; oy += rset->rowstep)
     {
-        if (iye >= (uint32_t)bm->height - 1)
+        if (iye >= (uint32_t)ctx->bm->height - 1)
         {
-            /* swap temp rows, then read another row into crow2 */
-            t = crow2;
-            crow2 = crow1;
-            crow1 = t;
-            iye -= bm->height - 1;
+            iye -= ctx->bm->height - 1;
             iy += 1;
-            if (iy < (uint32_t)src->height)
+#ifdef HAVE_LCD_COLOR
+            for (x = 0; x < 3 * (uint32_t)ctx->bm->width; x++)
+#else
+            for (x = 0; x < (uint32_t)ctx->bm->width; x++)
+#endif
             {
-                if (!h_scaler(bm, src, crow2, ctx, false))
+                rowinc[x] = -rowtmp[x];
+                rowval[x] = rowtmp[x] * (ctx->bm->height - 1);
+            }
+            if (iy < (uint32_t)ctx->src->height)
+            {
+                if (!ctx->h_scaler((void*)rowtmp, ctx, false))
                     return false;
+#ifdef HAVE_LCD_COLOR
+                for (x = 0; x < 3 * (uint32_t)ctx->bm->width; x++)
+#else
+                for (x = 0; x < (uint32_t)ctx->bm->width; x++)
+#endif
+                {
+                    rowinc[x] += rowtmp[x];
+                    rowval[x] += rowinc[x] * iye;
+                    rowinc[x] *= ctx->src->height - 1;
+                }
             }
-        }
-        pix = row;
-        for (x = 0; x < (uint32_t)bm->width; x++)
-        {
-            /* iye and bm-height - 1 - iye represent the contribution of each
-               row to the output. Calculate their weighted sum, then round and
-               scale it.
-            */
-            p.r = (crow1[x].r * (bm->height - 1 - iye) +
-                  crow2[x].r * iye + round) * (uint64_t)divmul >> 32;
-            p.g = (crow1[x].g * (bm->height - 1 - iye) +
-                  crow2[x].g * iye + round) * (uint64_t)divmul >> 32;
-            p.b = (crow1[x].b * (bm->height - 1 - iye) +
-                  crow2[x].b * iye + round) * (uint64_t)divmul >> 32;
-            /* dither and pack pixels to output */
-            if (dither)
-                delta = dither_mat(x & 0xf, oy & 0xf);
-            p.r = PACKRB(p.r,delta);
-            p.g = PACKG(p.g,delta);
-            p.b = PACKRB(p.b,delta);
-            *pix++ = LCD_RGBPACK_LCD(p.r, p.g, p.b);
-        }
-        row += bm->width * rset->rowstep;
-        iye += src->height - 1;
+        } else
+#ifdef HAVE_LCD_COLOR
+            for (x = 0; x < 3 * (uint32_t)ctx->bm->width; x++)
+#else
+            for (x = 0; x < (uint32_t)ctx->bm->width; x++)
+#endif
+                    rowval[x] += rowinc[x];
+        ctx->output_row(oy, (void*)rowval, ctx);
+        iye += ctx->src->height - 1;
     }
     return true;
 }
 #endif /* HAVE_UPSCALER */
-#endif /* HAVE_LCD_COLOR */
 
-/* docs for this are still TODO, but it's Bresenham's again, used to skip or
-   repeat input pixels, and with the *ls values being used for "long steps"
-   that skip all the way, or nearly all the way, to the next transition of
-   the associated value.
-*/
-#if LCD_DEPTH < 8 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH < 8)
-/* nearest-neighbor up/down/non-scaler */
-static inline bool scale_nearest(struct bitmap *bm,
-                                struct dim *src,
-                                struct rowset *rset,
-                                bool remote, bool dither,
-                                struct img_part* (*store_part)(void *args),
-                                bool (*skip_lines)(void *args, unsigned int),
-                                void *args)
+void output_row_native(uint32_t row, void * row_in, struct scaler_context *ctx)
 {
-    const int sw = src->width;
-    const int sh = src->height;
-    const int dw = bm->width;
-    const int dh = bm->height;
-    unsigned char *bitmap = bm->data;
-    const int rowstep = rset->rowstep;
-    const int rowstart = rset->rowstart;
-    const int rowstop = rset->rowstop;
-    const int fb_width = get_fb_width(bm, false);
-    long last_tick = current_tick;
-    /* yet/oyt will always be initialized before use, since they are set in the
-       inside loop, and not used elsewhere until the end of the outside loop.
-    */
-    int ix, ox, lx, xe, iy, oy, ly, ye, yet = yet, oyt = oyt;
-    int xelim, ixls, xels, yelim, iyls, yels, p;
-    struct img_part *cur_part;
-#ifndef HAVE_LCD_COLOR
-    fb_data *dest = dest, *dest_t;
-#endif
-#ifdef HAVE_REMOTE_LCD
-    fb_remote_data *rdest = rdest, *rdest_t;
-#endif
-
-    SDEBUGF("scale_nearest sw=%d sh=%d dw=%d dh=%d remote=%d\n", sw, sh, dw,
-            dh, remote);
-    ly = 0;
-    iy = 0;
-    ye = 0;
-    xelim = sw == dw - 1 ? dw : dw - 1;
-    ixls = xelim ? sw / xelim : 1;
-    xels = sw - ixls * (xelim ? xelim : 1);
-    yelim = sh == dh - 1 ? dh : dh - 1;
-    iyls = yelim ? sh / yelim : 1;
-    yels = iyls * (yelim ? yelim : 1);
-    int delta = 127;
-#if LCD_PIXELFORMAT == HORIZONTAL_PACKING || \
-    (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_PIXELFORMAT == HORIZONTAL_PACKING)
-    uint8_t buf[4];
-    int data, oxt;
-#endif
-#if LCD_PIXELFORMAT == VERTICAL_PACKING || \
-    LCD_PIXELFORMAT == VERTICAL_INTERLEAVED || \
-    (defined(HAVE_REMOTE_LCD) && \
-    (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED || \
-    LCD_REMOTE_PIXELFORMAT == VERTICAL_PACKING))
-    int bright, shift;
-#endif
-    for (oy = rowstart; oy != rowstop;) {
-        SDEBUGF("oy=%d iy=%d\n", oy, iy);
-        if (last_tick != current_tick)
-        {
-            yield();
-            last_tick = current_tick;
-        }
-        if (iy > ly && !skip_lines(args, iy - ly - 1))
-            return false;
-        ly = iy;
-
-        cur_part = store_part(args);
-        if (cur_part == NULL)
-            return false;
-
-        lx = 0;
-        ix = 0;
-        xe = 0;
-#if defined(HAVE_REMOTE_LCD) && !defined(HAVE_LCD_COLOR) 
-        if(!remote)
+    int col;
+    int fb_width = BM_WIDTH(ctx->bm->width,FORMAT_NATIVE,0);
+    uint8_t dy = DITHERY(row);
+#ifdef HAVE_LCD_COLOR
+    struct uint32_rgb *qp = (struct uint32_rgb*)row_in;
 #else
-        (void)remote;
-#endif
-#if LCD_PIXELFORMAT == HORIZONTAL_PACKING
-            dest = (fb_data *)bitmap + fb_width * oy;
-#elif LCD_PIXELFORMAT == VERTICAL_PACKING
-            dest = (fb_data *)bitmap + fb_width * (oy >> 2);
-#elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED
-            dest = (fb_data *)bitmap + fb_width * (oy >> 3);
-#endif
-#ifdef HAVE_REMOTE_LCD
-#ifndef HAVE_LCD_COLOR 
-        else
-#endif
-            rdest = (fb_remote_data *)bitmap + fb_width * (oy >> 3);
-#endif
-        for (ox = 0; ox < dw; ox++) {
-            while (cur_part->len <= ix - lx)
-            {
-                lx += cur_part->len;
-                cur_part = store_part(args);
-                if (cur_part == NULL)
-                    return false;
-            }
-            cur_part->len -= ix - lx;
-            cur_part->buf += ix - lx;
-            lx = ix;
-#if defined(HAVE_REMOTE_LCD) && !defined(HAVE_LCD_COLOR) 
-            if(!remote)
-            {
+    uint32_t *qp = (uint32_t*)row_in;
 #endif
+    SDEBUGF("output_row: y: %d in: %p\n",row, row_in);
+#if LCD_DEPTH == 2
 #if LCD_PIXELFORMAT == HORIZONTAL_PACKING
                 /* greyscale iPods */
-                buf[ox & 3] = brightness(*(cur_part->buf));
-                if ((ox & 3) == 3 || ox == dw - 1)
-                {
-                    dest_t = dest++;
-                    oyt = oy;
-                    yet = ye;
-                    int xo = ox & ~3;
-                    while(yet < dh)
-                    {
+                fb_data *dest = (fb_data *)ctx->bm->data + fb_width * row;
+                int shift = 6;
+                int delta = 127;
+                unsigned bright;
+                unsigned data = 0;
+
+                for (col = 0; col < ctx->bm->width; col++) {
+                    if (ctx->dither)
+                        delta = DITHERXDY(col,dy);
+                    bright = ((*qp++) + ctx->round) *
+                             (uint64_t)ctx->divisor >> 32;
+                    bright = (3 * bright + (bright >> 6) + delta) >> 8;
+                    data |= (~bright & 3) << shift;
+                    shift -= 2;
+                    if (shift < 0) {
+                        *dest++ = data;
                         data = 0;
-                        for (oxt = 0; oxt < (ox & 3) + 1; oxt++)
-                        {
-                            if (dither)
-                                delta = dither_mat(oyt & 0xf, (xo + oxt) & 0xf);
-                            p = (3 * buf[oxt] + (buf[oxt] >> 6) + delta) >> 8;
-                            data |= (~p & 3) << ((3 - oxt) << 1);
-                        }
-                        *dest_t = data;
-                        dest_t += rowstep * fb_width;
-                        yet += sh;
-                        oyt += rowstep;
+                        shift = 6;
                     }
                 }
+                if (shift < 6)
+                    *dest++ = data;
 #elif LCD_PIXELFORMAT == VERTICAL_PACKING
                 /* iriver H1x0 */
-                bright = brightness(*(cur_part->buf));
-                dest_t = dest++;
-                oyt = oy;
-                yet = ye;
-                while(yet < dh)
-                {
-                    shift = (oyt & 3) << 1;
-                    if (dither)
-                        delta = dither_mat(oyt & 0xf, ox & 0xf);
+                fb_data *dest = (fb_data *)ctx->bm->data + fb_width *
+                                (row >> 2);
+                int shift = 2 * (row & 3);
+                int delta = 127;
+                unsigned bright;
 
-                    p = (3 * bright + (bright >> 6) + delta) >> 8;
-                    *dest_t |= (~p & 3) << shift;
-                    if ((rowstep > 0 && shift == 6) || shift == 0)
-                        dest_t += rowstep * fb_width;
-                    yet += sh;
-                    oyt += rowstep;
+                for (col = 0; col < ctx->bm->width; col++) {
+                    if (ctx->dither)
+                        delta = DITHERXDY(col,dy);
+                    bright = ((*qp++) + ctx->round) *
+                             (uint64_t)ctx->divisor >> 32;
+                    bright = (3 * bright + (bright >> 6) + delta) >> 8;
+                    *dest++ |= (~bright & 3) << shift;
                 }
 #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED
-                bright = brightness(*(cur_part->buf));
-                dest_t = dest++;
-                oyt = oy;
-                yet = ye;
-                while(yet < dh)
-                {
-                    shift = oyt & 7;
-                    if (dither)
-                        delta = dither_mat(oyt & 0xf, ox & 0xf);
+                /* iAudio M3 */
+                fb_data *dest = (fb_data *)ctx->bm->data + fb_width *
+                                (row >> 3);
+                int shift = row & 7;
+                int delta = 127;
+                unsigned bright;
 
-                    p = (3 * bright + (bright >> 6) + delta) >> 8;
-                    *dest_t |= vi_pat(p) << shift;
-                    if ((rowstep > 0 && shift == 7) || shift == 0)
-                        dest_t += rowstep * fb_width;
-                    yet += sh;
-                    oyt += rowstep;
+                for (col = 0; col < ctx->bm->width; col++) {
+                    if (ctx->dither)
+                        delta = DITHERXDY(col,dy);
+                    bright = ((*qp++) + ctx->round) *
+                             (uint64_t)ctx->divisor >> 32;
+                    bright = (3 * bright + (bright >> 6) + delta) >> 8;
+                    *dest++ |= vi_pattern[bright] << shift;
                 }
 #endif /* LCD_PIXELFORMAT */
-#ifdef HAVE_REMOTE_LCD
-#ifndef HAVE_LCD_COLOR
-            } else
-#endif
-            {
-#if LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED
-                bright = brightness(*(cur_part->buf));
-                rdest_t = rdest++;
-                oyt = oy;
-                yet = ye;
-                while(yet < dh)
-                {
-                    shift = oyt & 7;
-                    if (dither)
-                        delta = dither_mat(oyt & 0xf, ox & 0xf);
+#elif LCD_DEPTH == 16
+                /* iriver h300, colour iPods, X5 */
+                fb_data *dest = (fb_data *)ctx->bm->data + fb_width * row;
+                int delta = 127;
+                unsigned r, g, b;
+                struct uint32_rgb q0;
 
-                    p = (3 * bright + (bright >> 6) + delta) >> 8;
-                    *rdest_t |= vi_pat(p) << shift;
-                    if ((rowstep > 0 && shift == 7) || shift == 0)
-                        rdest_t += rowstep * fb_width;
-                    yet += sh;
-                    oyt += rowstep;
-                }
-#else
-                bright = brightness(*(cur_part->buf));
-                rdest_t = rdest++;
-                oyt = oy;
-                yet = ye;
-                while(yet < dh)
-                {
-                    shift = oyt & 7;
-                    if (dither)
-                        delta = dither_mat(oyt & 0xf, ox & 0xf);
-                    p = (bright + delta) >> 8;
-                    *rdest_t |= (~p & 1) << shift;
-                    if ((rowstep > 0 && shift == 7) || shift == 0)
-                        rdest_t += rowstep * fb_width;
-                    yet += sh;
-                    oyt += rowstep;
+                for (col = 0; col < ctx->bm->width; col++) {
+                    if (ctx->dither)
+                        delta = DITHERXDY(col,dy);
+                    q0 = *qp++;
+                    r = (q0.r + ctx->round) * (uint64_t)ctx->divisor >> 32;
+                    g = (q0.g + ctx->round) * (uint64_t)ctx->divisor >> 32;
+                    b = (q0.b + ctx->round) * (uint64_t)ctx->divisor >> 32;
+                    r = (31 * r + (r >> 3) + delta) >> 8;
+                    g = (63 * g + (g >> 2) + delta) >> 8;
+                    b = (31 * b + (b >> 3) + delta) >> 8;
+                    *dest++ = LCD_RGBPACK_LCD(r, g, b);
                 }
-#endif
-            }
-#endif
-            xe += xels;
-            ix += ixls;
-            while (xe > xelim)
-            {
-                xe -= xelim;
-                ix += 1;
-            }
-        }
-        oy = oyt;
-        ye = yet - yels;
-        iy += iyls;
-        while (ye > yelim)
-        {
-            ye -= yelim;
-            iy += 1;
-        }
-    }
-    return true;
+#endif /* LCD_DEPTH */
 }
-#endif
 
 int resize_on_load(struct bitmap *bm, bool dither, struct dim *src,
-                   struct rowset *rset, bool remote,
-#ifdef HAVE_LCD_COLOR
-                   unsigned char *buf, unsigned int len,
-#endif
+                   struct rowset *rset, unsigned char *buf, unsigned int len,
                    struct img_part* (*store_part)(void *args),
-                   bool (*skip_lines)(void *args, unsigned int lines), 
                    void *args)
 {
 
-#if defined(HAVE_LCD_COLOR) && !defined(HAVE_REMOTE_LCD)
-    (void)skip_lines;
+#ifdef HAVE_UPSCALER
+    const int sw = src->width;
+    const int sh = src->height;
+    const int dw = bm->width;
+    const int dh = bm->height;
 #endif
+    int ret;
 #ifdef HAVE_LCD_COLOR
-#ifdef HAVE_REMOTE_LCD
-        if (!remote)
-#endif
-        {
-#ifdef HAVE_UPSCALER
-            const int sw = src->width;
-            const int sh = src->height;
-            const int dw = bm->width;
-            const int dh = bm->height;
+    unsigned int needed = sizeof(struct uint32_rgb) * 3 * bm->width;
+#else
+    unsigned int needed = sizeof(uint32_t) * 3 * bm->width;
 #endif
-            int ret;
-            unsigned int needed = sizeof(struct uint32_rgb) * 2 * bm->width;
 #if MAX_SC_STACK_ALLOC
-            uint8_t sc_buf[(needed <= len  || needed > MAX_SC_STACK_ALLOC) ?
-                           0 : needed];
-            if (len && buf)
+    uint8_t sc_buf[(needed <= len  || needed > MAX_SC_STACK_ALLOC) ?
+                   0 : needed];
 #endif
-                len = (unsigned int)align_buffer(PUN_PTR(void**, &buf), len,
-                                                 sizeof(uint32_t));
-            if (needed > len)
-            {
+    len = (unsigned int)align_buffer(PUN_PTR(void**, &buf), len,
+                                         sizeof(uint32_t));
+    if (needed > len)
+    {
 #if MAX_SC_STACK_ALLOC
-                if (needed > MAX_SC_STACK_ALLOC)
-                {
-                    DEBUGF("unable to allocate required buffer: %d needed, "
-                           "%d available, %d permitted from stack\n",
-                           needed, len, MAX_SC_STACK_ALLOC);
-                    return 0;
-                }
-                if (sizeof(sc_buf) < needed)
-                {
-                    DEBUGF("failed to allocate large enough buffer on stack: "
-                           "%d needed, only got %d",
-                           needed, MAX_SC_STACK_ALLOC);
-                    return 0;
-                }
+        if (needed > MAX_SC_STACK_ALLOC)
+        {
+            DEBUGF("unable to allocate required buffer: %d needed, "
+                   "%d available, %d permitted from stack\n",
+                   needed, len, MAX_SC_STACK_ALLOC);
+            return 0;
+        }
+        if (sizeof(sc_buf) < needed)
+        {
+            DEBUGF("failed to allocate large enough buffer on stack: "
+                   "%d needed, only got %d",
+                   needed, MAX_SC_STACK_ALLOC);
+            return 0;
+        }
 #else
-                DEBUGF("unable to allocate required buffer: %d needed, "
-                       "%d available\n", needed, len);
-                return 0;
+        DEBUGF("unable to allocate required buffer: %d needed, "
+               "%d available\n", needed, len);
+        return 0;
 #endif
-            }
+    }
 
-            bool (*h_scaler)(struct bitmap*, struct dim*,
-                             struct uint32_rgb*,
-                             struct scaler_context*, bool);
-            struct scaler_context ctx;
-            ctx.last_tick = current_tick;
-            cpu_boost(true);
-#ifdef HAVE_UPSCALER
-            if (sw > dw)
-            {
-#endif
-                h_scaler = scale_h_area;
-                scale_h_area_setup(bm, src, &ctx); 
-#ifdef HAVE_UPSCALER
-            } else {
-                h_scaler = scale_h_linear;
-                scale_h_linear_setup(bm, src, &ctx);
-            }
-#endif
-            ctx.store_part = store_part;
-            ctx.args = args;
+    struct scaler_context ctx;
+    cpu_boost(true);
+    ctx.store_part = store_part;
+    ctx.args = args;
 #if MAX_SC_STACK_ALLOC
-            ctx.buf = needed > len ? sc_buf : buf;
+    ctx.buf = needed > len ? sc_buf : buf;
 #else
-            ctx.buf = buf;
+    ctx.buf = buf;
 #endif
-            ctx.len = len;
+    ctx.len = len;
+    ctx.bm = bm;
+    ctx.src = src;
+    ctx.dither = dither;
+    ctx.output_row = output_row_native;
 #ifdef HAVE_UPSCALER
-            if (sh > dh)
+    if (sw > dw)
+    {
 #endif
-                ret = scale_v_area(bm, dither, src, rset, h_scaler, &ctx);
+        ctx.h_scaler = scale_h_area;
+        scale_h_area_setup(&ctx);
 #ifdef HAVE_UPSCALER
-            else
-                ret = scale_v_linear(bm, dither, src, rset, h_scaler, &ctx);
+    } else {
+        ctx.h_scaler = scale_h_linear;
+        scale_h_linear_setup(&ctx);
+    }
 #endif
-            cpu_boost(false);
-            if (!ret)
-                return 0;
-        }
-#ifdef HAVE_REMOTE_LCD
-        else
+#ifdef HAVE_UPSCALER
+    if (sh > dh)
 #endif
-#endif /* HAVE_LCD_COLOR */
-#if !defined(HAVE_LCD_COLOR) || defined(HAVE_REMOTE_LCD)
-        {
-            if (!scale_nearest(bm, src, rset, remote, dither, store_part,
-                skip_lines, args))
-                return 0;
-        }
-#endif /* !HAVE_LCD_COLOR || HAVE_REMOTE_LCD*/
-    return get_totalsize(bm, remote);
+        ret = scale_v_area(rset, &ctx);
+#ifdef HAVE_UPSCALER
+    else
+        ret = scale_v_linear(rset, &ctx);
+#endif
+    cpu_boost(false);
+    if (!ret)
+        return 0;
+    return BM_SIZE(bm->width,bm->height,bm->format,0);
 }