diff options
author | Jens Arnold <amiconn@rockbox.org> | 2009-02-09 23:34:44 +0000 |
---|---|---|
committer | Jens Arnold <amiconn@rockbox.org> | 2009-02-09 23:34:44 +0000 |
commit | 309a3c4590ea0ed3cf028cfc7f1372ca019fe638 (patch) | |
tree | 1f0828d5876f280686ba83bcd2589d9b9f808cda | |
parent | a12c2d59ade3f8d4c1edb56ad4812836766df95b (diff) | |
download | rockbox-309a3c4590ea0ed3cf028cfc7f1372ca019fe638.tar.gz rockbox-309a3c4590ea0ed3cf028cfc7f1372ca019fe638.zip |
More compact screendump routines for core and greylib. The core routine might be a little slower for vertically packed mono and greyscale displays, the greylib one should be faster in all cases. * Reduce stack usage of greyscale screendump on the Clip* Rename a macro in the bitmap LCD simulation.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@19959 a1c6a512-1295-4272-9138-f99709370657
-rw-r--r-- | apps/misc.c | 179 | ||||
-rw-r--r-- | apps/plugins/lib/grey_core.c | 173 | ||||
-rw-r--r-- | uisimulator/sdl/lcd-bitmap.c | 24 |
3 files changed, 177 insertions, 199 deletions
diff --git a/apps/misc.c b/apps/misc.c index 43dfd45e51..0d244563d0 100644 --- a/apps/misc.c +++ b/apps/misc.c | |||
@@ -425,21 +425,23 @@ static void (*screen_dump_hook)(int fh) = NULL; | |||
425 | 425 | ||
426 | void screen_dump(void) | 426 | void screen_dump(void) |
427 | { | 427 | { |
428 | int fh; | 428 | int fd, y; |
429 | char filename[MAX_PATH]; | 429 | char filename[MAX_PATH]; |
430 | int bx, by; | 430 | |
431 | fb_data *src; | ||
431 | #if LCD_DEPTH == 1 | 432 | #if LCD_DEPTH == 1 |
432 | static unsigned char line_block[8][BMP_LINESIZE]; | 433 | unsigned mask; |
433 | #elif LCD_DEPTH == 2 | 434 | unsigned val; |
434 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING | 435 | #elif (LCD_DEPTH == 2) && (LCD_PIXELFORMAT != HORIZONTAL_PACKING) |
435 | static unsigned char line_block[BMP_LINESIZE]; | 436 | int shift; |
436 | #elif LCD_PIXELFORMAT == VERTICAL_PACKING | 437 | unsigned val; |
437 | static unsigned char line_block[4][BMP_LINESIZE]; | ||
438 | #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED | ||
439 | static unsigned char line_block[8][BMP_LINESIZE]; | ||
440 | #endif | 438 | #endif |
441 | #elif LCD_DEPTH == 16 | 439 | #if LCD_DEPTH <= 8 |
442 | static unsigned short line_block[BMP_LINESIZE/2]; | 440 | unsigned char *dst, *dst_end; |
441 | unsigned char linebuf[BMP_LINESIZE]; | ||
442 | #elif LCD_DEPTH <= 16 | ||
443 | unsigned short *dst, *dst_end; | ||
444 | unsigned short linebuf[BMP_LINESIZE/2]; | ||
443 | #endif | 445 | #endif |
444 | 446 | ||
445 | #if CONFIG_RTC | 447 | #if CONFIG_RTC |
@@ -449,132 +451,97 @@ void screen_dump(void) | |||
449 | IF_CNFN_NUM_(, NULL)); | 451 | IF_CNFN_NUM_(, NULL)); |
450 | #endif | 452 | #endif |
451 | 453 | ||
452 | fh = creat(filename); | 454 | fd = creat(filename); |
453 | if (fh < 0) | 455 | if (fd < 0) |
454 | return; | 456 | return; |
455 | 457 | ||
456 | if (screen_dump_hook) | 458 | if (screen_dump_hook) |
457 | { | 459 | { |
458 | screen_dump_hook(fh); | 460 | screen_dump_hook(fd); |
459 | } | 461 | } |
460 | else | 462 | else |
461 | { | 463 | { |
462 | write(fh, bmpheader, sizeof(bmpheader)); | 464 | write(fd, bmpheader, sizeof(bmpheader)); |
463 | 465 | ||
464 | /* BMP image goes bottom up */ | 466 | /* BMP image goes bottom up */ |
465 | #if LCD_DEPTH == 1 | 467 | for (y = LCD_HEIGHT - 1; y >= 0; y--) |
466 | for (by = LCD_FBHEIGHT - 1; by >= 0; by--) | 468 | { |
467 | { | 469 | memset(linebuf, 0, BMP_LINESIZE); |
468 | unsigned char *src = &lcd_framebuffer[by][0]; | ||
469 | unsigned char *dst = &line_block[7][0]; | ||
470 | |||
471 | memset(line_block, 0, sizeof(line_block)); | ||
472 | 470 | ||
473 | #ifdef HAVE_LCD_SPLIT | 471 | #if defined(HAVE_LCD_SPLIT) && (LCD_SPLIT_LINES == 2) |
474 | if (by == (LCD_SPLIT_POS/8 - 1)) | 472 | if (y == LCD_SPLIT_POS - 1) |
475 | write(fh, line_block, LCD_SPLIT_LINES * sizeof(line_block[0])); | ||
476 | #endif | ||
477 | for (bx = LCD_WIDTH/2; bx > 0; bx--) | ||
478 | { | 473 | { |
479 | unsigned char *dst_blk = dst++; | 474 | write(fd, linebuf, BMP_LINESIZE); |
480 | unsigned src_byte0 = *src++ << 4; | 475 | write(fd, linebuf, BMP_LINESIZE); |
481 | unsigned src_byte1 = *src++; | 476 | } |
482 | int iy; | 477 | #endif |
478 | dst = linebuf; | ||
483 | 479 | ||
484 | for (iy = 8; iy > 0; iy--) | 480 | #if LCD_DEPTH == 1 |
485 | { | 481 | dst_end = dst + LCD_WIDTH/2; |
486 | *dst_blk = (src_byte0 & 0x10) | 482 | src = lcd_framebuffer[y >> 3]; |
487 | | (src_byte1 & 0x01) | 483 | mask = 1 << (y & 7); |
484 | |||
485 | do | ||
486 | { | ||
487 | val = (*src++ & mask) ? 0x10 : 0; | ||
488 | val |= (*src++ & mask) ? 0x01 : 0; | ||
488 | #ifdef HAVE_LCD_SPLIT | 489 | #ifdef HAVE_LCD_SPLIT |
489 | | (by < (LCD_SPLIT_POS/8) ? 0x22 : 0) | 490 | if (y < LCD_SPLIT_POS) |
491 | val |= 0x22; | ||
490 | #endif | 492 | #endif |
491 | ; | 493 | *dst++ = val; |
492 | src_byte0 >>= 1; | ||
493 | src_byte1 >>= 1; | ||
494 | dst_blk -= BMP_LINESIZE; | ||
495 | } | ||
496 | } | 494 | } |
495 | while (dst < dst_end); | ||
497 | 496 | ||
498 | write(fh, line_block, sizeof(line_block)); | ||
499 | } | ||
500 | #elif LCD_DEPTH == 2 | 497 | #elif LCD_DEPTH == 2 |
498 | dst_end = dst + LCD_WIDTH/2; | ||
499 | |||
501 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING | 500 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING |
502 | for (by = LCD_FBHEIGHT - 1; by >= 0; by--) | 501 | src = lcd_framebuffer[y]; |
503 | { | ||
504 | unsigned char *src = &lcd_framebuffer[by][0]; | ||
505 | unsigned char *dst = line_block; | ||
506 | 502 | ||
507 | memset(line_block, 0, sizeof(line_block)); | 503 | do |
508 | for (bx = LCD_FBWIDTH; bx > 0; bx--) | ||
509 | { | 504 | { |
510 | unsigned src_byte = *src++; | 505 | unsigned data = *src++; |
511 | 506 | ||
512 | *dst++ = ((src_byte >> 2) & 0x30) | ((src_byte >> 4) & 0x03); | 507 | *dst++ = (data >> 2) & 0x30 | (data >> 4) & 0x03; |
513 | *dst++ = ((src_byte << 2) & 0x30) | (src_byte & 0x03); | 508 | *dst++ = (data << 2) & 0x30 | data & 0x03; |
514 | } | 509 | } |
510 | while (dst < dst_end); | ||
515 | 511 | ||
516 | write(fh, line_block, sizeof(line_block)); | ||
517 | } | ||
518 | #elif LCD_PIXELFORMAT == VERTICAL_PACKING | 512 | #elif LCD_PIXELFORMAT == VERTICAL_PACKING |
519 | for (by = LCD_FBHEIGHT - 1; by >= 0; by--) | 513 | src = lcd_framebuffer[y >> 2]; |
520 | { | 514 | shift = 2 * (y & 3); |
521 | unsigned char *src = &lcd_framebuffer[by][0]; | ||
522 | unsigned char *dst = &line_block[3][0]; | ||
523 | 515 | ||
524 | memset(line_block, 0, sizeof(line_block)); | 516 | do |
525 | for (bx = LCD_WIDTH/2; bx > 0; bx--) | ||
526 | { | 517 | { |
527 | unsigned char *dst_blk = dst++; | 518 | val = ((*src++ >> shift) & 3) << 4; |
528 | unsigned src_byte0 = *src++ << 4; | 519 | val |= ((*src++ >> shift) & 3); |
529 | unsigned src_byte1 = *src++; | 520 | *dst++ = val; |
530 | int iy; | ||
531 | |||
532 | for (iy = 4; iy > 0; iy--) | ||
533 | { | ||
534 | *dst_blk = (src_byte0 & 0x30) | (src_byte1 & 0x03); | ||
535 | src_byte0 >>= 2; | ||
536 | src_byte1 >>= 2; | ||
537 | dst_blk -= BMP_LINESIZE; | ||
538 | } | ||
539 | } | 521 | } |
522 | while (dst < dst_end); | ||
540 | 523 | ||
541 | write(fh, line_block, sizeof(line_block)); | ||
542 | } | ||
543 | #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED | 524 | #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED |
544 | for (by = LCD_FBHEIGHT - 1; by >= 0; by--) | 525 | src = lcd_framebuffer[y >> 3]; |
545 | { | 526 | shift = y & 7; |
546 | const fb_data *src = &lcd_framebuffer[by][0]; | ||
547 | unsigned char *dst = &line_block[7][0]; | ||
548 | 527 | ||
549 | memset(line_block, 0, sizeof(line_block)); | 528 | do |
550 | for (bx = LCD_WIDTH/2; bx > 0; bx--) | ||
551 | { | 529 | { |
552 | unsigned char *dst_blk = dst++; | 530 | unsigned data = (*src++ >> shift) & 0x0101; |
553 | unsigned src_data0 = *src++ << 4; | ||
554 | unsigned src_data1 = *src++; | ||
555 | int iy; | ||
556 | 531 | ||
557 | for (iy = 8; iy > 0; iy--) | 532 | val = (((data >> 7) | data) & 3) << 4; |
558 | { | 533 | data = (*src++ >> shift) & 0x0101; |
559 | *dst_blk = (src_data0 & 0x10) | (src_data1 & 0x01) | 534 | val |= ((data >> 7) | data) & 3; |
560 | | ((src_data0 & 0x1000) | (src_data1 & 0x0100)) >> 7; | 535 | *dst++ = val; |
561 | src_data0 >>= 1; | ||
562 | src_data1 >>= 1; | ||
563 | dst_blk -= BMP_LINESIZE; | ||
564 | } | ||
565 | } | 536 | } |
537 | while (dst < dst_end); | ||
566 | 538 | ||
567 | write(fh, line_block, sizeof(line_block)); | ||
568 | } | ||
569 | #endif | 539 | #endif |
570 | #elif LCD_DEPTH == 16 | 540 | #elif LCD_DEPTH == 16 |
571 | for (by = LCD_HEIGHT - 1; by >= 0; by--) | 541 | dst_end = dst + LCD_WIDTH; |
572 | { | 542 | src = lcd_framebuffer[y]; |
573 | unsigned short *src = &lcd_framebuffer[by][0]; | 543 | |
574 | unsigned short *dst = line_block; | 544 | do |
575 | |||
576 | memset(line_block, 0, sizeof(line_block)); | ||
577 | for (bx = LCD_WIDTH; bx > 0; bx--) | ||
578 | { | 545 | { |
579 | #if (LCD_PIXELFORMAT == RGB565SWAPPED) | 546 | #if (LCD_PIXELFORMAT == RGB565SWAPPED) |
580 | /* iPod LCD data is big endian although the CPU is not */ | 547 | /* iPod LCD data is big endian although the CPU is not */ |
@@ -583,13 +550,13 @@ void screen_dump(void) | |||
583 | *dst++ = htole16(*src++); | 550 | *dst++ = htole16(*src++); |
584 | #endif | 551 | #endif |
585 | } | 552 | } |
553 | while (dst < dst_end); | ||
586 | 554 | ||
587 | write(fh, line_block, sizeof(line_block)); | ||
588 | } | ||
589 | #endif /* LCD_DEPTH */ | 555 | #endif /* LCD_DEPTH */ |
556 | write(fd, linebuf, BMP_LINESIZE); | ||
557 | } | ||
590 | } | 558 | } |
591 | 559 | close(fd); | |
592 | close(fh); | ||
593 | } | 560 | } |
594 | 561 | ||
595 | void screen_dump_set_hook(void (*hook)(int fh)) | 562 | void screen_dump_set_hook(void (*hook)(int fh)) |
diff --git a/apps/plugins/lib/grey_core.c b/apps/plugins/lib/grey_core.c index a7e8f2a08b..88becb1336 100644 --- a/apps/plugins/lib/grey_core.c +++ b/apps/plugins/lib/grey_core.c | |||
@@ -708,10 +708,10 @@ void grey_deferred_lcd_update(void) | |||
708 | /*** Screenshot ***/ | 708 | /*** Screenshot ***/ |
709 | 709 | ||
710 | #ifdef HAVE_LCD_SPLIT | 710 | #ifdef HAVE_LCD_SPLIT |
711 | #define GRADIENT_MAX 127 | 711 | #define NUM_SHADES 128 |
712 | #define BMP_NUMCOLORS 256 | 712 | #define BMP_NUMCOLORS 256 |
713 | #else | 713 | #else |
714 | #define GRADIENT_MAX 128 | 714 | #define NUM_SHADES 129 |
715 | #define BMP_NUMCOLORS 129 | 715 | #define BMP_NUMCOLORS 129 |
716 | #endif | 716 | #endif |
717 | 717 | ||
@@ -754,7 +754,7 @@ static const unsigned char colorindex[4] = {128, 85, 43, 0}; | |||
754 | static void grey_screendump_hook(int fd) | 754 | static void grey_screendump_hook(int fd) |
755 | { | 755 | { |
756 | int i; | 756 | int i; |
757 | int x, y, gx, gy; | 757 | int y, gx, gy; |
758 | #if LCD_PIXELFORMAT == VERTICAL_PACKING | 758 | #if LCD_PIXELFORMAT == VERTICAL_PACKING |
759 | #if LCD_DEPTH == 1 | 759 | #if LCD_DEPTH == 1 |
760 | unsigned val; | 760 | unsigned val; |
@@ -766,45 +766,50 @@ static void grey_screendump_hook(int fd) | |||
766 | unsigned data; | 766 | unsigned data; |
767 | int shift; | 767 | int shift; |
768 | #endif /* LCD_PIXELFORMAT */ | 768 | #endif /* LCD_PIXELFORMAT */ |
769 | fb_data *lcdptr; | 769 | fb_data *src; |
770 | unsigned char *clut_entry; | 770 | unsigned char *gsrc; |
771 | unsigned char linebuf[MAX(4*BMP_NUMCOLORS,BMP_LINESIZE)]; | 771 | unsigned char *dst, *dst_end; |
772 | unsigned char linebuf[MAX(4*NUM_SHADES,BMP_LINESIZE)]; | ||
772 | 773 | ||
773 | rb->write(fd, bmpheader, sizeof(bmpheader)); /* write header */ | 774 | rb->write(fd, bmpheader, sizeof(bmpheader)); /* write header */ |
774 | 775 | ||
775 | /* build clut */ | 776 | /* build clut */ |
776 | rb->memset(linebuf, 0, 4*BMP_NUMCOLORS); | 777 | rb->memset(linebuf, 0, 4*NUM_SHADES); |
777 | clut_entry = linebuf; | 778 | dst = linebuf; |
778 | 779 | ||
779 | for (i = 0; i <= GRADIENT_MAX; i++) | 780 | for (i = 0; i < NUM_SHADES; i++) |
780 | { | 781 | { |
781 | *clut_entry++ = (_GREY_MULUQ(BLUE_CMP(LCD_BL_BRIGHTCOLOR) | 782 | *dst++ = (_GREY_MULUQ(BLUE_CMP(LCD_BL_BRIGHTCOLOR) |
782 | -BLUE_CMP(LCD_BL_DARKCOLOR), i) >> 7) | 783 | -BLUE_CMP(LCD_BL_DARKCOLOR), i) >> 7) |
783 | + BLUE_CMP(LCD_BL_DARKCOLOR); | 784 | + BLUE_CMP(LCD_BL_DARKCOLOR); |
784 | *clut_entry++ = (_GREY_MULUQ(GREEN_CMP(LCD_BL_BRIGHTCOLOR) | 785 | *dst++ = (_GREY_MULUQ(GREEN_CMP(LCD_BL_BRIGHTCOLOR) |
785 | -GREEN_CMP(LCD_BL_DARKCOLOR), i) >> 7) | 786 | -GREEN_CMP(LCD_BL_DARKCOLOR), i) >> 7) |
786 | + GREEN_CMP(LCD_BL_DARKCOLOR); | 787 | + GREEN_CMP(LCD_BL_DARKCOLOR); |
787 | *clut_entry++ = (_GREY_MULUQ(RED_CMP(LCD_BL_BRIGHTCOLOR) | 788 | *dst++ = (_GREY_MULUQ(RED_CMP(LCD_BL_BRIGHTCOLOR) |
788 | -RED_CMP(LCD_BL_DARKCOLOR), i) >> 7) | 789 | -RED_CMP(LCD_BL_DARKCOLOR), i) >> 7) |
789 | + RED_CMP(LCD_BL_DARKCOLOR); | 790 | + RED_CMP(LCD_BL_DARKCOLOR); |
790 | clut_entry++; | 791 | dst++; |
791 | } | 792 | } |
793 | rb->write(fd, linebuf, 4*NUM_SHADES); | ||
794 | |||
792 | #ifdef HAVE_LCD_SPLIT | 795 | #ifdef HAVE_LCD_SPLIT |
793 | for (i = 0; i <= GRADIENT_MAX; i++) | 796 | dst = linebuf; |
797 | |||
798 | for (i = 0; i <= NUM_SHADES; i++) | ||
794 | { | 799 | { |
795 | *clut_entry++ = (_GREY_MULUQ(BLUE_CMP(LCD_BL_BRIGHTCOLOR_2) | 800 | *dst++ = (_GREY_MULUQ(BLUE_CMP(LCD_BL_BRIGHTCOLOR_2) |
796 | -BLUE_CMP(LCD_BL_DARKCOLOR_2), i) >> 7) | 801 | -BLUE_CMP(LCD_BL_DARKCOLOR_2), i) >> 7) |
797 | + BLUE_CMP(LCD_BL_DARKCOLOR_2); | 802 | + BLUE_CMP(LCD_BL_DARKCOLOR_2); |
798 | *clut_entry++ = (_GREY_MULUQ(GREEN_CMP(LCD_BL_BRIGHTCOLOR_2) | 803 | *dst++ = (_GREY_MULUQ(GREEN_CMP(LCD_BL_BRIGHTCOLOR_2) |
799 | -GREEN_CMP(LCD_BL_DARKCOLOR_2), i) >> 7) | 804 | -GREEN_CMP(LCD_BL_DARKCOLOR_2), i) >> 7) |
800 | + GREEN_CMP(LCD_BL_DARKCOLOR_2); | 805 | + GREEN_CMP(LCD_BL_DARKCOLOR_2); |
801 | *clut_entry++ = (_GREY_MULUQ(RED_CMP(LCD_BL_BRIGHTCOLOR_2) | 806 | *dst++ = (_GREY_MULUQ(RED_CMP(LCD_BL_BRIGHTCOLOR_2) |
802 | -RED_CMP(LCD_BL_DARKCOLOR_2), i) >> 7) | 807 | -RED_CMP(LCD_BL_DARKCOLOR_2), i) >> 7) |
803 | + RED_CMP(LCD_BL_DARKCOLOR_2); | 808 | + RED_CMP(LCD_BL_DARKCOLOR_2); |
804 | clut_entry++; | 809 | dst++; |
805 | } | 810 | } |
811 | rb->write(fd, linebuf, 4*NUM_SHADES); | ||
806 | #endif | 812 | #endif |
807 | rb->write(fd, linebuf, 4*BMP_NUMCOLORS); | ||
808 | 813 | ||
809 | /* BMP image goes bottom -> top */ | 814 | /* BMP image goes bottom -> top */ |
810 | for (y = LCD_HEIGHT - 1; y >= 0; y--) | 815 | for (y = LCD_HEIGHT - 1; y >= 0; y--) |
@@ -819,116 +824,122 @@ static void grey_screendump_hook(int fd) | |||
819 | } | 824 | } |
820 | #endif | 825 | #endif |
821 | 826 | ||
827 | dst = linebuf; | ||
828 | dst_end = dst + LCD_WIDTH; | ||
822 | gy = y - _grey_info.y; | 829 | gy = y - _grey_info.y; |
830 | gx = -_grey_info.x; | ||
831 | |||
823 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING | 832 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING |
824 | #if LCD_DEPTH == 2 | 833 | gsrc = _grey_info.values + _GREY_MULUQ(_grey_info.width, gy); |
825 | lcdptr = rb->lcd_framebuffer + _GREY_MULUQ(LCD_FBWIDTH, y); | ||
826 | 834 | ||
827 | for (x = 0; x < LCD_WIDTH; x += 4) | 835 | #if LCD_DEPTH == 2 |
836 | src = rb->lcd_framebuffer + _GREY_MULUQ(LCD_FBWIDTH, y); | ||
837 | |||
838 | do | ||
828 | { | 839 | { |
829 | gx = x - _grey_info.x; | ||
830 | |||
831 | if (((unsigned)gy < (unsigned)_grey_info.height) | 840 | if (((unsigned)gy < (unsigned)_grey_info.height) |
832 | && ((unsigned)gx < (unsigned)_grey_info.width)) | 841 | && ((unsigned)gx < (unsigned)_grey_info.width)) |
833 | { | 842 | { |
834 | unsigned char *src = _grey_info.values | 843 | *dst++ = *gsrc++; |
835 | + _GREY_MULUQ(_grey_info.width, gy) + gx; | 844 | *dst++ = *gsrc++; |
836 | for (i = 0; i < 4; i++) | 845 | *dst++ = *gsrc++; |
837 | linebuf[x + i] = *src++; | 846 | *dst++ = *gsrc++; |
838 | } | 847 | } |
839 | else | 848 | else |
840 | { | 849 | { |
841 | unsigned data = *lcdptr; | 850 | unsigned data = *src; |
842 | linebuf[x] = colorindex[(data >> 6) & 3]; | 851 | *dst++ = colorindex[(data >> 6) & 3]; |
843 | linebuf[x + 1] = colorindex[(data >> 4) & 3]; | 852 | *dst++ = colorindex[(data >> 4) & 3]; |
844 | linebuf[x + 2] = colorindex[(data >> 2) & 3]; | 853 | *dst++ = colorindex[(data >> 2) & 3]; |
845 | linebuf[x + 3] = colorindex[data & 3]; | 854 | *dst++ = colorindex[data & 3]; |
846 | } | 855 | } |
847 | lcdptr++; | 856 | gx++, src++; |
848 | } | 857 | } |
858 | while (dst < dst_end); | ||
859 | |||
849 | #endif /* LCD_DEPTH */ | 860 | #endif /* LCD_DEPTH */ |
850 | #elif LCD_PIXELFORMAT == VERTICAL_PACKING | 861 | #elif LCD_PIXELFORMAT == VERTICAL_PACKING |
862 | gsrc = _grey_info.values + (~gy & _GREY_BMASK) | ||
863 | + _GREY_MULUQ(_grey_info.width, gy & ~_GREY_BMASK); | ||
864 | |||
851 | #if LCD_DEPTH == 1 | 865 | #if LCD_DEPTH == 1 |
852 | mask = 1 << (y & 7); | 866 | mask = 1 << (y & 7); |
853 | lcdptr = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 3); | 867 | src = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 3); |
854 | 868 | ||
855 | for (x = 0; x < LCD_WIDTH; x++) | 869 | do |
856 | { | 870 | { |
857 | gx = x - _grey_info.x; | ||
858 | |||
859 | if (((unsigned)gy < (unsigned)_grey_info.height) | 871 | if (((unsigned)gy < (unsigned)_grey_info.height) |
860 | && ((unsigned)gx < (unsigned)_grey_info.width)) | 872 | && ((unsigned)gx < (unsigned)_grey_info.width)) |
861 | { | 873 | { |
862 | val = _grey_info.values[_GREY_MULUQ(_grey_info.width, | 874 | val = *gsrc; |
863 | gy & ~_GREY_BMASK) | ||
864 | + (gx << _GREY_BSHIFT) | ||
865 | + (~gy & _GREY_BMASK)]; | ||
866 | #ifdef HAVE_LCD_SPLIT | 875 | #ifdef HAVE_LCD_SPLIT |
867 | val -= val >> 7; | 876 | val -= val >> 7; |
868 | #endif | 877 | #endif |
878 | gsrc += _GREY_BSIZE; | ||
869 | } | 879 | } |
870 | else | 880 | else |
871 | { | 881 | { |
872 | #ifdef HAVE_NEGATIVE_LCD | 882 | #ifdef HAVE_NEGATIVE_LCD |
873 | val = (*lcdptr & mask) ? GRADIENT_MAX : 0; | 883 | val = (*src & mask) ? (NUM_SHADES-1) : 0; |
874 | #else | 884 | #else |
875 | val = (*lcdptr & mask) ? 0 : GRADIENT_MAX; | 885 | val = (*src & mask) ? 0 : (NUM_SHADES-1); |
876 | #endif | 886 | #endif |
877 | } | 887 | } |
878 | #ifdef HAVE_LCD_SPLIT | 888 | #ifdef HAVE_LCD_SPLIT |
879 | if (y < LCD_SPLIT_POS) | 889 | if (y < LCD_SPLIT_POS) |
880 | val |= 0x80; | 890 | val |= 0x80; |
881 | #endif | 891 | #endif |
882 | linebuf[x] = val; | 892 | *dst++ = val; |
883 | lcdptr++; | 893 | gx++, src++; |
884 | } | 894 | } |
895 | while (dst < dst_end); | ||
896 | |||
885 | #elif LCD_DEPTH == 2 | 897 | #elif LCD_DEPTH == 2 |
886 | shift = 2 * (y & 3); | 898 | shift = 2 * (y & 3); |
887 | lcdptr = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 2); | 899 | src = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 2); |
888 | 900 | ||
889 | for (x = 0; x < LCD_WIDTH; x++) | 901 | do |
890 | { | 902 | { |
891 | gx = x - _grey_info.x; | ||
892 | |||
893 | if (((unsigned)gy < (unsigned)_grey_info.height) | 903 | if (((unsigned)gy < (unsigned)_grey_info.height) |
894 | && ((unsigned)gx < (unsigned)_grey_info.width)) | 904 | && ((unsigned)gx < (unsigned)_grey_info.width)) |
895 | { | 905 | { |
896 | linebuf[x] = _grey_info.values[_GREY_MULUQ(_grey_info.width, | 906 | *dst++ = *gsrc; |
897 | gy & ~_GREY_BMASK) | 907 | gsrc += _GREY_BSIZE; |
898 | + (gx << _GREY_BSHIFT) | ||
899 | + (~gy & _GREY_BMASK)]; | ||
900 | } | 908 | } |
901 | else | 909 | else |
902 | { | 910 | { |
903 | linebuf[x] = colorindex[(*lcdptr >> shift) & 3]; | 911 | *dst++ = colorindex[(*src >> shift) & 3]; |
904 | } | 912 | } |
905 | lcdptr++; | 913 | gx++, src++; |
906 | } | 914 | } |
915 | while (dst < dst_end); | ||
916 | |||
907 | #endif /* LCD_DEPTH */ | 917 | #endif /* LCD_DEPTH */ |
908 | #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED | 918 | #elif LCD_PIXELFORMAT == VERTICAL_INTERLEAVED |
919 | gsrc = _grey_info.values + (~gy & _GREY_BMASK) | ||
920 | + _GREY_MULUQ(_grey_info.width, gy & ~_GREY_BMASK); | ||
921 | |||
909 | #if LCD_DEPTH == 2 | 922 | #if LCD_DEPTH == 2 |
910 | shift = y & 7; | 923 | shift = y & 7; |
911 | lcdptr = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 3); | 924 | src = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 3); |
912 | 925 | ||
913 | for (x = 0; x < LCD_WIDTH; x++) | 926 | do |
914 | { | 927 | { |
915 | gx = x - _grey_info.x; | ||
916 | |||
917 | if (((unsigned)gy < (unsigned)_grey_info.height) | 928 | if (((unsigned)gy < (unsigned)_grey_info.height) |
918 | && ((unsigned)gx < (unsigned)_grey_info.width)) | 929 | && ((unsigned)gx < (unsigned)_grey_info.width)) |
919 | { | 930 | { |
920 | linebuf[x] = _grey_info.values[_GREY_MULUQ(_grey_info.width, | 931 | *dst++ = *gsrc; |
921 | gy & ~_GREY_BMASK) | 932 | gsrc += _GREY_BSIZE; |
922 | + (gx << _GREY_BSHIFT) | ||
923 | + (~gy & _GREY_BMASK)]; | ||
924 | } | 933 | } |
925 | else | 934 | else |
926 | { | 935 | { |
927 | data = (*lcdptr >> shift) & 0x0101; | 936 | data = (*src >> shift) & 0x0101; |
928 | linebuf[x] = colorindex[((data >> 7) | data) & 3]; | 937 | *dst++ = colorindex[((data >> 7) | data) & 3]; |
929 | } | 938 | } |
930 | lcdptr++; | 939 | gx++, src++; |
931 | } | 940 | } |
941 | while (dst < dst_end); | ||
942 | |||
932 | #endif /* LCD_DEPTH */ | 943 | #endif /* LCD_DEPTH */ |
933 | #endif /* LCD_PIXELFORMAT */ | 944 | #endif /* LCD_PIXELFORMAT */ |
934 | 945 | ||
diff --git a/uisimulator/sdl/lcd-bitmap.c b/uisimulator/sdl/lcd-bitmap.c index 1d720b80a1..b4e6dcd4c0 100644 --- a/uisimulator/sdl/lcd-bitmap.c +++ b/uisimulator/sdl/lcd-bitmap.c | |||
@@ -59,9 +59,9 @@ SDL_Color lcd_color2_bright = {RED_CMP(LCD_BRIGHTCOLOR_2), | |||
59 | #endif | 59 | #endif |
60 | 60 | ||
61 | #ifdef HAVE_LCD_SPLIT | 61 | #ifdef HAVE_LCD_SPLIT |
62 | #define GRADIENT_MAX 127 | 62 | #define NUM_SHADES 128 |
63 | #else | 63 | #else |
64 | #define GRADIENT_MAX 128 | 64 | #define NUM_SHADES 129 |
65 | #endif | 65 | #endif |
66 | #endif /* LCD_DEPTH <= 8 */ | 66 | #endif /* LCD_DEPTH <= 8 */ |
67 | 67 | ||
@@ -78,9 +78,9 @@ static unsigned long get_lcd_pixel(int x, int y) | |||
78 | { | 78 | { |
79 | #if LCD_DEPTH == 1 | 79 | #if LCD_DEPTH == 1 |
80 | #ifdef HAVE_NEGATIVE_LCD | 80 | #ifdef HAVE_NEGATIVE_LCD |
81 | return (lcd_framebuffer[y/8][x] & (1 << (y & 7))) ? GRADIENT_MAX : 0; | 81 | return (lcd_framebuffer[y/8][x] & (1 << (y & 7))) ? (NUM_SHADES-1) : 0; |
82 | #else | 82 | #else |
83 | return (lcd_framebuffer[y/8][x] & (1 << (y & 7))) ? 0 : GRADIENT_MAX; | 83 | return (lcd_framebuffer[y/8][x] & (1 << (y & 7))) ? 0 : (NUM_SHADES-1); |
84 | #endif | 84 | #endif |
85 | #elif LCD_DEPTH == 2 | 85 | #elif LCD_DEPTH == 2 |
86 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING | 86 | #if LCD_PIXELFORMAT == HORIZONTAL_PACKING |
@@ -122,17 +122,17 @@ void sim_backlight(int value) | |||
122 | #if LCD_DEPTH <= 8 | 122 | #if LCD_DEPTH <= 8 |
123 | if (value > 0) { | 123 | if (value > 0) { |
124 | sdl_set_gradient(lcd_surface, &lcd_bl_color_dark, | 124 | sdl_set_gradient(lcd_surface, &lcd_bl_color_dark, |
125 | &lcd_bl_color_bright, 0, GRADIENT_MAX+1); | 125 | &lcd_bl_color_bright, 0, NUM_SHADES); |
126 | #ifdef HAVE_LCD_SPLIT | 126 | #ifdef HAVE_LCD_SPLIT |
127 | sdl_set_gradient(lcd_surface, &lcd_bl_color2_dark, | 127 | sdl_set_gradient(lcd_surface, &lcd_bl_color2_dark, |
128 | &lcd_bl_color2_bright, GRADIENT_MAX+1, GRADIENT_MAX+1); | 128 | &lcd_bl_color2_bright, NUM_SHADES, NUM_SHADES); |
129 | #endif | 129 | #endif |
130 | } else { | 130 | } else { |
131 | sdl_set_gradient(lcd_surface, &lcd_color_dark, | 131 | sdl_set_gradient(lcd_surface, &lcd_color_dark, |
132 | &lcd_color_bright, 0, GRADIENT_MAX+1); | 132 | &lcd_color_bright, 0, NUM_SHADES); |
133 | #ifdef HAVE_LCD_SPLIT | 133 | #ifdef HAVE_LCD_SPLIT |
134 | sdl_set_gradient(lcd_surface, &lcd_color2_dark, | 134 | sdl_set_gradient(lcd_surface, &lcd_color2_dark, |
135 | &lcd_color2_bright, GRADIENT_MAX+1, GRADIENT_MAX+1); | 135 | &lcd_color2_bright, NUM_SHADES, NUM_SHADES); |
136 | #endif | 136 | #endif |
137 | } | 137 | } |
138 | sdl_gui_update(lcd_surface, 0, 0, SIM_LCD_WIDTH, SIM_LCD_HEIGHT, | 138 | sdl_gui_update(lcd_surface, 0, 0, SIM_LCD_WIDTH, SIM_LCD_HEIGHT, |
@@ -162,17 +162,17 @@ void sim_lcd_init(void) | |||
162 | #if LCD_DEPTH <= 8 | 162 | #if LCD_DEPTH <= 8 |
163 | #ifdef HAVE_BACKLIGHT | 163 | #ifdef HAVE_BACKLIGHT |
164 | sdl_set_gradient(lcd_surface, &lcd_bl_color_dark, | 164 | sdl_set_gradient(lcd_surface, &lcd_bl_color_dark, |
165 | &lcd_bl_color_bright, 0, GRADIENT_MAX+1); | 165 | &lcd_bl_color_bright, 0, NUM_SHADES); |
166 | #ifdef HAVE_LCD_SPLIT | 166 | #ifdef HAVE_LCD_SPLIT |
167 | sdl_set_gradient(lcd_surface, &lcd_bl_color2_dark, | 167 | sdl_set_gradient(lcd_surface, &lcd_bl_color2_dark, |
168 | &lcd_bl_color2_bright, GRADIENT_MAX+1, GRADIENT_MAX+1); | 168 | &lcd_bl_color2_bright, NUM_SHADES, NUM_SHADES); |
169 | #endif | 169 | #endif |
170 | #else /* !HAVE_BACKLIGHT */ | 170 | #else /* !HAVE_BACKLIGHT */ |
171 | sdl_set_gradient(lcd_surface, &lcd_color_dark, | 171 | sdl_set_gradient(lcd_surface, &lcd_color_dark, |
172 | &lcd_color_bright, 0, GRADIENT_MAX+1); | 172 | &lcd_color_bright, 0, NUM_SHADES); |
173 | #ifdef HAVE_LCD_SPLIT | 173 | #ifdef HAVE_LCD_SPLIT |
174 | sdl_set_gradient(lcd_surface, &lcd_color2_dark, | 174 | sdl_set_gradient(lcd_surface, &lcd_color2_dark, |
175 | &lcd_color2_bright, GRADIENT_MAX+1, GRADIENT_MAX+1); | 175 | &lcd_color2_bright, NUM_SHADES, NUM_SHADES); |
176 | #endif | 176 | #endif |
177 | #endif /* !HAVE_BACKLIGHT */ | 177 | #endif /* !HAVE_BACKLIGHT */ |
178 | #endif /* LCD_DEPTH < 8 */ | 178 | #endif /* LCD_DEPTH < 8 */ |