10 #if GFX_USE_GDISP && GDISP_NEED_IMAGE && GDISP_NEED_IMAGE_BMP
14 #if GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE * (COLOR_TYPE_BITS/8) < 40
15 #if GFX_COMPILER_WARNING_TYPE == GFX_COMPILER_WARNING_DIRECT
16 #warning "GDISP: GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE must be at least 40 bytes. It has been adjusted for you."
17 #elif GFX_COMPILER_WARNING_TYPE == GFX_COMPILER_WARNING_MACRO
18 COMPILER_WARNING(
"GDISP: GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE must be at least 40 bytes. It has been adjusted for you.")
20 #undef GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE
21 #define GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE ((40 + (COLOR_TYPE_BITS/8) - 1) / (COLOR_TYPE_BITS/8))
24 typedef struct gdispImagePrivate_BMP {
28 #define BMP_PALETTE 0x04
29 #define BMP_COMP_RLE 0x08
30 #define BMP_COMP_MASK 0x10
31 #define BMP_RLE_ENC 0x20
32 #define BMP_RLE_ABS 0x40
33 #define BMP_TOP_TO_BOTTOM 0x80
35 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
39 #if GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8_RLE
43 #if GDISP_NEED_IMAGE_BMP_16 || GDISP_NEED_IMAGE_BMP_32
56 } gdispImagePrivate_BMP;
58 void gdispImageClose_BMP(
gImage *img) {
59 gdispImagePrivate_BMP *priv;
61 priv = (gdispImagePrivate_BMP *)img->priv;
63 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
65 gdispImageFree(img, (
void *)priv->palette, priv->palsize*
sizeof(
gColor));
67 if (priv->frame0cache)
68 gdispImageFree(img, (
void *)priv->frame0cache, img->width*img->height*
sizeof(
gPixel));
69 gdispImageFree(img, (
void *)priv,
sizeof(gdispImagePrivate_BMP));
75 gdispImagePrivate_BMP *priv;
79 gU32 offsetColorTable;
83 return GDISP_IMAGE_ERR_BADFORMAT;
91 if (hdr[0] !=
'B' || hdr[1] !=
'M')
92 return GDISP_IMAGE_ERR_BADFORMAT;
98 if (!(img->priv = gdispImageAlloc(img,
sizeof(gdispImagePrivate_BMP))))
99 return GDISP_IMAGE_ERR_NOMEMORY;
102 priv = (gdispImagePrivate_BMP *)img->priv;
103 priv->frame0cache = 0;
110 if (
gfileRead(img->f, priv->buf, 8) != 8)
114 if (
gfileRead(img->f, &priv->frame0pos, 4) != 4)
116 gdispImageMakeLE32(priv->frame0pos);
121 if (
gfileRead(img->f, &offsetColorTable, 4) != 4)
123 gdispImageMakeLE32(offsetColorTable);
124 offsetColorTable += 14;
127 if (offsetColorTable == 12+14) {
128 priv->bmpflags |= BMP_V2;
131 if (
gfileRead(img->f, priv->buf, 12-4) != 12-4)
134 img->width = gdispImageGetAlignedLE16(priv->buf, 0);
136 img->height = gdispImageGetAlignedLE16(priv->buf, 2);
137 if (img->height < 0) {
138 priv->bmpflags |= BMP_TOP_TO_BOTTOM;
139 img->height = -img->height;
142 aword = gdispImageGetAlignedLE16(priv->buf, 4);
144 goto unsupportedcleanup;
146 aword = gdispImageGetAlignedLE16(priv->buf, 6);
148 #if GDISP_NEED_IMAGE_BMP_1
151 #if GDISP_NEED_IMAGE_BMP_4
154 #if GDISP_NEED_IMAGE_BMP_8
157 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_8
158 priv->bmpflags |= BMP_PALETTE;
159 priv->palsize = 1<<aword;
162 #if GDISP_NEED_IMAGE_BMP_24
167 goto unsupportedcleanup;
169 priv->bitsperpixel = aword;
171 }
else if (offsetColorTable >= 40+14) {
172 if (offsetColorTable > 40+14)
173 priv->bmpflags |= BMP_V4;
176 if (
gfileRead(img->f, priv->buf, 40-4) != 40-4)
179 adword = gdispImageGetAlignedLE32(priv->buf, 0);
181 goto unsupportedcleanup;
184 adword = gdispImageGetAlignedLE32(priv->buf, 4);
185 if ((gI32)adword < 0) {
186 priv->bmpflags |= BMP_TOP_TO_BOTTOM;
190 goto unsupportedcleanup;
191 img->height = adword;
193 aword = gdispImageGetAlignedLE16(priv->buf, 8);
195 goto unsupportedcleanup;
197 aword = gdispImageGetAlignedLE16(priv->buf, 10);
199 #if GDISP_NEED_IMAGE_BMP_1
202 #if GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE
205 #if GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
208 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
209 priv->bmpflags |= BMP_PALETTE;
210 priv->palsize = 1<<aword;
213 #if GDISP_NEED_IMAGE_BMP_16
216 #if GDISP_NEED_IMAGE_BMP_24
219 #if GDISP_NEED_IMAGE_BMP_32
222 #if GDISP_NEED_IMAGE_BMP_16 || GDISP_NEED_IMAGE_BMP_24 || GDISP_NEED_IMAGE_BMP_32
226 goto unsupportedcleanup;
228 priv->bitsperpixel = aword;
230 adword = gdispImageGetAlignedLE32(priv->buf, 12);
234 #if GDISP_NEED_IMAGE_BMP_8_RLE
236 if (priv->bitsperpixel != 8)
237 goto unsupportedcleanup;
238 priv->bmpflags |= BMP_COMP_RLE;
241 #if GDISP_NEED_IMAGE_BMP_4_RLE
243 if (priv->bitsperpixel != 4)
244 goto unsupportedcleanup;
245 priv->bmpflags |= BMP_COMP_RLE;
248 #if GDISP_NEED_IMAGE_BMP_16 || GDISP_NEED_IMAGE_BMP_32
250 if (priv->bitsperpixel < 16 || priv->bitsperpixel == 24)
251 goto unsupportedcleanup;
252 priv->bmpflags |= BMP_COMP_MASK;
253 if (priv->bmpflags & BMP_V4)
254 offsetColorTable = 40+14;
258 goto unsupportedcleanup;
260 priv->bitsperpixel = aword;
261 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
263 adword = gdispImageGetAlignedLE32(priv->buf, 28);
264 if (adword && adword < priv->palsize)
265 priv->palsize = adword;
270 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
272 if (priv->bmpflags & BMP_PALETTE) {
275 if (!(priv->palette = (
gColor *)gdispImageAlloc(img, priv->palsize*
sizeof(
gColor))))
276 return GDISP_IMAGE_ERR_NOMEMORY;
277 if (priv->bmpflags & BMP_V2) {
278 for(aword = 0; aword < priv->palsize; aword++) {
279 if (
gfileRead(img->f, &priv->buf, 3) != 3)
goto baddatacleanup;
280 priv->palette[aword] =
RGB2COLOR(((gU8 *)priv->buf)[2], ((gU8 *)priv->buf)[1], ((gU8 *)priv->buf)[0]);
283 for(aword = 0; aword < priv->palsize; aword++) {
284 if (
gfileRead(img->f, &priv->buf, 4) != 4)
goto baddatacleanup;
285 priv->palette[aword] =
RGB2COLOR(((gU8 *)priv->buf)[2], ((gU8 *)priv->buf)[1], ((gU8 *)priv->buf)[0]);
292 #if GDISP_NEED_IMAGE_BMP_16 || GDISP_NEED_IMAGE_BMP_32
294 if (priv->bmpflags & BMP_COMP_MASK) {
296 if (
gfileRead(img->f, &priv->maskred, 4) != 4)
goto baddatacleanup;
297 gdispImageMakeLE32(priv->maskred);
298 if (
gfileRead(img->f, &priv->maskgreen, 4) != 4)
goto baddatacleanup;
299 gdispImageMakeLE32(priv->maskgreen);
300 if (
gfileRead(img->f, &priv->maskblue, 4) != 4)
goto baddatacleanup;
301 gdispImageMakeLE32(priv->maskblue);
302 if (priv->bmpflags & BMP_V4) {
303 if (
gfileRead(img->f, &priv->maskalpha, 4) != 4)
goto baddatacleanup;
304 gdispImageMakeLE32(priv->maskalpha);
307 }
else if (priv->bitsperpixel == 16) {
308 priv->bmpflags |= BMP_COMP_MASK;
309 priv->maskred = 0x7C00;
310 priv->maskgreen = 0x03E0;
311 priv->maskblue = 0x001F;
313 }
else if (priv->bitsperpixel == 32) {
314 priv->bmpflags |= BMP_COMP_MASK;
315 priv->maskred = 0x00FF0000;
316 priv->maskgreen = 0x0000FF00;
317 priv->maskblue = 0x000000FF;
322 if (priv->bmpflags & BMP_COMP_MASK) {
324 priv->shiftgreen = 0;
327 if (priv->maskred < 256)
328 for(adword = priv->maskred; adword < 128; priv->shiftred--, adword <<= 1);
330 for(adword = priv->maskred; adword > 255; priv->shiftred++, adword >>= 1);
332 if (priv->maskgreen) {
333 if (priv->maskgreen < 256)
334 for(adword = priv->maskgreen; adword < 128; priv->shiftgreen--, adword <<= 1);
336 for(adword = priv->maskgreen; adword > 255; priv->shiftgreen++, adword >>= 1);
338 if (priv->maskblue) {
339 if (priv->maskblue < 256)
340 for(adword = priv->maskblue; adword < 128; priv->shiftblue--, adword <<= 1);
342 for(adword = priv->maskblue; adword > 255; priv->shiftblue++, adword >>= 1);
344 if (priv->maskalpha) {
345 if (priv->maskalpha < 256)
346 for(adword = priv->maskalpha; adword < 128; priv->shiftalpha--, adword <<= 1);
348 for(adword = priv->maskalpha; adword > 255; priv->shiftalpha++, adword >>= 1);
353 img->type = GDISP_IMAGE_TYPE_BMP;
354 return GDISP_IMAGE_ERR_OK;
357 gdispImageClose_BMP(img);
358 return GDISP_IMAGE_ERR_BADDATA;
361 gdispImageClose_BMP(img);
362 return GDISP_IMAGE_ERR_UNSUPPORTED;
366 gdispImagePrivate_BMP * priv;
370 priv = (gdispImagePrivate_BMP *)img->priv;
374 switch(priv->bitsperpixel) {
375 #if GDISP_NEED_IMAGE_BMP_1
381 priv = (gdispImagePrivate_BMP *)img->priv;
389 for(m=0x80; m; m >>= 1, pc++)
390 pc[0] = priv->palette[(m&b[0]) ? 1 : 0];
391 for(m=0x80; m; m >>= 1, pc++)
392 pc[0] = priv->palette[(m&b[1]) ? 1 : 0];
393 for(m=0x80; m; m >>= 1, pc++)
394 pc[0] = priv->palette[(m&b[2]) ? 1 : 0];
395 for(m=0x80; m; m >>= 1, pc++)
396 pc[0] = priv->palette[(m&b[3]) ? 1 : 0];
404 #if GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_4_RLE
406 #if GDISP_NEED_IMAGE_BMP_4_RLE
407 #if GDISP_NEED_IMAGE_BMP_4
408 if (priv->bmpflags & BMP_COMP_RLE)
413 while(x < img->width) {
414 if (priv->bmpflags & BMP_RLE_ENC) {
416 *pc++ = priv->palette[priv->rlecode >> 4];
421 *pc++ = priv->palette[priv->rlecode & 0x0F];
429 }
else if (priv->bmpflags & BMP_RLE_ABS) {
433 *pc++ = priv->palette[b[0] >> 4];
438 *pc++ = priv->palette[b[0] & 0x0F];
453 priv->bmpflags &= ~(BMP_RLE_ENC|BMP_RLE_ABS);
461 priv->rlecode = b[1];
462 priv->bmpflags |= BMP_RLE_ENC;
463 }
else if (b[1] == 0) {
464 if (x < img->width) {
465 priv->rlerun = img->width - x;
467 priv->bmpflags |= BMP_RLE_ENC;
469 }
else if (b[1] == 1) {
471 }
else if (b[1] == 2) {
475 priv->rlerun = b[0] + (gU16)b[1] * img->width;
477 priv->bmpflags |= BMP_RLE_ENC;
480 priv->bmpflags |= BMP_RLE_ABS;
486 #if GDISP_NEED_IMAGE_BMP_4
494 *pc++ = priv->palette[b[0] >> 4];
495 *pc++ = priv->palette[b[0] & 0x0F];
496 *pc++ = priv->palette[b[1] >> 4];
497 *pc++ = priv->palette[b[1] & 0x0F];
498 *pc++ = priv->palette[b[2] >> 4];
499 *pc++ = priv->palette[b[2] & 0x0F];
500 *pc++ = priv->palette[b[3] >> 4];
501 *pc++ = priv->palette[b[3] & 0x0F];
510 #if GDISP_NEED_IMAGE_BMP_8 || GDISP_NEED_IMAGE_BMP_8_RLE
512 #if GDISP_NEED_IMAGE_BMP_8_RLE
513 #if GDISP_NEED_IMAGE_BMP_8
514 if (priv->bmpflags & BMP_COMP_RLE)
519 while(x < img->width) {
520 if (priv->bmpflags & BMP_RLE_ENC) {
522 *pc++ = priv->palette[priv->rlecode];
529 }
else if (priv->bmpflags & BMP_RLE_ABS) {
533 *pc++ = priv->palette[b[0]];
547 priv->bmpflags &= ~(BMP_RLE_ENC|BMP_RLE_ABS);
555 priv->rlecode = b[1];
556 priv->bmpflags |= BMP_RLE_ENC;
557 }
else if (b[1] == 0) {
558 if (x < img->width) {
559 priv->rlerun = img->width - x;
561 priv->bmpflags |= BMP_RLE_ENC;
563 }
else if (b[1] == 1) {
565 }
else if (b[1] == 2) {
568 return (
gCoord)GDISP_IMAGE_ERR_BADDATA;
569 priv->rlerun = b[0] + (gU16)b[1] * img->width;
571 priv->bmpflags |= BMP_RLE_ENC;
574 priv->bmpflags |= BMP_RLE_ABS;
580 #if GDISP_NEED_IMAGE_BMP_8
588 *pc++ = priv->palette[b[0]];
589 *pc++ = priv->palette[b[1]];
590 *pc++ = priv->palette[b[2]];
591 *pc++ = priv->palette[b[3]];
600 #if GDISP_NEED_IMAGE_BMP_16
609 gdispImageMakeLE16(w[0]);
610 gdispImageMakeLE16(w[1]);
611 if (priv->shiftred < 0)
612 r = (
gColor)((w[0] & priv->maskred) << -priv->shiftred);
614 r = (
gColor)((w[0] & priv->maskred) >> priv->shiftred);
615 if (priv->shiftgreen < 0)
616 g = (
gColor)((w[0] & priv->maskgreen) << -priv->shiftgreen);
618 g = (
gColor)((w[0] & priv->maskgreen) >> priv->shiftgreen);
619 if (priv->shiftblue < 0)
620 b = (
gColor)((w[0] & priv->maskblue) << -priv->shiftblue);
622 b = (
gColor)((w[0] & priv->maskblue) >> priv->shiftblue);
625 if (priv->shiftred < 0)
626 r = (
gColor)((w[1] & priv->maskred) << -priv->shiftred);
628 r = (
gColor)((w[1] & priv->maskred) >> priv->shiftred);
629 if (priv->shiftgreen < 0)
630 g = (
gColor)((w[1] & priv->maskgreen) << -priv->shiftgreen);
632 g = (
gColor)((w[1] & priv->maskgreen) >> priv->shiftgreen);
633 if (priv->shiftblue < 0)
634 b = (
gColor)((w[1] & priv->maskblue) << -priv->shiftblue);
636 b = (gU8)((w[1] & priv->maskblue) >> priv->shiftblue);
646 #if GDISP_NEED_IMAGE_BMP_24
659 if (x >= img->width) {
661 if ((x & 3) &&
gfileRead(img->f, &b, x & 3) != (x & 3))
668 #if GDISP_NEED_IMAGE_BMP_32
677 gdispImageMakeLE32(dw);
678 if (priv->shiftred < 0)
679 r = (
gColor)((dw & priv->maskred) << -priv->shiftred);
681 r = (
gColor)((dw & priv->maskred) >> priv->shiftred);
682 if (priv->shiftgreen < 0)
683 g = (
gColor)((dw & priv->maskgreen) << -priv->shiftgreen);
685 g = (
gColor)((dw & priv->maskgreen) >> priv->shiftgreen);
686 if (priv->shiftblue < 0)
687 b = (
gColor)((dw & priv->maskblue) << -priv->shiftblue);
689 b = (
gColor)((dw & priv->maskblue) >> priv->shiftblue);
705 gdispImagePrivate_BMP * priv;
712 priv = (gdispImagePrivate_BMP *)img->priv;
713 if (priv->frame0cache)
714 return GDISP_IMAGE_ERR_OK;
717 len = img->width * img->height *
sizeof(
gPixel);
718 priv->frame0cache = (
gPixel *)gdispImageAlloc(img, len);
719 if (!priv->frame0cache)
720 return GDISP_IMAGE_ERR_NOMEMORY;
724 #if GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8_RLE
731 if (priv->bmpflags & BMP_TOP_TO_BOTTOM) {
732 for(y = 0, pcd = priv->frame0cache; y < img->height; y++) {
734 while(x < img->width) {
736 if (!(pos = getPixels(img, x)))
737 return GDISP_IMAGE_ERR_BADDATA;
745 for(y = img->height-1, pcd = priv->frame0cache + img->width*(img->height-1); y >= 0; y--, pcd -= 2*img->width) {
747 while(x < img->width) {
749 if (!(pos = getPixels(img, x)))
750 return GDISP_IMAGE_ERR_BADDATA;
759 return GDISP_IMAGE_ERR_OK;
763 gdispImagePrivate_BMP * priv;
767 priv = (gdispImagePrivate_BMP *)img->priv;
770 if (sx >= img->width || sy >= img->height)
return GDISP_IMAGE_ERR_OK;
771 if (sx + cx > img->width) cx = img->width - sx;
772 if (sy + cy > img->height) cy = img->height - sy;
775 if (priv->frame0cache) {
776 gdispGBlitArea(g, x, y, cx, cy, sx, sy, img->width, priv->frame0cache);
777 return GDISP_IMAGE_ERR_OK;
782 #if GDISP_NEED_IMAGE_BMP_4_RLE || GDISP_NEED_IMAGE_BMP_8_RLE
787 if (priv->bmpflags & BMP_TOP_TO_BOTTOM) {
788 for(my = 0; my < img->height; my++) {
790 while(mx < img->width) {
791 if (!(pos = getPixels(img, mx)))
792 return GDISP_IMAGE_ERR_BADDATA;
793 if (my >= sy && my < sy+cy && mx < sx+cx && mx+pos >= sx) {
794 st = mx < sx ? sx - mx : 0;
796 if (mx+st+len > sx+cx) len = sx+cx-mx-st;
800 gdispGBlitArea(g, x+mx+st-sx, y+my-sy, len, 1, st, 0, pos, priv->buf);
806 for(my = img->height-1; my >= 0; my--) {
808 while(mx < img->width) {
809 if (!(pos = getPixels(img, mx)))
810 return GDISP_IMAGE_ERR_BADDATA;
811 if (my >= sy && my < sy+cy && mx < sx+cx && mx+pos >= sx) {
812 st = mx < sx ? sx - mx : 0;
814 if (mx+st+len > sx+cx) len = sx+cx-mx-st;
818 gdispGBlitArea(g, x+mx+st-sx, y+my-sy, len, 1, st, 0, pos, priv->buf);
825 return GDISP_IMAGE_ERR_OK;
828 gDelay gdispImageNext_BMP(
gImage *img) {
832 return gDelayForever;
835 gU16 gdispImageGetPaletteSize_BMP(
gImage *img) {
836 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_8
837 gdispImagePrivate_BMP *priv;
839 priv = (gdispImagePrivate_BMP *)img->priv;
843 if (!(priv->bmpflags & BMP_PALETTE))
846 return priv->palsize;
852 gColor gdispImageGetPalette_BMP(
gImage *img, gU16 index) {
853 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_8
854 gdispImagePrivate_BMP *priv;
856 priv = (gdispImagePrivate_BMP *)img->priv;
860 if (!(priv->bmpflags & BMP_PALETTE))
863 if (index >= priv->palsize)
866 return priv->palette[(gU8)index];
873 gBool gdispImageAdjustPalette_BMP(
gImage *img, gU16 index,
gColor newColor) {
874 #if GDISP_NEED_IMAGE_BMP_1 || GDISP_NEED_IMAGE_BMP_4 || GDISP_NEED_IMAGE_BMP_8
875 gdispImagePrivate_BMP *priv;
877 priv = (gdispImagePrivate_BMP *)img->priv;
881 if (!(priv->bmpflags & BMP_PALETTE))
884 if (index >= priv->palsize)
887 priv->palette[(gU8)index] = newColor;
GDISP image support routines header file.
#define RGB2COLOR(r, g, b)
Convert red, green, blue (each 0 to 255) into a color value.
COLOR_TYPE gColor
The color type definition.
void gdispGDrawPixel(GDisplay *g, gCoord x, gCoord y, gColor color)
Set a pixel in the specified color.
#define GDISP_NEED_IMAGE_BMP_8_RLE
Is BMP 8 bits per pixel (256 color) with RLE compression image decoding required.
void gdispGBlitArea(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord srcx, gCoord srcy, gCoord srccx, const gPixel *buffer)
Fill an area using the supplied bitmap.
gColor gPixel
The pixel format.
#define GDISP_NEED_IMAGE_BMP_1
Is BMP 1 bit per pixel (monochrome/2 color) image decoding required.
#define GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE
The BMP blit buffer size in pixels.
#define GDISP_NEED_IMAGE_BMP_8
Is BMP 8 bits per pixel (256 color) image decoding required.
gI16 gCoord
The type for a coordinate or length on the screen.
#define GDISP_NEED_IMAGE_BMP_4
Is BMP 4 bits per pixel (16 color) image decoding required.
#define GDISP_NEED_IMAGE_BMP_4_RLE
Is BMP 4 bits per pixel (16 color) with RLE compression image decoding required.
gBool gfileSetPos(GFILE *f, gFileSize pos)
Set the position of the read/write cursor.
gMemSize gfileRead(GFILE *f, void *buf, gMemSize len)
Read from file.
gFileSize gfileGetPos(GFILE *f)
Get the current position of the read/write cursor.
gU16 gdispImageError
An image error code.
The structure for an image.