1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Linus Nielsen Feltzing
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
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
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
52 #ifdef HAVE_REMOTE_LCD
53 #include "lcd-remote.h"
55 #ifdef ROCKBOX_DEBUG_BMP_LOADER
56 #define BDEBUGF DEBUGF
69 #define STRUCT_PACKED __attribute__((packed))
72 #pragma pack (push, 2)
75 /* BMP header structure */
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 */
96 struct { /* Little endian */
100 unsigned char reserved
;
105 /* masks for supported BI_BITFIELDS encodings (16/32 bit) */
106 static const struct uint8_rgb bitfields
[3][3] = {
109 { .blue
= 0x00, .green
= 0x7c, .red
= 0x00 },
110 { .blue
= 0xe0, .green
= 0x03, .red
= 0x00 },
111 { .blue
= 0x1f, .green
= 0x00, .red
= 0x00 },
115 { .blue
= 0x00, .green
= 0xf8, .red
= 0x00 },
116 { .blue
= 0xe0, .green
= 0x07, .red
= 0x00 },
117 { .blue
= 0x1f, .green
= 0x00, .red
= 0x00 },
121 { .blue
= 0x00, .green
= 0x00, .red
= 0xff },
122 { .blue
= 0x00, .green
= 0xff, .red
= 0x00 },
123 { .blue
= 0xff, .green
= 0x00, .red
= 0x00 },
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
130 const unsigned char dither_table
[16] =
131 { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 };
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
142 /******************************************************************************
145 * Reads a BMP file and puts the data in rockbox format in *bitmap.
147 *****************************************************************************/
148 int read_bmp_file(const char* filename
,
152 const struct custom_format
*cformat
)
155 fd
= open(filename
, O_RDONLY
);
157 /* Exit if file opening failed */
159 DEBUGF("read_bmp_file: can't open '%s', rc: %d\n", filename
, fd
);
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
);
171 static inline void set_rgb_union(struct uint8_rgb
*dst
, union rgb_union src
)
174 dst
->green
= src
.green
;
175 dst
->blue
= src
.blue
;
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)
190 struct img_part part
;
194 static unsigned int read_part_line(struct bmp_args
*ba
)
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
;
205 const int fd
= ba
->fd
;
207 struct uint8_rgb
*buf
= (struct uint8_rgb
*)(ba
->buf
);
208 const struct uint8_rgb
*palette
= ba
->palette
;
209 uint32_t component
, data
= data
;
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;
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
);
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
,
236 while (ibuf
< ba
->buf
+ (BM_MAX_WIDTH
<< 2))
242 for (i
= 0; i
< 8; i
++)
244 *buf
++ = palette
[data
& 0x80 ? 1 : 0];
250 *buf
++ = palette
[data
>> 4];
251 *buf
++ = palette
[data
& 0xf];
254 *buf
++ = palette
[*ibuf
++];
258 data
= letoh16(*(uint16_t*)ibuf
);
259 component
= (data
<< 3) & 0xf8;
260 component
|= component
>> 5;
261 buf
->blue
= component
;
265 component
= data
& 0xf8;
266 component
|= component
>> 5;
269 component
= data
& 0xfc;
270 component
|= component
>> 6;
272 buf
->green
= component
;
274 component
= data
& 0xf8;
275 component
|= component
>> 5;
276 buf
->red
= component
;
283 buf
->green
= *ibuf
++;
292 #if !defined(HAVE_LCD_COLOR) && \
293 ((LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
296 buf
= (struct uint8_rgb
*)ba
->buf
;
297 while (ibuf
< ba
->buf
+ cols
)
298 *ibuf
++ = brightness(*buf
++);
301 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
302 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
304 if (cur_col
== width
)
307 int pad
= padded_width
- read_width
;
310 BDEBUGF("seeking %d bytes to next line\n",pad
);
311 lseek(fd
, pad
, SEEK_CUR
);
313 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
314 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
316 BDEBUGF("read_part_line: completed row %d\n", cur_row
);
320 ba
->cur_row
= cur_row
;
321 ba
->cur_col
= cur_col
;
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
)
330 struct bmp_args
*ba
= (struct bmp_args
*)args
;
332 ba
->part
.len
= read_part_line(ba
);
333 #ifdef HAVE_LCD_COLOR
334 ba
->part
.buf
= (struct uint8_rgb
*)ba
->buf
;
336 ba
->part
.buf
= (uint8_t *)ba
->buf
;
345 static inline int rgbcmp(struct uint8_rgb rgb1
, struct uint8_rgb rgb2
)
347 if ((rgb1
.red
== rgb2
.red
) && (rgb1
.green
== rgb2
.green
) &&
348 (rgb1
.blue
== rgb2
.blue
))
354 #if !defined(PLUGIN) && !defined(HAVE_JPEG) && !defined(HAVE_BMP_SCALING)
357 void output_row_8_native(uint32_t row
, void * row_in
,
358 struct scaler_context
*ctx
)
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
;
366 uint8_t *qp
= (uint8_t*)row_in
;
368 BDEBUGF("output_row: y: %lu in: %p\n",row
, row_in
);
370 #if LCD_PIXELFORMAT == HORIZONTAL_PACKING
371 /* greyscale iPods */
372 fb_data
*dest
= (fb_data
*)ctx
->bm
->data
+ fb_width
* row
;
378 for (col
= 0; col
< ctx
->bm
->width
; col
++) {
380 delta
= DITHERXDY(col
,dy
);
382 bright
= (3 * bright
+ (bright
>> 6) + delta
) >> 8;
383 data
|= (~bright
& 3) << shift
;
393 #elif LCD_PIXELFORMAT == VERTICAL_PACKING
395 fb_data
*dest
= (fb_data
*)ctx
->bm
->data
+ fb_width
*
397 int shift
= 2 * (row
& 3);
401 for (col
= 0; col
< ctx
->bm
->width
; col
++) {
403 delta
= DITHERXDY(col
,dy
);
405 bright
= (3 * bright
+ (bright
>> 6) + delta
) >> 8;
406 *dest
++ |= (~bright
& 3) << shift
;
408 #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED
410 fb_data
*dest
= (fb_data
*)ctx
->bm
->data
+ fb_width
*
416 for (col
= 0; col
< ctx
->bm
->width
; col
++) {
418 delta
= DITHERXDY(col
,dy
);
420 bright
= (3 * bright
+ (bright
>> 6) + delta
) >> 8;
421 *dest
++ |= vi_pattern
[bright
] << shift
;
423 #endif /* LCD_PIXELFORMAT */
424 #elif LCD_DEPTH == 16
425 #if defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE
428 fb_data
*dest
= (fb_data
*)ctx
->bm
->data
+ row
;
431 for (col
= 0; col
< ctx
->bm
->width
; col
++) {
433 delta
= DITHERXDY(col
,dy
);
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
;
444 /* iriver h300, colour iPods, X5 */
445 fb_data
*dest
= (fb_data
*)ctx
->bm
->data
+ fb_width
* row
;
448 for (col
= 0; col
< ctx
->bm
->width
; col
++) {
450 delta
= DITHERXDY(col
,dy
);
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
);
460 #endif /* LCD_DEPTH */
464 /******************************************************************************
467 * Reads a BMP file in an open file descriptor and puts the data in rockbox
470 *****************************************************************************/
471 int read_bmp_fd(int fd
,
475 const struct custom_format
*cformat
)
477 struct bmp_header bmph
;
480 int depth
, numcolors
, compression
, totalsize
;
482 bool return_size
= format
& FORMAT_RETURN_SIZE
;
484 unsigned char *bitmap
= bm
->data
;
485 struct uint8_rgb palette
[256];
488 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
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
;
496 #ifdef HAVE_REMOTE_LCD
498 if (format
& FORMAT_REMOTE
) {
500 #if LCD_REMOTE_DEPTH == 1
501 format
= FORMAT_MONO
;
504 #endif /* HAVE_REMOTE_LCD */
506 if (format
& FORMAT_RESIZE
) {
513 #endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
514 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
516 if (format
& FORMAT_DITHER
) {
520 /* read fileheader */
521 ret
= read(fd
, &bmph
, sizeof(struct bmp_header
));
526 if (ret
!= sizeof(struct bmp_header
)) {
527 DEBUGF("read_bmp_fd: can't read BMP header.");
531 src_dim
.width
= letoh32(bmph
.width
);
532 src_dim
.height
= letoh32(bmph
.height
);
533 if (src_dim
.height
< 0) { /* Top-down BMP file */
534 src_dim
.height
= -src_dim
.height
;
536 } else { /* normal BMP */
540 depth
= letoh16(bmph
.bit_count
);
541 /* 4-byte boundary aligned */
542 read_width
= ((src_dim
.width
* (depth
== 15 ? 16 : depth
) + 7) >> 3);
543 padded_width
= (read_width
+ 3) & ~3;
545 BDEBUGF("width: %d height: %d depth: %d padded_width: %d\n", src_dim
.width
,
546 src_dim
.height
, depth
, padded_width
);
548 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
549 if ((format
& 3) == FORMAT_ANY
) {
551 format
= (format
& ~3);
553 format
= (format
& ~3) | FORMAT_NATIVE
;
555 bm
->format
= format
& 1;
556 if ((format
& 1) == FORMAT_MONO
)
558 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
559 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
560 resize
&= ~IMG_RESIZE
;
561 resize
|= IMG_NORESIZE
;
563 #ifdef HAVE_REMOTE_LCD
567 #elif !defined(PLUGIN)
568 if (src_dim
.width
> BM_MAX_WIDTH
)
570 #endif /*(LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)*/
572 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
573 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
574 if (resize
& IMG_RESIZE
) {
575 if(format
& FORMAT_KEEP_ASPECT
) {
576 /* keep aspect ratio.. */
577 struct dim resize_dim
= {
579 .height
= bm
->height
,
581 if (recalc_dimension(&resize_dim
, &src_dim
))
582 resize
= IMG_NORESIZE
;
583 bm
->width
= resize_dim
.width
;
584 bm
->height
= resize_dim
.height
;
588 if (!(resize
& IMG_RESIZE
)) {
590 /* returning image size */
591 bm
->width
= src_dim
.width
;
592 bm
->height
= src_dim
.height
;
594 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
595 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
598 #if LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
601 if (rset
.rowstep
> 0) { /* Top-down BMP file */
603 rset
.rowstop
= bm
->height
;
604 } else { /* normal BMP */
605 rset
.rowstart
= bm
->height
- 1;
610 totalsize
= cformat
->get_size(bm
);
612 totalsize
= BM_SIZE(bm
->width
,bm
->height
,format
,remote
);
616 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
617 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
619 totalsize
+= BM_SCALED_SIZE(bm
->width
, 0, 0, 0);
620 else if (bm
->width
> BM_MAX_WIDTH
)
621 totalsize
+= bm
->width
*4;
626 /* Check if this fits the buffer */
627 if (totalsize
> maxsize
) {
628 DEBUGF("read_bmp_fd: Bitmap too large for buffer: "
629 "%d bytes.\n", totalsize
);
633 compression
= letoh32(bmph
.compression
);
635 numcolors
= letoh32(bmph
.clr_used
);
637 numcolors
= BIT_N(depth
);
639 numcolors
= (compression
== 3) ? 3 : 0;
641 if (numcolors
> 0 && numcolors
<= 256) {
644 for (i
= 0; i
< numcolors
; i
++) {
645 if (read(fd
, &pal
, sizeof(pal
)) != (int)sizeof(pal
))
647 DEBUGF("read_bmp_fd: Can't read color palette\n");
650 set_rgb_union(&palette
[i
], pal
);
657 /* don't dither 16 bit BMP to LCD with same or larger depth */
658 #ifdef HAVE_REMOTE_LCD
663 if (compression
== 0) { /* BI_RGB, i.e. 15 bit */
666 } /* else fall through */
669 if (compression
== 3) { /* BI_BITFIELDS */
673 /* (i == 0) is 15bit, (i == 1) is 16bit, (i == 2) is 32bit */
674 for (i
= 0; i
< ARRAY_SIZE(bitfields
); i
++) {
675 for (j
= 0; j
< ARRAY_SIZE(bitfields
[0]); j
++) {
676 if (!rgbcmp(palette
[j
], bitfields
[i
][j
])) {
684 if (i
== 0) /* 15bit */
691 } /* else fall through */
694 if (compression
!= 0) { /* not BI_RGB */
695 DEBUGF("read_bmp_fd: Unsupported compression (type %d)\n",
702 /* Search to the beginning of the image data */
703 lseek(fd
, (off_t
)letoh32(bmph
.off_bits
), SEEK_SET
);
705 memset(bitmap
, 0, totalsize
);
707 struct bmp_args ba
= {
708 .fd
= fd
, .padded_width
= padded_width
, .read_width
= read_width
,
709 .width
= src_dim
.width
, .depth
= depth
, .palette
= palette
,
710 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
711 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
712 .cur_row
= 0, .cur_col
= 0, .part
= {0,0}
716 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
717 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
720 if (resize_on_load(bm
, dither
, &src_dim
, &rset
,
721 bitmap
+ totalsize
, maxsize
- totalsize
,
722 cformat
, IF_PIX_FMT(0,) store_part_bmp
, &ba
))
727 #endif /* LCD_DEPTH */
729 #if LCD_DEPTH > 1 || defined(PLUGIN)
730 struct scaler_context ctx
= {
735 #if defined(PLUGIN) || defined(HAVE_JPEG) || defined(HAVE_BMP_SCALING)
737 void (*output_row_8
)(uint32_t, void*, struct scaler_context
*) =
739 #elif defined(PLUGIN)
740 void (*output_row_8
)(uint32_t, void*, struct scaler_context
*) = NULL
;
742 #if LCD_DEPTH > 1 || defined(PLUGIN)
744 output_row_8
= cformat
->output_row_8
;
748 unsigned char *buf
= ba
.buf
;
749 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) || \
751 if (bm
->width
> BM_MAX_WIDTH
)
753 #if defined(HAVE_BMP_SCALING) || defined(PLUGIN)
754 unsigned int len
= maxsize
- totalsize
;
755 buf
= bitmap
+ totalsize
;
756 ALIGN_BUFFER(buf
, len
, sizeof(uint32_t));
757 if (bm
->width
*4 > (int)len
)
764 /* loop to read rows and put them to buffer */
765 for (row
= rset
.rowstart
; row
!= rset
.rowstop
; row
+= rset
.rowstep
) {
766 #if (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)) && \
767 defined(HAVE_BMP_SCALING) || defined(PLUGIN)
768 if (bm
->width
> BM_MAX_WIDTH
)
770 #if defined(HAVE_LCD_COLOR)
771 struct uint8_rgb
*p
= (struct uint8_rgb
*)buf
;
776 int len
= read_part_line(&ba
);
779 memcpy(p
, ba
.buf
, len
*sizeof(*p
));
781 } while (ba
.cur_col
);
785 if (!read_part_line(&ba
))
788 #if !defined(HAVE_LCD_COLOR) && \
789 (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
792 struct uint8_rgb
*qp
= (struct uint8_rgb
*)buf
;
795 /* Convert to destination format */
796 #if ((LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) && \
798 if (format
== FORMAT_NATIVE
) {
799 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
801 unsigned char dy
= DITHERY(row
);
802 #if (LCD_REMOTE_DEPTH == 2) && (LCD_REMOTE_PIXELFORMAT == VERTICAL_INTERLEAVED)
803 /* iAudio X5/M5 remote */
804 fb_remote_data
*dest
= (fb_remote_data
*)bitmap
805 + bm
->width
* (row
>> 3);
811 for (col
= 0; col
< bm
->width
; col
++) {
813 delta
= DITHERXDY(col
,dy
);
814 #if !defined(HAVE_LCD_COLOR) && \
815 (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
818 bright
= brightness(*qp
++);
820 bright
= (3 * bright
+ (bright
>> 6) + delta
) >> 8;
821 *dest
++ |= vi_pattern
[bright
] << shift
;
823 #endif /* LCD_REMOTE_DEPTH / LCD_REMOTE_PIXELFORMAT */
825 #endif /* defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1 */
826 #endif /* (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) &&
827 (LCD_REMOTE_DEPTH > 1) */
828 #if LCD_DEPTH > 1 || defined(PLUGIN)
830 #if !defined(PLUGIN) && !defined(HAVE_JPEG) && !defined(HAVE_BMP_SCALING)
831 output_row_8_native(row
, buf
, &ctx
);
833 output_row_8(row
, buf
, &ctx
);
837 #if ((LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) && \
846 unsigned char *p
= bitmap
+ bm
->width
* (row
>> 3);
847 unsigned char mask
= BIT_N(row
& 7);
849 for (col
= 0; col
< bm
->width
; col
++, p
++)
850 #if !defined(HAVE_LCD_COLOR) && \
851 (LCD_DEPTH > 1 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1))
855 if (brightness(*qp
++) < 128)
861 return totalsize
; /* return the used buffer size. */