781421afa2
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@19374 a1c6a512-1295-4272-9138-f99709370657
706 lines
21 KiB
C
706 lines
21 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2002 by Linus Nielsen Feltzing
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/*
|
|
2005-04-16 Tomas Salfischberger:
|
|
- New BMP loader function, based on the old one (borrowed a lot of
|
|
calculations and checks there.)
|
|
- Conversion part needs some optimization, doing unneeded calulations now.
|
|
2006-11-18 Jens Arnold: complete rework
|
|
- All canonical formats supported now (1, 4, 8, 15/16, 24 and 32 bit)
|
|
- better protection against malformed / non-standard BMPs
|
|
- code heavily optimised for both size and speed
|
|
- dithering for 2 bit targets
|
|
2008-11-02 Akio Idehara: refactor for scaler frontend
|
|
2008-12-08 Andrew Mahone: partial-line reading, scaler frontend
|
|
- read_part_line does the actual source BMP reading, return columns read
|
|
and updates fields in a struct bmp_args with the new data and current
|
|
reader state
|
|
- skip_lines_bmp and store_part_bmp implement the scaler callbacks to skip
|
|
ahead by whole lines, or read the next chunk of the current line
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "inttypes.h"
|
|
#include "debug.h"
|
|
#include "lcd.h"
|
|
#include "file.h"
|
|
#ifdef HAVE_REMOTE_LCD
|
|
#include "lcd-remote.h"
|
|
#endif
|
|
#ifdef ROCKBOX_DEBUG_BMP_LOADER
|
|
#define BDEBUGF DEBUGF
|
|
#else
|
|
#define BDEBUGF(...)
|
|
#endif
|
|
#ifndef __PCTOOL__
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "bmp.h"
|
|
#include "resize.h"
|
|
#include "debug.h"
|
|
#else
|
|
#undef DEBUGF
|
|
#define DEBUGF(...)
|
|
#endif
|
|
|
|
#ifdef __GNUC__
|
|
#define STRUCT_PACKED __attribute__((packed))
|
|
#else
|
|
#define STRUCT_PACKED
|
|
#pragma pack (push, 2)
|
|
#endif
|
|
|
|
/* BMP header structure */
|
|
struct bmp_header {
|
|
uint16_t type; /* signature - 'BM' */
|
|
uint32_t size; /* file size in bytes */
|
|
uint16_t reserved1; /* 0 */
|
|
uint16_t reserved2; /* 0 */
|
|
uint32_t off_bits; /* offset to bitmap */
|
|
uint32_t struct_size; /* size of this struct (40) */
|
|
int32_t width; /* bmap width in pixels */
|
|
int32_t height; /* bmap height in pixels */
|
|
uint16_t planes; /* num planes - always 1 */
|
|
uint16_t bit_count; /* bits per pixel */
|
|
uint32_t compression; /* compression flag */
|
|
uint32_t size_image; /* image size in bytes */
|
|
int32_t x_pels_per_meter; /* horz resolution */
|
|
int32_t y_pels_per_meter; /* vert resolution */
|
|
uint32_t clr_used; /* 0 -> color table size */
|
|
uint32_t clr_important; /* important color count */
|
|
} STRUCT_PACKED;
|
|
|
|
union rgb_union {
|
|
struct { /* Little endian */
|
|
unsigned char blue;
|
|
unsigned char green;
|
|
unsigned char red;
|
|
unsigned char reserved;
|
|
};
|
|
uint32_t raw;
|
|
};
|
|
|
|
/* masks for supported BI_BITFIELDS encodings (16/32 bit) */
|
|
static const struct uint8_rgb bitfields[3][3] = {
|
|
/* 15bit */
|
|
{
|
|
{ .blue = 0x00, .green = 0x7c, .red = 0x00 },
|
|
{ .blue = 0xe0, .green = 0x03, .red = 0x00 },
|
|
{ .blue = 0x1f, .green = 0x00, .red = 0x00 },
|
|
},
|
|
/* 16bit */
|
|
{
|
|
{ .blue = 0x00, .green = 0xf8, .red = 0x00 },
|
|
{ .blue = 0xe0, .green = 0x07, .red = 0x00 },
|
|
{ .blue = 0x1f, .green = 0x00, .red = 0x00 },
|
|
},
|
|
/* 32bit */
|
|
{
|
|
{ .blue = 0x00, .green = 0x00, .red = 0xff },
|
|
{ .blue = 0x00, .green = 0xff, .red = 0x00 },
|
|
{ .blue = 0xff, .green = 0x00, .red = 0x00 },
|
|
},
|
|
};
|
|
|
|
#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
|
|
/* canonical ordered dither matrix */
|
|
const unsigned char dither_matrix[16][16] = {
|
|
{ 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 },
|
|
{ 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
|
|
{ 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
|
|
{ 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
|
|
{ 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 },
|
|
{ 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
|
|
{ 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
|
|
{ 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
|
|
{ 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 },
|
|
{ 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
|
|
{ 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
|
|
{ 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
|
|
{ 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 },
|
|
{ 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
|
|
{ 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
|
|
{ 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
|
|
};
|
|
#endif
|
|
|
|
#if ((LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)) \
|
|
|| (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH == 2) \
|
|
&& (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED))
|
|
const unsigned short vi_pattern[4] = {
|
|
0x0101, 0x0100, 0x0001, 0x0000
|
|
};
|
|
#endif
|
|
|
|
/******************************************************************************
|
|
* read_bmp_file()
|
|
*
|
|
* Reads a BMP file and puts the data in rockbox format in *bitmap.
|
|
*
|
|
*****************************************************************************/
|
|
int read_bmp_file(const char* filename,
|
|
struct bitmap *bm,
|
|
int maxsize,
|
|
int format)
|
|
{
|
|
int fd, ret;
|
|
fd = open(filename, O_RDONLY);
|
|
|
|
/* Exit if file opening failed */
|
|
if (fd < 0) {
|
|
DEBUGF("read_bmp_file: can't open '%s', rc: %d\n", filename, fd);
|
|
return fd * 10 - 1;
|
|
}
|
|
|
|
BDEBUGF("read_bmp_file: '%s' remote: %d resize: %d keep_aspect: %d\n",
|
|
filename, !!(format & FORMAT_REMOTE), !!(format & FORMAT_RESIZE),
|
|
!!(format & FORMAT_KEEP_ASPECT));
|
|
ret = read_bmp_fd(fd, bm, maxsize, format);
|
|
close(fd);
|
|
return ret;
|
|
}
|
|
|
|
static inline void set_rgb_union(struct uint8_rgb *dst, union rgb_union src)
|
|
{
|
|
dst->red = src.red;
|
|
dst->green = src.green;
|
|
dst->blue = src.blue;
|
|
}
|
|
|
|
struct bmp_args {
|
|
int fd;
|
|
short padded_width;
|
|
short read_width;
|
|
short width;
|
|
short depth;
|
|
unsigned char buf[MAX_WIDTH * 4];
|
|
struct uint8_rgb *palette;
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
int cur_row;
|
|
int cur_col;
|
|
struct img_part part;
|
|
#endif
|
|
};
|
|
|
|
static unsigned int read_part_line(struct bmp_args *ba)
|
|
{
|
|
const int padded_width = ba->padded_width;
|
|
const int read_width = ba->read_width;
|
|
const int width = ba->width;
|
|
const int depth = ba->depth;
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
int cur_row = ba->cur_row;
|
|
int cur_col = ba->cur_col;
|
|
#endif
|
|
const int fd = ba->fd;
|
|
uint8_t *ibuf;
|
|
struct uint8_rgb *buf = (struct uint8_rgb *)(ba->buf);
|
|
const struct uint8_rgb *palette = ba->palette;
|
|
uint32_t component, data = data;
|
|
int ret;
|
|
int i, cols, len;
|
|
|
|
#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
|
|
cols = MIN(width - cur_col,(int)MAX_WIDTH);
|
|
len = (cols * (depth == 15 ? 16 : depth) + 7) >> 3;
|
|
#else
|
|
cols = width;
|
|
len = read_width;
|
|
#endif
|
|
ibuf = ((unsigned char *)buf) + (MAX_WIDTH << 2) - len;
|
|
BDEBUGF("read_part_line: cols=%d len=%d\n",cols,len);
|
|
ret = read(fd, ibuf, len);
|
|
if (ret != len)
|
|
{
|
|
DEBUGF("read_part_line: error reading image, read returned %d "
|
|
"expected %d\n", ret, len);
|
|
BDEBUGF("cur_row: %d cur_col: %d cols: %d len: %d\n", cur_row, cur_col,
|
|
cols, len);
|
|
return 0;
|
|
}
|
|
for (i = 0; i < cols; i++)
|
|
{
|
|
switch (depth)
|
|
{
|
|
case 1:
|
|
if ((i & 7) == 0)
|
|
data = *ibuf++;
|
|
*buf = palette[(data >> 7) & 1];
|
|
data <<= 1;
|
|
break;
|
|
case 4:
|
|
*buf = palette[*ibuf >> 4];
|
|
if (i & 1)
|
|
ibuf++;
|
|
else
|
|
*ibuf <<= 4;
|
|
break;
|
|
case 8:
|
|
*buf = palette[*ibuf++];
|
|
break;
|
|
case 15:
|
|
case 16:
|
|
data = letoh16(*(uint16_t*)ibuf);
|
|
component = (data << 3) & 0xf8;
|
|
component |= component >> 5;
|
|
buf->blue = component;
|
|
if (depth == 15)
|
|
{
|
|
data >>= 2;
|
|
component = data & 0xf8;
|
|
component |= component >> 5;
|
|
} else {
|
|
data >>= 3;
|
|
component = data & 0xfc;
|
|
component |= component >> 6;
|
|
}
|
|
buf->green = component;
|
|
data >>= 5;
|
|
component = data & 0xf8;
|
|
component |= component >> 5;
|
|
buf->red = component;
|
|
ibuf += 2;
|
|
break;
|
|
case 32:
|
|
case 24:
|
|
buf->blue = *ibuf++;
|
|
buf->green = *ibuf++;
|
|
buf->red = *ibuf++;
|
|
if (depth == 32)
|
|
ibuf++;
|
|
break;
|
|
}
|
|
buf++;
|
|
}
|
|
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
cur_col += cols;
|
|
if (cur_col == width)
|
|
{
|
|
#endif
|
|
int pad = padded_width - read_width;
|
|
if (pad > 0)
|
|
{
|
|
BDEBUGF("seeking %d bytes to next line\n",pad);
|
|
lseek(fd, pad, SEEK_CUR);
|
|
}
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
cur_col = 0;
|
|
BDEBUGF("read_part_line: completed row %d\n", cur_row);
|
|
cur_row += 1;
|
|
}
|
|
|
|
ba->cur_row = cur_row;
|
|
ba->cur_col = cur_col;
|
|
#endif
|
|
return cols;
|
|
}
|
|
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
static struct img_part *store_part_bmp(void *args)
|
|
{
|
|
struct bmp_args *ba = (struct bmp_args *)args;
|
|
|
|
ba->part.len = read_part_line(ba);
|
|
ba->part.buf = (struct uint8_rgb *)ba->buf;
|
|
if (ba->part.len)
|
|
return &(ba->part);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
static bool skip_lines_bmp(void *args, unsigned int lines)
|
|
{
|
|
struct bmp_args * ba = (struct bmp_args *)args;
|
|
|
|
int pad = lines * ba->padded_width +
|
|
(ba->cur_col
|
|
? ((ba->cur_col * ba->depth + 7) >> 3) - ba->padded_width
|
|
: 0);
|
|
if (pad)
|
|
{
|
|
if(lseek(ba->fd, pad, SEEK_CUR) < 0)
|
|
|
|
return false;
|
|
}
|
|
ba->cur_row += lines + (ba->cur_col ? 1 : 0);
|
|
ba->cur_col = 0;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
static inline 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;
|
|
}
|
|
#endif
|
|
|
|
static inline int rgbcmp(struct uint8_rgb rgb1, struct uint8_rgb rgb2)
|
|
{
|
|
if ((rgb1.red == rgb2.red) && (rgb1.green == rgb2.green) &&
|
|
(rgb1.blue == rgb2.blue))
|
|
return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* read_bmp_fd()
|
|
*
|
|
* Reads a BMP file in an open file descriptor and puts the data in rockbox
|
|
* format in *bitmap.
|
|
*
|
|
*****************************************************************************/
|
|
int read_bmp_fd(int fd,
|
|
struct bitmap *bm,
|
|
int maxsize,
|
|
int format)
|
|
{
|
|
struct bmp_header bmph;
|
|
int padded_width;
|
|
int read_width;
|
|
int depth, numcolors, compression, totalsize;
|
|
int ret;
|
|
|
|
unsigned char *bitmap = bm->data;
|
|
struct uint8_rgb palette[256];
|
|
bool remote = false;
|
|
struct rowset rset;
|
|
struct dim src_dim;
|
|
#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
|
|
unsigned int resize = IMG_NORESIZE;
|
|
bool dither = false;
|
|
bool transparent = false;
|
|
|
|
#ifdef HAVE_REMOTE_LCD
|
|
if (format & FORMAT_REMOTE) {
|
|
remote = true;
|
|
#if LCD_REMOTE_DEPTH == 1
|
|
format = FORMAT_MONO;
|
|
#else
|
|
format &= ~FORMAT_REMOTE;
|
|
#endif
|
|
}
|
|
#endif /* HAVE_REMOTE_LCD */
|
|
|
|
if (format & FORMAT_RESIZE) {
|
|
resize = IMG_RESIZE;
|
|
format &= ~FORMAT_RESIZE;
|
|
}
|
|
|
|
if (format & FORMAT_TRANSPARENT) {
|
|
transparent = true;
|
|
format &= ~FORMAT_TRANSPARENT;
|
|
}
|
|
if (format & FORMAT_DITHER) {
|
|
dither = true;
|
|
format &= ~FORMAT_DITHER;
|
|
}
|
|
#else
|
|
|
|
(void)format;
|
|
#endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
|
|
|
|
/* read fileheader */
|
|
ret = read(fd, &bmph, sizeof(struct bmp_header));
|
|
if (ret < 0) {
|
|
return ret * 10 - 2;
|
|
}
|
|
|
|
if (ret != sizeof(struct bmp_header)) {
|
|
DEBUGF("read_bmp_fd: can't read BMP header.");
|
|
return -3;
|
|
}
|
|
|
|
src_dim.width = letoh32(bmph.width);
|
|
src_dim.height = letoh32(bmph.height);
|
|
if (src_dim.height < 0) { /* Top-down BMP file */
|
|
src_dim.height = -src_dim.height;
|
|
rset.rowstep = 1;
|
|
} else { /* normal BMP */
|
|
rset.rowstep = -1;
|
|
}
|
|
|
|
depth = letoh16(bmph.bit_count);
|
|
/* 4-byte boundary aligned */
|
|
read_width = ((src_dim.width * (depth == 15 ? 16 : depth) + 7) >> 3);
|
|
padded_width = (read_width + 3) & ~3;
|
|
|
|
BDEBUGF("width: %d height: %d depth: %d padded_width: %d\n", src_dim.width,
|
|
src_dim.height, depth, padded_width);
|
|
|
|
#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
|
|
if ((format & 3) == FORMAT_ANY) {
|
|
if (depth == 1)
|
|
format = (format & ~3);
|
|
else
|
|
format = (format & ~3) | FORMAT_NATIVE;
|
|
}
|
|
bm->format = format & 3;
|
|
if ((format & 3) == FORMAT_MONO)
|
|
{
|
|
resize &= ~IMG_RESIZE;
|
|
resize |= IMG_NORESIZE;
|
|
remote = 0;
|
|
}
|
|
#else
|
|
if (src_dim.width > MAX_WIDTH)
|
|
return -6;
|
|
#endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
|
|
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
if (resize & IMG_RESIZE) {
|
|
if(format & FORMAT_KEEP_ASPECT) {
|
|
/* keep aspect ratio.. */
|
|
format &= ~FORMAT_KEEP_ASPECT;
|
|
struct dim resize_dim = {
|
|
.width = bm->width,
|
|
.height = bm->height,
|
|
};
|
|
if (recalc_dimension(&resize_dim, &src_dim))
|
|
resize = IMG_NORESIZE;
|
|
bm->width = resize_dim.width;
|
|
bm->height = resize_dim.height;
|
|
}
|
|
}
|
|
|
|
if (!(resize & IMG_RESIZE)) {
|
|
#endif
|
|
/* returning image size */
|
|
bm->width = src_dim.width;
|
|
bm->height = src_dim.height;
|
|
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
}
|
|
#endif
|
|
|
|
if (rset.rowstep > 0) { /* Top-down BMP file */
|
|
rset.rowstart = 0;
|
|
rset.rowstop = bm->height;
|
|
} else { /* normal BMP */
|
|
rset.rowstart = bm->height - 1;
|
|
rset.rowstop = -1;
|
|
}
|
|
|
|
totalsize = get_totalsize(bm, remote);
|
|
|
|
/* Check if this fits the buffer */
|
|
if (totalsize > maxsize) {
|
|
DEBUGF("read_bmp_fd: Bitmap too large for buffer: "
|
|
"%d bytes.\n", totalsize);
|
|
return -6;
|
|
}
|
|
|
|
compression = letoh32(bmph.compression);
|
|
if (depth <= 8) {
|
|
numcolors = letoh32(bmph.clr_used);
|
|
if (numcolors == 0)
|
|
numcolors = 1 << depth;
|
|
} else
|
|
numcolors = (compression == 3) ? 3 : 0;
|
|
|
|
if (numcolors > 0 && numcolors <= 256) {
|
|
int i;
|
|
union rgb_union pal;
|
|
for (i = 0; i < numcolors; i++) {
|
|
if (read(fd, &pal, sizeof(pal)) != (int)sizeof(pal))
|
|
{
|
|
DEBUGF("read_bmp_fd: Can't read color palette\n");
|
|
return -7;
|
|
}
|
|
set_rgb_union(&palette[i], pal);
|
|
}
|
|
}
|
|
|
|
switch (depth) {
|
|
case 16:
|
|
#if LCD_DEPTH >= 16
|
|
/* don't dither 16 bit BMP to LCD with same or larger depth */
|
|
#ifdef HAVE_REMOTE_LCD
|
|
if (!remote)
|
|
#endif
|
|
dither = false;
|
|
#endif
|
|
if (compression == 0) { /* BI_RGB, i.e. 15 bit */
|
|
depth = 15;
|
|
break;
|
|
} /* else fall through */
|
|
|
|
case 32:
|
|
if (compression == 3) { /* BI_BITFIELDS */
|
|
bool found;
|
|
int i, j;
|
|
|
|
/* (i == 0) is 15bit, (i == 1) is 16bit, (i == 2) is 32bit */
|
|
for (i = 0; i < ARRAY_SIZE(bitfields); i++) {
|
|
for (j = 0; j < ARRAY_SIZE(bitfields[0]); j++) {
|
|
if (!rgbcmp(palette[j], bitfields[i][j])) {
|
|
found = true;
|
|
} else {
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
if (found) {
|
|
if (i == 0) /* 15bit */
|
|
depth = 15;
|
|
break;
|
|
}
|
|
}
|
|
if (found)
|
|
break;
|
|
} /* else fall through */
|
|
|
|
default:
|
|
if (compression != 0) { /* not BI_RGB */
|
|
DEBUGF("read_bmp_fd: Unsupported compression (type %d)\n",
|
|
compression);
|
|
return -8;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* Search to the beginning of the image data */
|
|
lseek(fd, (off_t)letoh32(bmph.off_bits), SEEK_SET);
|
|
|
|
memset(bitmap, 0, totalsize);
|
|
|
|
struct bmp_args ba = {
|
|
.fd = fd, .padded_width = padded_width, .read_width = read_width,
|
|
.width = src_dim.width, .depth = depth, .palette = palette,
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
.cur_row = 0, .cur_col = 0, .part = {0,0}
|
|
#endif
|
|
};
|
|
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
#if LCD_DEPTH == 16
|
|
#ifdef HAVE_REMOTE_LCD
|
|
if (resize & IMG_RESIZE || remote)
|
|
#else
|
|
if (resize & IMG_RESIZE)
|
|
#endif
|
|
#else
|
|
if (format == FORMAT_NATIVE)
|
|
#endif
|
|
return resize_on_load(bm, dither, &src_dim, &rset, remote,
|
|
#ifdef HAVE_LCD_COLOR
|
|
bitmap + totalsize, maxsize - totalsize,
|
|
#endif
|
|
store_part_bmp, skip_lines_bmp, &ba);
|
|
#endif /* LCD_DEPTH */
|
|
|
|
int fb_width = get_fb_width(bm, remote);
|
|
int col, row;
|
|
|
|
/* loop to read rows and put them to buffer */
|
|
for (row = rset.rowstart; row != rset.rowstop; row += rset.rowstep) {
|
|
struct uint8_rgb *qp;
|
|
unsigned mask;
|
|
unsigned char *p;
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
unsigned int len;
|
|
|
|
if (!(len = read_part_line(&ba)))
|
|
return -9;
|
|
#else
|
|
if (!read_part_line(&ba))
|
|
return -9;
|
|
#endif
|
|
|
|
/* Convert to destination format */
|
|
qp = (struct uint8_rgb *) ba.buf;
|
|
#if LCD_DEPTH == 16
|
|
if (format == FORMAT_NATIVE)
|
|
{
|
|
/* iriver h300, colour iPods, X5 */
|
|
fb_data *dest = (fb_data *)bitmap + fb_width * row;
|
|
int delta = 127;
|
|
unsigned r, g, b;
|
|
struct uint8_rgb q0;
|
|
|
|
for (col = 0; col < src_dim.width; col++) {
|
|
if (dither)
|
|
delta = dither_mat(row & 0xf, col & 0xf);
|
|
if (!len)
|
|
{
|
|
if(!(len = read_part_line(&ba)))
|
|
return -9;
|
|
else
|
|
qp = (struct uint8_rgb *)ba.buf;
|
|
}
|
|
q0 = *qp++;
|
|
len--;
|
|
r = (31 * q0.red + (q0.red >> 3) + delta) >> 8;
|
|
g = (63 * q0.green + (q0.green >> 2) + delta) >> 8;
|
|
b = (31 * q0.blue + (q0.blue >> 3) + delta) >> 8;
|
|
*dest++ = LCD_RGBPACK_LCD(r, g, b);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
p = bitmap + fb_width * (row >> 3);
|
|
mask = 1 << (row & 7);
|
|
for (col = 0; col < src_dim.width; col++)
|
|
{
|
|
#if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
if (!len)
|
|
{
|
|
if(!(len = read_part_line(&ba)))
|
|
return -9;
|
|
else
|
|
qp = (struct uint8_rgb *)ba.buf;
|
|
}
|
|
len--;
|
|
#endif
|
|
if (brightness(*qp++) < 128)
|
|
*p |= mask;
|
|
p++;
|
|
}
|
|
}
|
|
}
|
|
return totalsize; /* return the used buffer size. */
|
|
}
|