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  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 /*
  21 2005-04-16 Tomas Salfischberger:
  22  - New BMP loader function, based on the old one (borrowed a lot of
  23    calculations and checks there.)
  24  - Conversion part needs some optimization, doing unneeded calulations now.
  25 2006-11-18 Jens Arnold: complete rework
  26  - All canonical formats supported now (1, 4, 8, 15/16, 24 and 32 bit)
  27  - better protection against malformed / non-standard BMPs
  28  - code heavily optimised for both size and speed
  29  - dithering for 2 bit targets
  30 */
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include "inttypes.h"
  36 #include "debug.h"
  37 #include "lcd.h"
  38 #ifdef HAVE_REMOTE_LCD
  39 #include "lcd-remote.h"
  40 #endif
  41 #include "file.h"
  42 #include "config.h"
  43 #include "system.h"
  44 #include "bmp.h"
  45 #include "lcd.h"
  46
  47 #ifdef __GNUC__
  48 #define STRUCT_PACKED __attribute__((packed))
  49 #else
  50 #define STRUCT_PACKED
  51 #pragma pack (push, 2)
  52 #endif
  53
  54 /* BMP header structure */
  55 struct bmp_header {
  56     uint16_t type;          /* signature - 'BM' */
  57     uint32_t size;          /* file size in bytes */
  58     uint16_t reserved1;     /* 0 */
  59     uint16_t reserved2;     /* 0 */
  60     uint32_t off_bits;      /* offset to bitmap */
  61     uint32_t struct_size;   /* size of this struct (40) */
  62     uint32_t width;         /* bmap width in pixels */
  63     uint32_t height;        /* bmap height in pixels */
  64     uint16_t planes;        /* num planes - always 1 */
  65     uint16_t bit_count;     /* bits per pixel */
  66     uint32_t compression;   /* compression flag */
  67     uint32_t size_image;    /* image size in bytes */
  68     int32_t x_pels_per_meter;   /* horz resolution */
  69     int32_t y_pels_per_meter;   /* vert resolution */
  70     uint32_t clr_used;      /* 0 -> color table size */
  71     uint32_t clr_important; /* important color count */
  72 } STRUCT_PACKED;
  73
  74 union rgb_union {
  75     struct { /* Little endian */
  76         unsigned char blue;
  77         unsigned char green;
  78         unsigned char red;
  79         unsigned char reserved;
  80     };
  81     uint32_t raw;
  82 };
  83
  84 /* masks for supported BI_BITFIELDS encodings (16/32 bit), little endian */
  85 static const unsigned char bitfields[3][12] = {
  86     { 0x00,0x7c,0x00,0,  0xe0,0x03,0x00,0,  0x1f,0x00,0x00,0 }, /* 15 bit */
  87     { 0x00,0xf8,0x00,0,  0xe0,0x07,0x00,0,  0x1f,0x00,0x00,0 }, /* 16 bit */
  88     { 0x00,0x00,0xff,0,  0x00,0xff,0x00,0,  0xff,0x00,0x00,0 }, /* 32 bit */
  89 };
  90
  91 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
  92 /* canonical ordered dither matrix */
  93 static const unsigned char dither_matrix[16][16] = {
  94     {   0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255 },
  95     { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
  96     {  32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
  97     { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
  98     {   8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247 },
  99     { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
 100     {  40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
 101     { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
 102     {   2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253 },
 103     { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
 104     {  34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
 105     { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
 106     {  10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245 },
 107     { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
 108     {  42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
 109     { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
 110 };
 111 #endif
 112
 113 #if defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH == 2) \
 114     && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED)
 115 static const fb_remote_data remote_pattern[4] = {
 116     0x0101, 0x0100, 0x0001, 0x0000
 117 };
 118 #endif
 119
 120 /* little endian functions */
 121 static inline unsigned readshort(uint16_t *value)
 122 {
 123     unsigned char* bytes = (unsigned char*) value;
 124     return (unsigned)bytes[0] | ((unsigned)bytes[1] << 8);
 125 }
 126
 127 static inline uint32_t readlong(uint32_t *value)
 128 {
 129     unsigned char* bytes = (unsigned char*) value;
 130     return (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) |
 131            ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
 132 }
 133
 134 static inline unsigned brightness(union rgb_union color)
 135 {
 136     return (3 * (unsigned)color.red + 6 * (unsigned)color.green
 137               + (unsigned)color.blue) / 10;
 138 }
 139
 140 /******************************************************************************
 141  * read_bmp_file()
 142  *
 143  * Reads a BMP file and puts the data in rockbox format in *bitmap.
 144  *
 145  *****************************************************************************/
 146 int read_bmp_file(char* filename,
 147                   struct bitmap *bm,
 148                   int maxsize,
 149                   int format)
 150 {
 151     struct bmp_header bmph;
 152     int width, height, padded_width;
 153     int dst_height, dst_width;
 154     int fd, row, col, ret;
 155     int depth, numcolors, compression, totalsize;
 156
 157     unsigned char *bitmap = bm->data;
 158     uint32_t bmpbuf[LCD_WIDTH]; /* Buffer for one line */
 159     uint32_t palette[256];
 160 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
 161     bool transparent = false;
 162     bool dither = false;
 163 #ifdef HAVE_REMOTE_LCD
 164     bool remote = false;
 165
 166     if (format & FORMAT_REMOTE) {
 167         remote = true;
 168 #if LCD_REMOTE_DEPTH == 1
 169         format = FORMAT_MONO;
 170 #else
 171         format &= ~FORMAT_REMOTE;
 172 #endif
 173     }
 174 #endif /* HAVE_REMOTE_LCD */
 175     if (format & FORMAT_TRANSPARENT) {
 176         transparent = true;
 177         format &= ~FORMAT_TRANSPARENT;
 178     }
 179     if (format & FORMAT_DITHER) {
 180         dither = true;
 181         format &= ~FORMAT_DITHER;
 182     }
 183 #else
 184
 185     (void)format;
 186 #endif /* (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) */
 187
 188     fd = open(filename, O_RDONLY);
 189
 190     /* Exit if file opening failed */
 191     if (fd < 0) {
 192         DEBUGF("read_bmp_file: can't open '%s', rc: %d\n", filename, fd);
 193         return fd * 10 - 1;
 194     }
 195
 196     /* read fileheader */
 197     ret = read(fd, &bmph, sizeof(struct bmp_header));
 198     if (ret < 0) {
 199         close(fd);
 200         return ret * 10 - 2;
 201     }
 202
 203     if (ret != sizeof(struct bmp_header)) {
 204         DEBUGF("read_bmp_file: can't read BMP header.");
 205         close(fd);
 206         return -3;
 207     }
 208
 209     width = readlong(&bmph.width);
 210     if (width > LCD_WIDTH) {
 211         DEBUGF("read_bmp_file: Bitmap too wide (%d pixels, max is %d)\n",
 212                         width, LCD_WIDTH);
 213         close(fd);
 214         return -4;
 215     }
 216
 217     height = readlong(&bmph.height);
 218     depth = readshort(&bmph.bit_count);
 219     padded_width = ((width * depth + 31) >> 3) & ~3;  /* 4-byte boundary aligned */
 220
 221 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
 222     if (format == FORMAT_ANY) {
 223         if (depth == 1)
 224             format = FORMAT_MONO;
 225         else
 226             format = FORMAT_NATIVE;
 227     }
 228     bm->format = format;
 229 #endif /* (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) */
 230     /* returning image size */
 231     bm->width = width;
 232     bm->height = height;
 233
 234 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
 235     if (format == FORMAT_NATIVE) {
 236 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 237         if (remote) {
 238 #if (LCD_REMOTE_DEPTH == 2) && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED)
 239             dst_width  = width;
 240             dst_height = (height + 7) >> 3;
 241 #endif /* LCD_REMOTE_DEPTH / LCD_REMOTE_PIXELFORMAT */
 242             totalsize = dst_width * dst_height * sizeof(fb_remote_data);
 243         } else
 244 #endif /* defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1 */
 245         {
 246 #if LCD_DEPTH == 2
 247 #if LCD_PIXELFORMAT == VERTICAL_PACKING
 248             dst_width  = width;
 249             dst_height = (height + 3) >> 2;
 250 #else /* LCD_PIXELFORMAT == HORIZONTAL_PACKING */
 251             dst_width  = (width + 3) >> 2;
 252             dst_height = height;
 253 #endif /* LCD_PIXELFORMAT */
 254 #elif LCD_DEPTH == 16
 255             dst_width  = width;
 256             dst_height = height;
 257 #endif /* LCD_DEPTH */
 258             totalsize  = dst_width * dst_height * sizeof(fb_data);
 259         }
 260     } else
 261 #endif /* (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) */
 262     {
 263         dst_width  = width;
 264         dst_height = (height + 7) >> 3;
 265         totalsize  = dst_width * dst_height;
 266     }
 267
 268     /* Check if this fits the buffer */
 269     if (totalsize > maxsize) {
 270         DEBUGF("read_bmp_file: Bitmap too large for buffer: "
 271                "%d bytes.\n", totalsize);
 272         close(fd);
 273         return -6;
 274     }
 275
 276     compression = readlong(&bmph.compression);
 277     if (depth <= 8) {
 278         numcolors = readlong(&bmph.clr_used);
 279         if (numcolors == 0)
 280             numcolors = 1 << depth;
 281     } else
 282         numcolors = (compression == 3) ? 3 : 0;
 283
 284     if (numcolors > 0 && numcolors <= 256) {
 285         if (read(fd, palette, numcolors * sizeof(uint32_t))
 286             != numcolors * (int)sizeof(uint32_t))
 287         {
 288             DEBUGF("read_bmp_file: Can't read color palette\n");
 289             close(fd);
 290             return -7;
 291         }
 292     }
 293
 294     switch (depth) {
 295       case 16:
 296 #if LCD_DEPTH >= 16
 297         /* don't dither 16 bit BMP to LCD with same or larger depth */
 298 #ifdef HAVE_REMOTE_LCD
 299         if (!remote)
 300 #endif
 301             dither = false;
 302 #endif
 303         if (compression == 0) { /* BI_RGB, i.e. 15 bit */
 304             depth = 15;
 305             break;
 306         }   /* else fall through */
 307
 308       case 32:
 309         if (compression == 3) { /* BI_BITFIELDS */
 310             if (!memcmp(palette, bitfields[0], 12)) {    /* 15 bit */
 311                 depth = 15;
 312                 break;
 313             }
 314             if (!memcmp(palette, bitfields[1], 12)       /* 16 bit */
 315                 || !memcmp(palette, bitfields[2], 12))   /* 32 bit */
 316             {
 317                 break;
 318             }
 319         }   /* else fall through */
 320
 321       default:
 322         if (compression != 0) { /* not BI_RGB */
 323             DEBUGF("read_bmp_file: Unsupported compression (type %d)\n",
 324                    compression);
 325             close(fd);
 326             return -8;
 327         }
 328         break;
 329     }
 330
 331     /* Search to the beginning of the image data */
 332     lseek(fd, (off_t)readlong(&bmph.off_bits), SEEK_SET);
 333
 334     memset(bitmap, 0, totalsize);
 335
 336     /* loop to read rows and put them to buffer */
 337     for (row = height - 1; row >= 0; row--) {
 338         unsigned data, mask;
 339         unsigned char *p;
 340         uint16_t *p2;
 341         uint32_t *rp;
 342         union rgb_union *qp;
 343         union rgb_union q0, q1;
 344
 345         /* read one row */
 346         ret = read(fd, bmpbuf, padded_width);
 347         if (ret != padded_width) {
 348             DEBUGF("read_bmp_file: error reading image, read returned: %d "
 349                    "expected: %d\n", ret, padded_width);
 350             close(fd);
 351             return -9;
 352         }
 353
 354         /* convert whole line in-place to XRGB8888 (little endian) */
 355         rp = bmpbuf + width;
 356         switch (depth) {
 357           case 1:
 358             q0.raw = palette[0];
 359             q1.raw = palette[1];
 360             p = (unsigned char*)bmpbuf + ((width + 7) >> 3);
 361             mask = 0x80 >> ((width + 7) & 7);
 362             while (p > (unsigned char*)bmpbuf) {
 363                 data = *(--p);
 364                 for (; mask <= 0x80; mask <<= 1)
 365                     *(--rp) = (data & mask) ? q1.raw : q0.raw;
 366                 mask = 0x01;
 367             }
 368             break;
 369
 370           case 4:
 371             if (width & 1)
 372                 rp++;
 373             p = (unsigned char*)bmpbuf + ((width + 1) >> 1);
 374             while (p > (unsigned char*)bmpbuf) {
 375                 data = *(--p);
 376                 *(--rp) = palette[data & 0x0f];
 377                 *(--rp) = palette[data >> 4];
 378             }
 379             break;
 380
 381           case 8:
 382             p = (unsigned char*)bmpbuf + width;
 383             while (p > (unsigned char*)bmpbuf)
 384                 *(--rp) = palette[*(--p)];
 385             break;
 386
 387           case 15:
 388           case 16:
 389             p2 = (uint16_t *)bmpbuf + width;
 390             while (p2 > (uint16_t *)bmpbuf) {
 391                 unsigned component, rgb;
 392
 393                 data = letoh16(*(--p2));
 394                 /* blue */
 395                 component = (data << 3) & 0xf8;
 396 #ifdef ROCKBOX_BIG_ENDIAN
 397                 rgb = (component | (component >> 5)) << 8;
 398                 /* green */
 399                 data >>= 2;
 400                 if (depth == 15) {
 401                     component = data & 0xf8;
 402                     rgb |= component | (component >> 5);
 403                 } else {
 404                     data >>= 1;
 405                     component = data & 0xfc;
 406                     rgb |= component | (component >> 6);
 407                 }
 408                 /* red */
 409                 data >>= 5;
 410                 component = data & 0xf8;
 411                 rgb = (rgb << 8) | component | (component >> 5);
 412                 *(--rp) = rgb << 8;
 413 #else /* little endian */
 414                 rgb = component | (component >> 5);
 415                 /* green */
 416                 data >>= 2;
 417                 if (depth == 15) {
 418                     component = data & 0xf8;
 419                     rgb |= (component | (component >> 5)) << 8;
 420                 } else {
 421                     data >>= 1;
 422                     component = data & 0xfc;
 423                     rgb |= (component | (component >> 6)) << 8;
 424                 }
 425                 /* red */
 426                 data >>= 5;
 427                 component = data & 0xf8;
 428                 rgb |= (component | (component >> 5)) << 16;
 429                 *(--rp) = rgb;
 430 #endif
 431             }
 432             break;
 433
 434           case 24:
 435             p = (unsigned char*)bmpbuf + 3 * width;
 436             while (p > (unsigned char*)bmpbuf) {
 437                 data = *(--p);
 438                 data = (data << 8) | *(--p);
 439                 data = (data << 8) | *(--p);
 440                 *(--rp) = htole32(data);
 441             }
 442             break;
 443
 444           case 32: /* already in desired format */
 445             break;
 446         }
 447
 448         /* Convert to destination format */
 449         qp = (union rgb_union *)bmpbuf;
 450 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
 451         if (format == FORMAT_NATIVE) {
 452 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 453             if (remote) {
 454 #if (LCD_REMOTE_DEPTH == 2) && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED)
 455                 fb_remote_data *dest = (fb_remote_data *)bitmap
 456                                      + dst_width * (row >> 3);
 457                 int shift = row & 7;
 458                 int delta = 127;
 459                 unsigned bright;
 460
 461                 for (col = 0; col < width; col++) {
 462                     if (dither)
 463                         delta = dither_matrix[row & 0xf][col & 0xf];
 464                     bright = brightness(*qp++);
 465                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 466                     *dest++ |= remote_pattern[bright] << shift;
 467                 }
 468 #endif /* LCD_REMOTE_DEPTH / LCD_REMOTE_PIXELFORMAT */
 469             } else
 470 #endif /* defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1 */
 471             {
 472 #if LCD_DEPTH == 2
 473 #if LCD_PIXELFORMAT == VERTICAL_PACKING
 474                 /* iriver H1x0 */
 475                 fb_data *dest = (fb_data *)bitmap + dst_width * (row >> 2);
 476                 int shift = 2 * (row & 3);
 477                 int delta = 127;
 478                 unsigned bright;
 479
 480                 for (col = 0; col < width; col++) {
 481                     if (dither)
 482                         delta = dither_matrix[row & 0xf][col & 0xf];
 483                     bright = brightness(*qp++);
 484                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 485                     *dest++ |= (~bright & 3) << shift;
 486                 }
 487 #else /* LCD_PIXELFORMAT == HORIZONTAL_PACKING */
 488                 /* greyscale iPods */
 489                 fb_data *dest = (fb_data *)bitmap + dst_width * row;
 490                 int shift = 6;
 491                 int delta = 127;
 492                 unsigned bright;
 493                 unsigned data = 0;
 494
 495                 for (col = 0; col < width; col++) {
 496                     if (dither)
 497                         delta = dither_matrix[row & 0xf][col & 0xf];
 498                     bright = brightness(*qp++);
 499                     bright = (3 * bright + (bright >> 6) + delta) >> 8;
 500                     data |= (~bright & 3) << shift;
 501                     shift -= 2;
 502                     if (shift < 0) {
 503                         *dest++ = data;
 504                         data = 0;
 505                         shift = 6;
 506                     }
 507                 }
 508                 if (shift < 6)
 509                     *dest++ = data;
 510 #endif /* LCD_PIXELFORMAT */
 511 #elif LCD_DEPTH == 16
 512                 /* iriver h300, colour iPods, X5 */
 513                 fb_data *dest = (fb_data *)bitmap + dst_width * row;
 514                 int delta = 127;
 515                 unsigned r, g, b;
 516
 517                 for (col = 0; col < width; col++) {
 518                     if (dither)
 519                         delta = dither_matrix[row & 0xf][col & 0xf];
 520                     q0 = *qp++;
 521                     r = (31 * q0.red + (q0.red >> 3) + delta) >> 8;
 522                     g = (63 * q0.green + (q0.green >> 2) + delta) >> 8;
 523                     b = (31 * q0.blue + (q0.blue >> 3) + delta) >> 8;
 524                     *dest++ = LCD_RGBPACK_LCD(r, g, b);
 525                 }
 526 #endif /* LCD_DEPTH */
 527             }
 528         } else
 529 #endif /* (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) */
 530         {
 531             p = bitmap + dst_width * (row >> 3);
 532             mask = 1 << (row & 7);
 533
 534             for (col = 0; col < width; col++, p++)
 535                 if (brightness(*qp++) < 128)
 536                     *p |= mask;
 537         }
 538     }
 539
 540     close(fd);
 541
 542     DEBUGF("totalsize: %d\n", totalsize);
 543     return totalsize; /* return the used buffer size. */
 544 }