apps/recorder/bmp.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 /*
  23 2005-04-16 Tomas Salfischberger:
  24  - New BMP loader function, based on the old one (borrowed a lot of
  25    calculations and checks there.)
  26  - Conversion part needs some optimization, doing unneeded calulations now.
  27 2006-11-18 Jens Arnold: complete rework
  28  - All canonical formats supported now (1, 4, 8, 15/16, 24 and 32 bit)
  29  - better protection against malformed / non-standard BMPs
  30  - code heavily optimised for both size and speed
  31  - dithering for 2 bit targets
  32 2008-11-02 Akio Idehara: refactor for scaler frontend
  33 2008-12-08 Andrew Mahone: partial-line reading, scaler frontend
  34  - read_part_line does the actual source BMP reading, return columns read
  35    and updates fields in a struct bmp_args with the new data and current
  36    reader state
  37  - skip_lines_bmp and store_part_bmp implement the scaler callbacks to skip
  38    ahead by whole lines, or read the next chunk of the current line
  39 */
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include "inttypes.h"
  45 #include "system.h"
  46 #ifndef PLUGIN
  47 #include "debug.h"
  48 #endif
  49 #include "lcd.h"
  50 #include "file.h"
  51 #include "bmp.h"
  52 #ifdef HAVE_REMOTE_LCD
  53 #include "lcd-remote.h"
  54 #endif
  55 #ifdef ROCKBOX_DEBUG_BMP_LOADER
  56 #define BDEBUGF DEBUGF
  57 #else
  58 #define BDEBUGF(...)
  59 #endif
  60 #ifndef __PCTOOL__
  61 #include "config.h"
  62 #include "resize.h"
  63 #else
  64 #undef DEBUGF
  65 #define DEBUGF(...)
  66 #endif
  67
  68 #ifdef __GNUC__
  69 #define STRUCT_PACKED __attribute__((packed))
  70 #else
  71 #define STRUCT_PACKED
  72 #pragma pack (push, 2)
  73 #endif
  74
  75 /* BMP header structure */
  76 struct bmp_header {
  77     uint16_t type;          /* signature - 'BM' */
  78     uint32_t size;          /* file size in bytes */
  79     uint16_t reserved1;     /* 0 */
  80     uint16_t reserved2;     /* 0 */
  81     uint32_t off_bits;      /* offset to bitmap */
  82     uint32_t struct_size;   /* size of this struct (40) */
  83     int32_t width;          /* bmap width in pixels */
  84     int32_t height;         /* bmap height in pixels */
  85     uint16_t planes;        /* num planes - always 1 */
  86     uint16_t bit_count;     /* bits per pixel */
  87     uint32_t compression;   /* compression flag */
  88     uint32_t size_image;    /* image size in bytes */
  89     int32_t x_pels_per_meter;   /* horz resolution */
  90     int32_t y_pels_per_meter;   /* vert resolution */
  91     uint32_t clr_used;      /* 0 -> color table size */
  92     uint32_t clr_important; /* important color count */
  93 } STRUCT_PACKED;
  94
  95 union rgb_union {
  96     struct { /* Little endian */
  97         unsigned char blue;
  98         unsigned char green;
  99         unsigned char red;
 100         unsigned char reserved;
 101     };
 102     uint32_t raw;
 103 };
 104
 105 /* masks for supported BI_BITFIELDS encodings (16/32 bit) */
 106 static const struct uint8_rgb bitfields[3][3] = {
 107     /* 15bit */
 108     {
 109         { .blue = 0x00, .green = 0x7c, .red = 0x00 },
 110         { .blue = 0xe0, .green = 0x03, .red = 0x00 },
 111         { .blue = 0x1f, .green = 0x00, .red = 0x00 },
 112     },
 113     /* 16bit */
 114     {
 115         { .blue = 0x00, .green = 0xf8, .red = 0x00 },
 116         { .blue = 0xe0, .green = 0x07, .red = 0x00 },
 117         { .blue = 0x1f, .green = 0x00, .red = 0x00 },
 118     },
 119     /* 32bit */
 120     {
 121         { .blue = 0x00, .green = 0x00, .red = 0xff },
 122         { .blue = 0x00, .green = 0xff, .red = 0x00 },
 123         { .blue = 0xff, .green = 0x00, .red = 0x00 },
 124     },
 125 };
 126
 127 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
 128 /* the full 16x16 Bayer dither matrix may be calculated quickly with this table
 129 */
 130 const unsigned char dither_table[16] =
 131     {   0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255 };
 132 #endif
 133
 134 #if ((LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)) \
 135  || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH == 2) \
 136      && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED))
 137 const unsigned short vi_pattern[4] = {
 138     0x0101, 0x0100, 0x0001, 0x0000
 139 };
 140 #endif
 141
 142 /******************************************************************************
 143  * read_bmp_file()
 144  *
 145  * Reads a BMP file and puts the data in rockbox format in *bitmap.
 146  *
 147  *****************************************************************************/
 148 int read_bmp_file(const char* filename,
 149                   struct bitmap *bm,
 150                   int maxsize,
 151                   int format,
 152                   const struct custom_format *cformat)
 153 {
 154     int fd, ret;
 155     fd = open(filename, O_RDONLY);
 156
 157     /* Exit if file opening failed */
 158     if (fd < 0) {
 159         DEBUGF("read_bmp_file: can't open '%s', rc: %d\n", filename, fd);
 160         return fd * 10 - 1;
 161     }
 162
 163     BDEBUGF("read_bmp_file: '%s' remote: %d resize: %d keep_aspect: %d\n",
 164            filename, !!(format & FORMAT_REMOTE), !!(format & FORMAT_RESIZE),
 165            !!(format & FORMAT_KEEP_ASPECT));
 166     ret = read_bmp_fd(fd, bm, maxsize, format, cformat);
 167     close(fd);
 168     return ret;
 169 }
 170
 171 static inline void set_rgb_union(struct uint8_rgb *dst, union rgb_union src)
 172 {
 173     dst->red = src.red;
 174     dst->green = src.green;
 175     dst->blue = src.blue;
 176 }
 177
 178 struct bmp_args {
 179     int fd;
 180     short padded_width;
 181     short read_width;
 182     short width;
 183     short depth;
 184     unsigned char buf[BM_MAX_WIDTH * 4];
 185     struct uint8_rgb *palette;
 186 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 187     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 188     int cur_row;
 189     int cur_col;
 190     struct img_part part;
 191 #endif
 192 };
 193
 194 static unsigned int read_part_line(struct bmp_args *ba)
 195 {
 196     const int padded_width = ba->padded_width;
 197     const int read_width = ba->read_width;
 198     const int width = ba->width;
 199     const int depth = ba->depth;
 200 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 201     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 202     int cur_row = ba->cur_row;
 203     int cur_col = ba->cur_col;
 204 #endif
 205     const int fd = ba->fd;
 206     uint8_t *ibuf;
 207     struct uint8_rgb *buf = (struct uint8_rgb *)(ba->buf);
 208     const struct uint8_rgb *palette = ba->palette;
 209     uint32_t component, data = data;
 210     int ret;
 211     int i, cols, len;
 212
 213 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 214     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 215     cols = MIN(width - cur_col,(int)BM_MAX_WIDTH);
 216     BDEBUGF("reading %d cols (width: %d, max: %d)\n",cols,width,BM_MAX_WIDTH);
 217     len = (cols * (depth == 15 ? 16 : depth) + 7) >> 3;
 218 #else
 219     cols = width;
 220     len = read_width;
 221 #endif
 222     ibuf = ((unsigned char *)buf) + (BM_MAX_WIDTH << 2) - len;
 223     BDEBUGF("read_part_line: cols=%d len=%d\n",cols,len);
 224     ret = read(fd, ibuf, len);
 225     if (ret != len)
 226     {
 227         DEBUGF("read_part_line: error reading image, read returned %d "
 228                "expected %d\n", ret, len);
 229 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 230     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 231         BDEBUGF("cur_row: %d cur_col: %d cols: %d len: %d\n", cur_row, cur_col,
 232                 cols, len);
 233 #endif
 234         return 0;
 235     }
 236     while (ibuf < ba->buf + (BM_MAX_WIDTH << 2))
 237     {
 238         switch (depth)
 239         {
 240           case 1:
 241             data = *ibuf++;
 242             for (i = 0; i < 8; i++)
 243             {
 244                 *buf++ = palette[data & 0x80 ? 1 : 0];
 245                 data <<= 1;
 246             }
 247             break;
 248           case 4:
 249             data = *ibuf++;
 250             *buf++ = palette[data >> 4];
 251             *buf++ = palette[data & 0xf];
 252             break;
 253           case 8:
 254             *buf++ = palette[*ibuf++];
 255             break;
 256           case 15:
 257           case 16:
 258             data = letoh16(*(uint16_t*)ibuf);
 259             component = (data << 3) & 0xf8;
 260             component |= component >> 5;
 261             buf->blue = component;
 262             if (depth == 15)
 263             {
 264                 data >>= 2;
 265                 component = data & 0xf8;
 266                 component |= component >> 5;
 267             } else {
 268                 data >>= 3;
 269                 component = data & 0xfc;
 270                 component |= component >> 6;
 271             }
 272             buf->green = component;
 273             data >>= 5;
 274             component = data & 0xf8;
 275             component |= component >> 5;
 276             buf->red = component;
 277             buf++;
 278             ibuf += 2;
 279             break;
 280           case 32:
 281           case 24:
 282             buf->blue = *ibuf++;
 283             buf->green = *ibuf++;
 284             buf->red = *ibuf++;
 285             if (depth == 32)
 286                 ibuf++;
 287             buf++;
 288             break;
 289         }
 290     }
 291
 292 #if !defined(HAVE_LCD_COLOR) && \
 293     ((LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
 294     defined(PLUGIN))
 295     ibuf = ba->buf;
 296     buf = (struct uint8_rgb*)ba->buf;
 297     while (ibuf < ba->buf + cols)
 298         *ibuf++ = brightness(*buf++);
 299 #endif
 300
 301 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 302     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 303     cur_col += cols;
 304     if (cur_col == width)
 305     {
 306 #endif
 307         int pad = padded_width - read_width;
 308         if (pad > 0)
 309         {
 310             BDEBUGF("seeking %d bytes to next line\n",pad);
 311             lseek(fd, pad, SEEK_CUR);
 312         }
 313 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 314     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 315         cur_col = 0;
 316         BDEBUGF("read_part_line: completed row %d\n", cur_row);
 317         cur_row += 1;
 318     }
 319
 320     ba->cur_row = cur_row;
 321     ba->cur_col = cur_col;
 322 #endif
 323     return cols;
 324 }
 325
 326 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 327     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 328 static struct img_part *store_part_bmp(void *args)
 329 {
 330     struct bmp_args *ba = (struct bmp_args *)args;
 331
 332     ba->part.len = read_part_line(ba);
 333 #ifdef HAVE_LCD_COLOR
 334     ba->part.buf = (struct uint8_rgb *)ba->buf;
 335 #else
 336     ba->part.buf = (uint8_t *)ba->buf;
 337 #endif
 338     if (ba->part.len)
 339         return &(ba->part);
 340     else
 341         return NULL;
 342 }
 343 #endif
 344
 345 static inline int rgbcmp(struct uint8_rgb rgb1, struct uint8_rgb rgb2)
 346 {
 347     if ((rgb1.red == rgb2.red) && (rgb1.green == rgb2.green) &&
 348         (rgb1.blue == rgb2.blue))
 349         return 0;
 350     else
 351         return 1;
 352 }
 353 #if LCD_DEPTH > 1
 354 #if !defined(PLUGIN) && !defined(HAVE_JPEG) && !defined(HAVE_BMP_SCALING)
 355 static inline
 356 #endif
 357 void output_row_8_native(uint32_t row, void * row_in,
 358                               struct scaler_context *ctx)
 359 {
 360     int col;
 361     int fb_width = BM_WIDTH(ctx->bm->width,FORMAT_NATIVE,0);
 362     uint8_t dy = DITHERY(row);
 363 #ifdef HAVE_LCD_COLOR
 364     struct uint8_rgb *qp = (struct uint8_rgb*)row_in;
 365 #else
 366     uint8_t *qp = (uint8_t*)row_in;
 367 #endif
 368     BDEBUGF("output_row: y: %lu in: %p\n",row, row_in);
 369 #if LCD_DEPTH == 2
 370 #if LCD_PIXELFORMAT == HORIZONTAL_PACKING
 371                 /* greyscale iPods */
 372                 fb_data *dest = (fb_data *)ctx->bm->data + fb_width * row;
 373                 int shift = 6;
 374                 int delta = 127;
 375                 unsigned bright;
 376                 unsigned data = 0;
 377
 378                 for (col = 0; col < ctx->bm->width; col++) {
 379                     if (ctx->dither)
 380                         delta = DITHERXDY(col,dy);
 381                     bright = *qp++;
 382                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 383                     data |= (~bright & 3) << shift;
 384                     shift -= 2;
 385                     if (shift < 0) {
 386                         *dest++ = data;
 387                         data = 0;
 388                         shift = 6;
 389                     }
 390                 }
 391                 if (shift < 6)
 392                     *dest++ = data;
 393 #elif LCD_PIXELFORMAT == VERTICAL_PACKING
 394                 /* iriver H1x0 */
 395                 fb_data *dest = (fb_data *)ctx->bm->data + fb_width *
 396                                 (row >> 2);
 397                 int shift = 2 * (row & 3);
 398                 int delta = 127;
 399                 unsigned bright;
 400
 401                 for (col = 0; col < ctx->bm->width; col++) {
 402                     if (ctx->dither)
 403                         delta = DITHERXDY(col,dy);
 404                     bright = *qp++;
 405                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 406                     *dest++ |= (~bright & 3) << shift;
 407                 }
 408 #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED
 409                 /* iAudio M3 */
 410                 fb_data *dest = (fb_data *)ctx->bm->data + fb_width *
 411                                 (row >> 3);
 412                 int shift = row & 7;
 413                 int delta = 127;
 414                 unsigned bright;
 415
 416                 for (col = 0; col < ctx->bm->width; col++) {
 417                     if (ctx->dither)
 418                         delta = DITHERXDY(col,dy);
 419                     bright = *qp++;
 420                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 421                     *dest++ |= vi_pattern[bright] << shift;
 422                 }
 423 #endif /* LCD_PIXELFORMAT */
 424 #elif LCD_DEPTH == 16
 425 #if   defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE
 426                 /* M:Robe 500 */
 427                 (void) fb_width;
 428                 fb_data *dest = (fb_data *)ctx->bm->data + row;
 429                 int delta = 127;
 430                 unsigned r, g, b;
 431                 for (col = 0; col < ctx->bm->width; col++) {
 432                     if (ctx->dither)
 433                         delta = DITHERXDY(col,dy);
 434                     r = qp->red;
 435                     g = qp->green;
 436                     b = (qp++)->blue;
 437                     r = (31 * r + (r >> 3) + delta) >> 8;
 438                     g = (63 * g + (g >> 2) + delta) >> 8;
 439                     b = (31 * b + (b >> 3) + delta) >> 8;
 440                     *dest = LCD_RGBPACK_LCD(r, g, b);
 441                     dest += ctx->bm->height;
 442                 }
 443 #else
 444                 /* iriver h300, colour iPods, X5 */
 445                 fb_data *dest = (fb_data *)ctx->bm->data + fb_width * row;
 446                 int delta = 127;
 447                 unsigned r, g, b;
 448                 for (col = 0; col < ctx->bm->width; col++) {
 449                     if (ctx->dither)
 450                         delta = DITHERXDY(col,dy);
 451                     r = qp->red;
 452                     g = qp->green;
 453                     b = (qp++)->blue;
 454                     r = (31 * r + (r >> 3) + delta) >> 8;
 455                     g = (63 * g + (g >> 2) + delta) >> 8;
 456                     b = (31 * b + (b >> 3) + delta) >> 8;
 457                     *dest++ = LCD_RGBPACK_LCD(r, g, b);
 458                 }
 459 #endif
 460 #endif /* LCD_DEPTH */
 461 }
 462 #endif
 463
 464 /******************************************************************************
 465  * read_bmp_fd()
 466  *
 467  * Reads a BMP file in an open file descriptor and puts the data in rockbox
 468  * format in *bitmap.
 469  *
 470  *****************************************************************************/
 471 int read_bmp_fd(int fd,
 472                 struct bitmap *bm,
 473                 int maxsize,
 474                 int format,
 475                 const struct custom_format *cformat)
 476 {
 477     struct bmp_header bmph;
 478     int padded_width;
 479     int read_width;
 480     int depth, numcolors, compression, totalsize;
 481     int ret;
 482     bool return_size = format & FORMAT_RETURN_SIZE;
 483
 484     unsigned char *bitmap = bm->data;
 485     struct uint8_rgb palette[256];
 486     struct rowset rset;
 487     struct dim src_dim;
 488 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
 489     defined(PLUGIN)
 490     bool dither = false;
 491 #endif
 492 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 493     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 494     unsigned int resize = IMG_NORESIZE;
 495     bool transparent = false;
 496
 497 #ifdef HAVE_REMOTE_LCD
 498     bool remote = false;
 499     if (format & FORMAT_REMOTE) {
 500         remote = true;
 501 #if LCD_REMOTE_DEPTH == 1
 502         format = FORMAT_MONO;
 503 #endif
 504     }
 505 #endif /* HAVE_REMOTE_LCD */
 506
 507     if (format & FORMAT_RESIZE) {
 508         resize = IMG_RESIZE;
 509     }
 510
 511     if (format & FORMAT_TRANSPARENT) {
 512         transparent = true;
 513     }
 514 #else
 515
 516     (void)format;
 517 #endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
 518 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
 519     defined(PLUGIN)
 520     if (format & FORMAT_DITHER) {
 521         dither = true;
 522     }
 523 #endif
 524     /* read fileheader */
 525     ret = read(fd, &bmph, sizeof(struct bmp_header));
 526     if (ret < 0) {
 527         return ret * 10 - 2;
 528     }
 529
 530     if (ret != sizeof(struct bmp_header)) {
 531         DEBUGF("read_bmp_fd: can't read BMP header.");
 532         return -3;
 533     }
 534
 535     src_dim.width = letoh32(bmph.width);
 536     src_dim.height = letoh32(bmph.height);
 537     if (src_dim.height < 0) {     /* Top-down BMP file */
 538         src_dim.height = -src_dim.height;
 539         rset.rowstep = 1;
 540     } else {              /* normal BMP */
 541         rset.rowstep = -1;
 542     }
 543
 544     depth = letoh16(bmph.bit_count);
 545     /* 4-byte boundary aligned */
 546     read_width = ((src_dim.width * (depth == 15 ? 16 : depth) + 7) >> 3);
 547     padded_width = (read_width + 3) & ~3;
 548
 549     BDEBUGF("width: %d height: %d depth: %d padded_width: %d\n", src_dim.width,
 550             src_dim.height, depth, padded_width);
 551
 552 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 553     if ((format & 3) == FORMAT_ANY) {
 554         if (depth == 1)
 555             format = (format & ~3);
 556         else
 557             format = (format & ~3) | FORMAT_NATIVE;
 558     }
 559     bm->format = format & 1;
 560     if ((format & 1) == FORMAT_MONO)
 561     {
 562 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 563     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 564         resize &= ~IMG_RESIZE;
 565         resize |= IMG_NORESIZE;
 566 #endif
 567 #ifdef HAVE_REMOTE_LCD
 568         remote = 0;
 569 #endif
 570     }
 571 #elif !defined(PLUGIN)
 572     if (src_dim.width > BM_MAX_WIDTH)
 573             return -6;
 574 #endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
 575
 576 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 577     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 578     if (resize & IMG_RESIZE) {
 579         if(format & FORMAT_KEEP_ASPECT) {
 580             /* keep aspect ratio.. */
 581             struct dim resize_dim = {
 582                 .width = bm->width,
 583                 .height = bm->height,
 584             };
 585             if (recalc_dimension(&resize_dim, &src_dim))
 586                 resize = IMG_NORESIZE;
 587             bm->width = resize_dim.width;
 588             bm->height = resize_dim.height;
 589         }
 590     }
 591
 592     if (!(resize & IMG_RESIZE)) {
 593 #endif
 594         /* returning image size */
 595         bm->width = src_dim.width;
 596         bm->height = src_dim.height;
 597
 598 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 599     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 600     }
 601 #endif
 602 #if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 603     format &= 1;
 604 #endif
 605     if (rset.rowstep > 0) {     /* Top-down BMP file */
 606         rset.rowstart = 0;
 607         rset.rowstop = bm->height;
 608     } else {              /* normal BMP */
 609         rset.rowstart = bm->height - 1;
 610         rset.rowstop = -1;
 611     }
 612
 613     if (cformat)
 614         totalsize = cformat->get_size(bm);
 615     else
 616         totalsize = BM_SIZE(bm->width,bm->height,format,remote);
 617
 618     if(return_size)
 619     {
 620 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 621     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 622         if(resize)
 623             totalsize += BM_SCALED_SIZE(bm->width, 0, 0, 0);
 624         else if (bm->width > BM_MAX_WIDTH)
 625             totalsize += bm->width*4;
 626 #endif
 627         return totalsize;
 628     }
 629
 630     /* Check if this fits the buffer */
 631     if (totalsize > maxsize) {
 632         DEBUGF("read_bmp_fd: Bitmap too large for buffer: "
 633                "%d bytes.\n", totalsize);
 634         return -6;
 635     }
 636
 637     compression = letoh32(bmph.compression);
 638     if (depth <= 8) {
 639         numcolors = letoh32(bmph.clr_used);
 640         if (numcolors == 0)
 641             numcolors = BIT_N(depth);
 642     } else
 643         numcolors = (compression == 3) ? 3 : 0;
 644
 645     if (numcolors > 0 && numcolors <= 256) {
 646         int i;
 647         union rgb_union pal;
 648         for (i = 0; i < numcolors; i++) {
 649             if (read(fd, &pal, sizeof(pal)) != (int)sizeof(pal))
 650             {
 651                 DEBUGF("read_bmp_fd: Can't read color palette\n");
 652                 return -7;
 653             }
 654             set_rgb_union(&palette[i], pal);
 655         }
 656     }
 657
 658     switch (depth) {
 659       case 16:
 660 #if LCD_DEPTH >= 16
 661         /* don't dither 16 bit BMP to LCD with same or larger depth */
 662 #ifdef HAVE_REMOTE_LCD
 663         if (!remote)
 664 #endif
 665             dither = false;
 666 #endif
 667         if (compression == 0) { /* BI_RGB, i.e. 15 bit */
 668             depth = 15;
 669             break;
 670         }   /* else fall through */
 671
 672       case 32:
 673         if (compression == 3) { /* BI_BITFIELDS */
 674             bool found;
 675             int i, j;
 676
 677             /* (i == 0) is 15bit, (i == 1) is 16bit, (i == 2) is 32bit */
 678             for (i = 0; i < ARRAY_SIZE(bitfields); i++) {
 679                 for (j = 0; j < ARRAY_SIZE(bitfields[0]); j++) {
 680                     if (!rgbcmp(palette[j], bitfields[i][j])) {
 681                         found = true;
 682                     } else {
 683                         found = false;
 684                         break;
 685                     }
 686                 }
 687                 if (found) {
 688                     if (i == 0) /* 15bit */
 689                         depth = 15;
 690                     break;
 691                 }
 692             }
 693             if (found)
 694                 break;
 695         }   /* else fall through */
 696
 697       default:
 698         if (compression != 0) { /* not BI_RGB */
 699             DEBUGF("read_bmp_fd: Unsupported compression (type %d)\n",
 700                    compression);
 701             return -8;
 702         }
 703         break;
 704     }
 705
 706     /* Search to the beginning of the image data */
 707     lseek(fd, (off_t)letoh32(bmph.off_bits), SEEK_SET);
 708
 709     memset(bitmap, 0, totalsize);
 710
 711     struct bmp_args ba = {
 712         .fd = fd, .padded_width = padded_width, .read_width = read_width,
 713         .width = src_dim.width, .depth = depth, .palette = palette,
 714 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 715     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 716         .cur_row = 0, .cur_col = 0, .part = {0,0}
 717 #endif
 718     };
 719
 720 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 721     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 722     if (resize)
 723     {
 724         if (resize_on_load(bm, dither, &src_dim, &rset,
 725                            bitmap + totalsize, maxsize - totalsize,
 726                            cformat, IF_PIX_FMT(0,) store_part_bmp, &ba))
 727             return totalsize;
 728         else
 729             return 0;
 730     }
 731 #endif /* LCD_DEPTH */
 732
 733 #if LCD_DEPTH > 1 || defined(PLUGIN)
 734     struct scaler_context ctx = {
 735         .bm = bm,
 736         .dither = dither,
 737     };
 738 #endif
 739 #if defined(PLUGIN) || defined(HAVE_JPEG) || defined(HAVE_BMP_SCALING)
 740 #if LCD_DEPTH > 1
 741     void (*output_row_8)(uint32_t, void*, struct scaler_context*) =
 742         output_row_8_native;
 743 #elif defined(PLUGIN)
 744     void (*output_row_8)(uint32_t, void*, struct scaler_context*) = NULL;
 745 #endif
 746 #if LCD_DEPTH > 1 || defined(PLUGIN)
 747     if (cformat)
 748         output_row_8 = cformat->output_row_8;
 749 #endif
 750 #endif
 751
 752     unsigned char *buf = ba.buf;
 753 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
 754     defined(PLUGIN)
 755     if (bm->width > BM_MAX_WIDTH)
 756     {
 757 #if defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 758         unsigned int len = maxsize - totalsize;
 759         buf = bitmap + totalsize;
 760         ALIGN_BUFFER(buf, len, sizeof(uint32_t));
 761         if (bm->width*4 > (int)len)
 762 #endif
 763             return -6;
 764     }
 765 #endif
 766
 767     int row;
 768     /* loop to read rows and put them to buffer */
 769     for (row = rset.rowstart; row != rset.rowstop; row += rset.rowstep) {
 770 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
 771     defined(HAVE_BMP_SCALING) || defined(PLUGIN)
 772         if (bm->width > BM_MAX_WIDTH)
 773         {
 774 #if defined(HAVE_LCD_COLOR)
 775             struct uint8_rgb *p = (struct uint8_rgb *)buf;
 776 #else
 777             uint8_t* p = buf;
 778 #endif
 779             do {
 780                 int len = read_part_line(&ba);
 781                 if (!len)
 782                     return -9;
 783                 memcpy(p, ba.buf, len*sizeof(*p));
 784                 p += len;
 785             } while (ba.cur_col);
 786         }
 787         else
 788 #endif
 789         if (!read_part_line(&ba))
 790             return -9;
 791 #ifndef PLUGIN
 792 #if !defined(HAVE_LCD_COLOR) && \
 793         (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
 794         uint8_t* qp = buf;
 795 #else
 796         struct uint8_rgb *qp = (struct uint8_rgb *)buf;
 797 #endif
 798 #endif
 799         /* Convert to destination format */
 800 #if ((LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) && \
 801     !defined(PLUGIN)
 802         if (format == FORMAT_NATIVE) {
 803 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 804             if (remote) {
 805                 unsigned char dy = DITHERY(row);
 806 #if (LCD_REMOTE_DEPTH == 2) && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED)
 807                 /* iAudio X5/M5 remote */
 808                 fb_remote_data *dest = (fb_remote_data *)bitmap
 809                                      + bm->width * (row >> 3);
 810                 int shift = row & 7;
 811                 int delta = 127;
 812                 unsigned bright;
 813
 814                 int col;
 815                 for (col = 0; col < bm->width; col++) {
 816                     if (dither)
 817                         delta = DITHERXDY(col,dy);
 818 #if !defined(HAVE_LCD_COLOR) && \
 819         (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
 820                     bright = *qp++;
 821 #else
 822                     bright = brightness(*qp++);
 823 #endif
 824                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 825                     *dest++ |= vi_pattern[bright] << shift;
 826                 }
 827 #endif /* LCD_REMOTE_DEPTH / LCD_REMOTE_PIXELFORMAT */
 828             } else
 829 #endif /* defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1 */
 830 #endif /* (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) &&
 831     (LCD_REMOTE_DEPTH > 1) */
 832 #if LCD_DEPTH > 1 || defined(PLUGIN)
 833             {
 834 #if !defined(PLUGIN) && !defined(HAVE_JPEG) && !defined(HAVE_BMP_SCALING)
 835                 output_row_8_native(row, buf, &ctx);
 836 #else
 837                 output_row_8(row, buf, &ctx);
 838 #endif
 839             }
 840 #endif
 841 #if ((LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) && \
 842     !defined(PLUGIN)
 843         }
 844 #ifndef PLUGIN
 845         else
 846 #endif
 847 #endif
 848 #ifndef PLUGIN
 849         {
 850             unsigned char *p = bitmap + bm->width * (row >> 3);
 851             unsigned char mask = BIT_N(row & 7);
 852             int col;
 853             for (col = 0; col < bm->width; col++, p++)
 854 #if !defined(HAVE_LCD_COLOR) && \
 855         (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
 856                 if (*qp++ < 128)
 857                     *p |= mask;
 858 #else
 859                 if (brightness(*qp++) < 128)
 860                     *p |= mask;
 861 #endif
 862         }
 863 #endif
 864     }
 865     return totalsize; /* return the used buffer size. */
 866 }