« back to all changes in this revision
Viewing changes to Source/LibMNG/libmng_pixels.c
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Bazaar Package Importer
- Author(s): Cosme Domínguez Díaz
- Date: 2010-07-20 13:42:15 UTC
- mfrom: (1.1.2 upstream)
- Revision ID: james.westby@ubuntu.com-20100720134215-xt1454zaedv3b604
Tags: 3.13.1-0ubuntu1
* New upstream release. Closes: (LP: #607800)
- Updated debian/freeimage-get-orig-source script.
- Removing no longer necessary debian/patches/* and
the patch system in debian/rules.
- Updated debian/rules to work with the new Makefiles.
- Drop from -O3 to -O2 and use lzma compression saves
~10 MB of free space.
* lintian stuff
- fixed debhelper-but-no-misc-depends
- fixed ldconfig-symlink-missing-for-shlib
- Updated debian/freeimage-get-orig-source script.
- Removing no longer necessary debian/patches/* and
the patch system in debian/rules.
- Updated debian/rules to work with the new Makefiles.
- Drop from -O3 to -O2 and use lzma compression saves
~10 MB of free space.
* lintian stuff
- fixed debhelper-but-no-misc-depends
- fixed ldconfig-symlink-missing-for-shlib
- files added:
- Examples/OpenGL
- Examples/OpenGL/TextureManager
- Source/LibRawLite
- Source/LibRawLite/dcraw
- Source/LibRawLite/internal
- Source/LibRawLite/libraw
- Source/LibRawLite/src
- Wrapper/FreeImage.NET/cpp
- Wrapper/FreeImage.NET/cpp/FreeImageIO
- Wrapper/FreeImage.NET/cs
- Wrapper/FreeImage.NET/cs/Bin
- Wrapper/FreeImage.NET/cs/Doc
- Wrapper/FreeImage.NET/cs/Doc/3.11.0
- Wrapper/FreeImage.NET/cs/Doc/3.12.0
- Wrapper/FreeImage.NET/cs/Doc/3.13.0
- Wrapper/FreeImage.NET/cs/Library
- Wrapper/FreeImage.NET/cs/Library/Classes
- Wrapper/FreeImage.NET/cs/Library/Enumerations
- Wrapper/FreeImage.NET/cs/Library/Properties
- Wrapper/FreeImage.NET/cs/Library/Structs
- Wrapper/FreeImage.NET/cs/Samples
- Wrapper/FreeImage.NET/cs/Samples/Sample 01 - Loading and saving
- Wrapper/FreeImage.NET/cs/Samples/Sample 01 - Loading and saving/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 02 - Multipaged bitmaps
- Wrapper/FreeImage.NET/cs/Samples/Sample 02 - Multipaged bitmaps/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 03 - Allocating
- Wrapper/FreeImage.NET/cs/Samples/Sample 03 - Allocating/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 04 - Getting bitmap informations
- Wrapper/FreeImage.NET/cs/Samples/Sample 04 - Getting bitmap informations/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 05 - Working with pixels
- Wrapper/FreeImage.NET/cs/Samples/Sample 05 - Working with pixels/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 06 - Converting
- Wrapper/FreeImage.NET/cs/Samples/Sample 06 - Converting/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 07 - ICC Profiles
- Wrapper/FreeImage.NET/cs/Samples/Sample 07 - ICC Profiles/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 08 - Creating a plugin
- Wrapper/FreeImage.NET/cs/Samples/Sample 08 - Creating a plugin/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 09 - Working with streams
- Wrapper/FreeImage.NET/cs/Samples/Sample 09 - Working with streams/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 10 - Metadata
- Wrapper/FreeImage.NET/cs/Samples/Sample 10 - Metadata/Properties
- Wrapper/FreeImage.NET/cs/Samples/Sample 11 - Using the FreeImageBitmap class
- Wrapper/FreeImage.NET/cs/Samples/Sample 11 - Using the FreeImageBitmap class/Properties
- Wrapper/FreeImage.NET/cs/SourceFileMerger
- Wrapper/FreeImage.NET/cs/SourceFileMerger/Properties
- Wrapper/FreeImage.NET/cs/UnitTest
- Wrapper/FreeImage.NET/cs/UnitTest/Properties
- Wrapper/VB6/awk_script
- files removed:
- Source/LibJPEG/jchuff.h
- Wrapper/FreeImage.NET/contributions
- Wrapper/FreeImage.NET/contributions/FreeImageIO
- Wrapper/FreeImage.NET/src
- Wrapper/FreeImage.NET/test
- debian/patches
- files modified:
- FreeImage.2003.sln
added
removed
Source/LibMNG/libmng_pixels.c
4
4
/* ************************************************************************** */
5
5
/* * * */
6
6
/* * project : libmng * */
7
/* * file : libmng_pixels.c copyright (c) 2000-2004 G.Juyn * */
8
/* * version : 1.0.9 * */
7
/* * file : libmng_pixels.c copyright (c) 2000-2005 G.Juyn * */
8
/* * version : 1.0.10 * */
9
9
/* * * */
10
10
/* * purpose : Pixel-row management routines (implementation) * */
11
11
/* * * */
182
182
/* * 1.0.9 - 12/31/2004 - G.R-P. * */
183
183
/* * - fixed warnings about C++ style (//) comments * */
184
184
/* * * */
185
/* * 1.0.10 - 07/06/2005 - G.R-P. * */
186
/* * - added MORE MNG_NO_1_2_4BIT_SUPPORT * */
187
/* * 1.0.10 - 10/06/2005 - G.R-P. * */
188
/* * - alloc more memory for MNG_NO_1_2_4BIT_SUPPORT * */
189
/* * 1.0.10 - 12/07/2005 - G.R-P. * */
190
/* * - optimized footprint of 16bit support * */
191
/* * 1.0.10 - 03/07/2006 - (thanks to W. Manthey) * */
192
/* * - added CANVAS_RGB555 and CANVAS_BGR555 * */
193
/* * * */
185
194
/* ************************************************************************** */
186
195
187
196
#include "libmng.h"
363
372
/* ************************************************************************** */
364
373
365
374
#ifndef MNG_SKIPCANVAS_RGB8
375
#ifndef MNG_NO_16BIT_SUPPORT
376
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
366
377
mng_retcode mng_display_rgb8 (mng_datap pData)
367
378
{
368
379
mng_uint8p pScanline;
369
380
mng_uint8p pDataline;
370
381
mng_int32 iX;
371
#ifndef MNG_NO_16BIT_SUPPORT
372
382
mng_uint16 iA16;
373
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
374
383
mng_uint16 iFGr16, iFGg16, iFGb16;
375
384
mng_uint16 iBGr16, iBGg16, iBGb16;
376
#else
377
mng_uint16 iFGg16;
378
mng_uint16 iBGg16;
379
#endif
380
#endif
381
385
mng_uint8 iA8;
382
386
383
387
#ifdef MNG_SUPPORT_TRACE
393
397
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
394
398
pDataline = pData->pRGBArow; /* address source row */
395
399
396
#ifndef MNG_NO_16BIT_SUPPORT
397
400
if (pData->bIsRGBA16) /* adjust source row starting-point */
398
401
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
399
402
else
400
#endif
401
403
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
402
404
403
405
if (pData->bIsOpaque) /* forget about transparency ? */
404
406
{
405
#ifndef MNG_NO_16BIT_SUPPORT
406
407
if (pData->bIsRGBA16) /* 16-bit input row ? */
407
408
{
408
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
409
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
410
iX += pData->iColinc)
409
411
{ /* scale down by dropping the LSB */
410
412
*pScanline = *pDataline;
411
413
*(pScanline+1) = *(pDataline+2);
416
418
}
417
419
}
418
420
else
419
#endif
420
421
{
421
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
422
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
423
iX += pData->iColinc)
422
424
{ /* copy the values */
423
425
*pScanline = *pDataline;
424
426
*(pScanline+1) = *(pDataline+1);
431
433
}
432
434
else
433
435
{
434
#ifndef MNG_NO_16BIT_SUPPORT
435
436
if (pData->bIsRGBA16) /* 16-bit input row ? */
436
437
{
437
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
438
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
439
iX += pData->iColinc)
438
440
{
439
441
iA16 = mng_get_uint16 (pDataline+6);
440
442
448
450
}
449
451
else
450
452
{ /* get the proper values */
451
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
452
int i;
453
for (i=2; i >= 0; i--)
454
{
455
iFGg16 = mng_get_uint16 (pDataline+i+i);
456
/* scale background up */
457
iBGg16 = (mng_uint16)(*(pScanline+i));
458
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
459
/* now compose */
460
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
461
/* and return the composed values */
462
*(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
463
}
464
#else
465
453
iFGr16 = mng_get_uint16 (pDataline );
466
454
iFGg16 = mng_get_uint16 (pDataline+2);
467
455
iFGb16 = mng_get_uint16 (pDataline+4);
480
468
*pScanline = (mng_uint8)(iFGr16 >> 8);
481
469
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
482
470
*(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
483
#endif
484
}
485
}
486
487
pScanline += (pData->iColinc * 3);
488
pDataline += 8;
489
}
490
}
491
else
492
#endif
493
{
494
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
471
}
472
}
473
474
pScanline += (pData->iColinc * 3);
475
pDataline += 8;
476
}
477
}
478
else
479
{
480
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
481
iX += pData->iColinc)
482
{
483
iA8 = *(pDataline+3); /* get alpha value */
484
485
if (iA8) /* any opacity at all ? */
486
{
487
if (iA8 == 0xFF) /* fully opaque ? */
488
{ /* then simply copy the values */
489
*pScanline = *pDataline;
490
*(pScanline+1) = *(pDataline+1);
491
*(pScanline+2) = *(pDataline+2);
492
}
493
else
494
{ /* do alpha composing */
495
MNG_COMPOSE8 (*pScanline, *pDataline, iA8, *pScanline );
496
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
497
MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iA8, *(pScanline+2));
498
}
499
}
500
501
pScanline += (pData->iColinc * 3);
502
pDataline += 4;
503
}
504
}
505
}
506
}
507
508
check_update_region (pData);
509
510
#ifdef MNG_SUPPORT_TRACE
511
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_END);
512
#endif
513
514
return MNG_NOERROR;
515
}
516
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
517
mng_retcode mng_display_rgb8 (mng_datap pData)
518
{
519
mng_uint8p pScanline;
520
mng_uint8p pDataline;
521
mng_int32 iX;
522
mng_uint16 iA16;
523
mng_uint16 iFGg16;
524
mng_uint16 iBGg16;
525
mng_uint8 iA8;
526
mng_uint8 iBps;
527
528
#ifdef MNG_SUPPORT_TRACE
529
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_START);
530
#endif
531
532
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
533
/* viewable row ? */
534
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
535
{ /* address destination row */
536
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
537
pData->iRow + pData->iDestt -
538
pData->iSourcet);
539
/* adjust destination row starting-point */
540
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
541
pDataline = pData->pRGBArow; /* address source row */
542
543
/* adjust source row starting-point */
544
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
545
546
if (pData->bIsOpaque) /* forget about transparency ? */
547
{
548
{
549
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
550
iX += pData->iColinc)
551
{ /* scale down by dropping the LSB */
552
*pScanline = *pDataline;
553
*(pScanline+1) = *(pDataline+iBps);
554
*(pScanline+2) = *(pDataline+2*iBps);
555
556
pScanline += (pData->iColinc * 3);
557
pDataline += 4*iBps;
558
}
559
}
560
}
561
else
562
{
563
if (pData->bIsRGBA16) /* 16-bit input row ? */
564
{
565
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
566
iX += pData->iColinc)
567
{
568
iA16 = mng_get_uint16 (pDataline+6);
569
570
if (iA16) /* any opacity at all ? */
571
{
572
if (iA16 == 0xFFFF) /* fully opaque ? */
573
{ /* scale down by dropping the LSB */
574
*pScanline = *pDataline;
575
*(pScanline+1) = *(pDataline+2);
576
*(pScanline+2) = *(pDataline+4);
577
}
578
else
579
{ /* get the proper values */
580
int i;
581
for (i=2; i >= 0; i--)
582
{
583
iFGg16 = mng_get_uint16 (pDataline+i+i);
584
/* scale background up */
585
iBGg16 = (mng_uint16)(*(pScanline+i));
586
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
587
/* now compose */
588
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
589
/* and return the composed values */
590
*(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
591
}
592
}
593
}
594
595
pScanline += (pData->iColinc * 3);
596
pDataline += 8;
597
}
598
}
599
else
600
{
601
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
602
iX += pData->iColinc)
603
{
604
iA8 = *(pDataline+3); /* get alpha value */
605
606
if (iA8) /* any opacity at all ? */
607
{
608
if (iA8 == 0xFF) /* fully opaque ? */
609
{ /* then simply copy the values */
610
*pScanline = *pDataline;
611
*(pScanline+1) = *(pDataline+1);
612
*(pScanline+2) = *(pDataline+2);
613
}
614
else
615
{ /* do alpha composing */
616
int i;
617
for (i=2; i >= 0; i--)
618
{
619
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iA8, *(pScanline+i));
620
}
621
}
622
}
623
624
pScanline += (pData->iColinc * 3);
625
pDataline += 4;
626
}
627
}
628
}
629
}
630
631
check_update_region (pData);
632
633
#ifdef MNG_SUPPORT_TRACE
634
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_END);
635
#endif
636
637
return MNG_NOERROR;
638
}
639
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
640
#else /* MNG_NO_16BIT_SUPPORT */
641
mng_retcode mng_display_rgb8 (mng_datap pData)
642
{
643
mng_uint8p pScanline;
644
mng_uint8p pDataline;
645
mng_int32 iX;
646
mng_uint8 iA8;
647
648
#ifdef MNG_SUPPORT_TRACE
649
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_START);
650
#endif
651
/* viewable row ? */
652
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
653
{ /* address destination row */
654
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
655
pData->iRow + pData->iDestt -
656
pData->iSourcet);
657
/* adjust destination row starting-point */
658
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
659
pDataline = pData->pRGBArow; /* address source row */
660
661
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
662
663
if (pData->bIsOpaque) /* forget about transparency ? */
664
{
665
{
666
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
667
iX += pData->iColinc)
668
{ /* copy the values */
669
*pScanline = *pDataline;
670
*(pScanline+1) = *(pDataline+1);
671
*(pScanline+2) = *(pDataline+2);
672
673
pScanline += (pData->iColinc * 3);
674
pDataline += 4;
675
}
676
}
677
}
678
else
679
{
680
{
681
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
682
iX += pData->iColinc)
495
683
{
496
684
iA8 = *(pDataline+3); /* get alpha value */
497
685
534
722
535
723
return MNG_NOERROR;
536
724
}
725
#endif /* MNG_NO_16BIT_SUPPORT */
537
726
#endif /* MNG_SKIPCANVAS_RGB8 */
538
727
539
728
/* ************************************************************************** */
540
729
541
730
#ifndef MNG_SKIPCANVAS_RGBA8
542
mng_retcode mng_display_rgba8 (mng_datap pData)
543
{
544
mng_uint8p pScanline;
545
mng_uint8p pDataline;
546
mng_int32 iX;
547
mng_uint8 iFGa8, iBGa8, iCa8;
548
731
#ifndef MNG_NO_16BIT_SUPPORT
549
mng_uint16 iFGa16, iBGa16, iCa16;
550
732
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
733
mng_retcode mng_display_rgba8 (mng_datap pData)
734
{
735
mng_uint8p pScanline;
736
mng_uint8p pDataline;
737
mng_int32 iX;
738
mng_uint8 iFGa8, iBGa8, iCa8;
739
mng_uint16 iFGa16, iBGa16, iCa16;
551
740
mng_uint16 iFGr16, iFGg16, iFGb16;
552
#else
553
mng_uint16 iFGg16;
554
#endif
555
741
mng_uint16 iBGr16, iBGg16, iBGb16;
556
742
mng_uint16 iCr16, iCg16, iCb16;
557
#endif
558
743
mng_uint8 iCr8, iCg8, iCb8;
559
744
560
745
#ifdef MNG_SUPPORT_TRACE
570
755
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
571
756
pDataline = pData->pRGBArow; /* address source row */
572
757
573
#ifndef MNG_NO_16BIT_SUPPORT
574
758
if (pData->bIsRGBA16) /* adjust source row starting-point */
575
759
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
576
760
else
577
#endif
578
761
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
579
762
580
763
if (pData->bIsOpaque) /* forget about transparency ? */
581
764
{
582
#ifndef MNG_NO_16BIT_SUPPORT
583
765
if (pData->bIsRGBA16) /* 16-bit input row ? */
584
766
{
585
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
767
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
768
iX += pData->iColinc)
586
769
{ /* scale down by dropping the LSB */
587
770
*pScanline = *pDataline;
588
771
*(pScanline+1) = *(pDataline+2);
594
777
}
595
778
}
596
779
else
597
#endif
598
780
{
599
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
781
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
782
iX += pData->iColinc)
600
783
{ /* copy the values */
601
784
*pScanline = *pDataline;
602
785
*(pScanline+1) = *(pDataline+1);
610
793
}
611
794
else
612
795
{
613
#ifndef MNG_NO_16BIT_SUPPORT
614
796
if (pData->bIsRGBA16) /* 16-bit input row ? */
615
797
{
616
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
798
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
799
iX += pData->iColinc)
617
800
{ /* get alpha values */
618
801
iFGa16 = mng_get_uint16 (pDataline+6);
619
802
iBGa16 = (mng_uint16)(*(pScanline+3));
632
815
{
633
816
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
634
817
{ /* get the proper values */
635
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
636
int i;
637
for (i=2; i >= 0; i--)
638
{
639
iFGg16 = mng_get_uint16 (pDataline+i+i);
640
/* scale background up */
641
iBGg16 = (mng_uint16)(*(pScanline+i));
642
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
643
/* now compose */
644
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
645
/* and return the composed values */
646
*(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
647
/* alpha remains fully opaque !!! */
648
}
649
#else
650
818
iFGr16 = mng_get_uint16 (pDataline );
651
819
iFGg16 = mng_get_uint16 (pDataline+2);
652
820
iFGb16 = mng_get_uint16 (pDataline+4);
666
834
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
667
835
*(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
668
836
/* alpha remains fully opaque !!! */
669
#endif
670
}
671
else
672
{ /* scale background up */
673
iBGr16 = (mng_uint16)(*pScanline );
674
iBGg16 = (mng_uint16)(*(pScanline+1));
675
iBGb16 = (mng_uint16)(*(pScanline+2));
676
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
677
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
678
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
679
/* let's blend */
680
MNG_BLEND16 (mng_get_uint16 (pDataline ),
681
mng_get_uint16 (pDataline+2),
682
mng_get_uint16 (pDataline+4), iFGa16,
683
iBGr16, iBGg16, iBGb16, iBGa16,
684
iCr16, iCg16, iCb16, iCa16);
685
/* and return the composed values */
686
*pScanline = (mng_uint8)(iCr16 >> 8);
687
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
688
*(pScanline+2) = (mng_uint8)(iCb16 >> 8);
689
*(pScanline+3) = (mng_uint8)(iCa16 >> 8);
690
}
691
}
692
}
693
694
pScanline += (pData->iColinc << 2);
695
pDataline += 8;
696
}
697
}
698
else
699
#endif
700
{
701
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
837
}
838
else
839
{ /* scale background up */
840
iBGr16 = (mng_uint16)(*pScanline );
841
iBGg16 = (mng_uint16)(*(pScanline+1));
842
iBGb16 = (mng_uint16)(*(pScanline+2));
843
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
844
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
845
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
846
/* let's blend */
847
MNG_BLEND16 (mng_get_uint16 (pDataline ),
848
mng_get_uint16 (pDataline+2),
849
mng_get_uint16 (pDataline+4), iFGa16,
850
iBGr16, iBGg16, iBGb16, iBGa16,
851
iCr16, iCg16, iCb16, iCa16);
852
/* and return the composed values */
853
*pScanline = (mng_uint8)(iCr16 >> 8);
854
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
855
*(pScanline+2) = (mng_uint8)(iCb16 >> 8);
856
*(pScanline+3) = (mng_uint8)(iCa16 >> 8);
857
}
858
}
859
}
860
861
pScanline += (pData->iColinc << 2);
862
pDataline += 8;
863
}
864
}
865
else
866
{
867
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
868
iX += pData->iColinc)
869
{
870
iFGa8 = *(pDataline+3); /* get alpha values */
871
iBGa8 = *(pScanline+3);
872
873
if (iFGa8) /* any opacity at all ? */
874
{ /* fully opaque or background fully transparent ? */
875
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
876
{ /* then simply copy the values */
877
*pScanline = *pDataline;
878
*(pScanline+1) = *(pDataline+1);
879
*(pScanline+2) = *(pDataline+2);
880
*(pScanline+3) = *(pDataline+3);
881
}
882
else
883
{
884
if (iBGa8 == 0xFF) /* background fully opaque ? */
885
{ /* do alpha composing */
886
MNG_COMPOSE8 (*pScanline, *pDataline, iFGa8, *pScanline );
887
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
888
MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iFGa8, *(pScanline+2));
889
/* alpha remains fully opaque !!! */
890
}
891
else
892
{ /* now blend */
893
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
894
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
895
iCr8, iCg8, iCb8, iCa8);
896
/* and return the composed values */
897
*pScanline = iCr8;
898
*(pScanline+1) = iCg8;
899
*(pScanline+2) = iCb8;
900
*(pScanline+3) = iCa8;
901
}
902
}
903
}
904
905
pScanline += (pData->iColinc << 2);
906
pDataline += 4;
907
}
908
}
909
}
910
}
911
912
check_update_region (pData);
913
914
#ifdef MNG_SUPPORT_TRACE
915
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
916
#endif
917
918
return MNG_NOERROR;
919
}
920
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
921
mng_retcode mng_display_rgba8 (mng_datap pData)
922
{
923
mng_uint8p pScanline;
924
mng_uint8p pDataline;
925
mng_int32 iX;
926
mng_uint8 iFGa8, iBGa8, iCa8;
927
mng_uint16 iFGa16, iBGa16, iCa16;
928
mng_uint16 iFGg16;
929
mng_uint16 iBGr16, iBGg16, iBGb16;
930
mng_uint16 iCr16, iCg16, iCb16;
931
mng_uint8 iCr8, iCg8, iCb8;
932
mng_uint8 iBps;
933
934
#ifdef MNG_SUPPORT_TRACE
935
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
936
#endif
937
938
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
939
/* viewable row ? */
940
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
941
{ /* address destination row */
942
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
943
pData->iRow + pData->iDestt -
944
pData->iSourcet);
945
/* adjust destination row starting-point */
946
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
947
pDataline = pData->pRGBArow; /* address source row */
948
949
/* adjust source row starting-point */
950
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
951
952
if (pData->bIsOpaque) /* forget about transparency ? */
953
{
954
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
955
iX += pData->iColinc)
956
{ /* scale down by dropping the LSB */
957
*pScanline = *pDataline;
958
*(pScanline+1) = *(pDataline+iBps);
959
*(pScanline+2) = *(pDataline+2*iBps);
960
*(pScanline+3) = *(pDataline+3*iBps);
961
962
pScanline += (pData->iColinc << 2);
963
pDataline += 4*iBps;
964
}
965
}
966
else
967
{
968
if (pData->bIsRGBA16) /* 16-bit input row ? */
969
{
970
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
971
iX += pData->iColinc)
972
{ /* get alpha values */
973
iFGa16 = mng_get_uint16 (pDataline+6);
974
iBGa16 = (mng_uint16)(*(pScanline+3));
975
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
976
977
if (iFGa16) /* any opacity at all ? */
978
{ /* fully opaque or background fully transparent ? */
979
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
980
{ /* plain copy it */
981
*pScanline = *pDataline;
982
*(pScanline+1) = *(pDataline+2);
983
*(pScanline+2) = *(pDataline+4);
984
*(pScanline+3) = *(pDataline+6);
985
}
986
else
987
{
988
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
989
{ /* get the proper values */
990
int i;
991
for (i=2; i >= 0; i--)
992
{
993
iFGg16 = mng_get_uint16 (pDataline+i+i);
994
/* scale background up */
995
iBGg16 = (mng_uint16)(*(pScanline+i));
996
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
997
/* now compose */
998
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
999
/* and return the composed values */
1000
*(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
1001
/* alpha remains fully opaque !!! */
1002
}
1003
}
1004
else
1005
{ /* scale background up */
1006
iBGr16 = (mng_uint16)(*pScanline );
1007
iBGg16 = (mng_uint16)(*(pScanline+1));
1008
iBGb16 = (mng_uint16)(*(pScanline+2));
1009
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
1010
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1011
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
1012
/* let's blend */
1013
MNG_BLEND16 (mng_get_uint16 (pDataline ),
1014
mng_get_uint16 (pDataline+2),
1015
mng_get_uint16 (pDataline+4), iFGa16,
1016
iBGr16, iBGg16, iBGb16, iBGa16,
1017
iCr16, iCg16, iCb16, iCa16);
1018
/* and return the composed values */
1019
*pScanline = (mng_uint8)(iCr16 >> 8);
1020
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
1021
*(pScanline+2) = (mng_uint8)(iCb16 >> 8);
1022
*(pScanline+3) = (mng_uint8)(iCa16 >> 8);
1023
}
1024
}
1025
}
1026
1027
pScanline += (pData->iColinc << 2);
1028
pDataline += 8;
1029
}
1030
}
1031
else
1032
{
1033
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1034
iX += pData->iColinc)
1035
{
1036
iFGa8 = *(pDataline+3); /* get alpha values */
1037
iBGa8 = *(pScanline+3);
1038
1039
if (iFGa8) /* any opacity at all ? */
1040
{ /* fully opaque or background fully transparent ? */
1041
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
1042
{ /* then simply copy the values */
1043
*pScanline = *pDataline;
1044
*(pScanline+1) = *(pDataline+1);
1045
*(pScanline+2) = *(pDataline+2);
1046
*(pScanline+3) = *(pDataline+3);
1047
}
1048
else
1049
{
1050
if (iBGa8 == 0xFF) /* background fully opaque ? */
1051
{ /* do alpha composing */
1052
int i;
1053
for (i=2; i >= 0; i--)
1054
{
1055
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
1056
}
1057
/* alpha remains fully opaque !!! */
1058
}
1059
else
1060
{ /* now blend */
1061
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
1062
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
1063
iCr8, iCg8, iCb8, iCa8);
1064
/* and return the composed values */
1065
*pScanline = iCr8;
1066
*(pScanline+1) = iCg8;
1067
*(pScanline+2) = iCb8;
1068
*(pScanline+3) = iCa8;
1069
}
1070
}
1071
}
1072
1073
pScanline += (pData->iColinc << 2);
1074
pDataline += 4;
1075
}
1076
}
1077
}
1078
}
1079
1080
check_update_region (pData);
1081
1082
#ifdef MNG_SUPPORT_TRACE
1083
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
1084
#endif
1085
1086
return MNG_NOERROR;
1087
}
1088
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1089
#else /* MNG_NO_16BIT_SUPPORT */
1090
mng_retcode mng_display_rgba8 (mng_datap pData)
1091
{
1092
mng_uint8p pScanline;
1093
mng_uint8p pDataline;
1094
mng_int32 iX;
1095
mng_uint8 iFGa8, iBGa8, iCa8;
1096
mng_uint8 iCr8, iCg8, iCb8;
1097
1098
#ifdef MNG_SUPPORT_TRACE
1099
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
1100
#endif
1101
/* viewable row ? */
1102
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
1103
{ /* address destination row */
1104
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
1105
pData->iRow + pData->iDestt -
1106
pData->iSourcet);
1107
/* adjust destination row starting-point */
1108
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1109
pDataline = pData->pRGBArow; /* address source row */
1110
1111
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1112
1113
if (pData->bIsOpaque) /* forget about transparency ? */
1114
{
1115
{
1116
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1117
iX += pData->iColinc)
1118
{ /* copy the values */
1119
*pScanline = *pDataline;
1120
*(pScanline+1) = *(pDataline+1);
1121
*(pScanline+2) = *(pDataline+2);
1122
*(pScanline+3) = *(pDataline+3);
1123
1124
pScanline += (pData->iColinc << 2);
1125
pDataline += 4;
1126
}
1127
}
1128
}
1129
else
1130
{
1131
{
1132
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1133
iX += pData->iColinc)
702
1134
{
703
1135
iFGa8 = *(pDataline+3); /* get alpha values */
704
1136
iBGa8 = *(pScanline+3);
758
1190
759
1191
return MNG_NOERROR;
760
1192
}
1193
#endif /* MNG_NO_16BIT_SUPPORT */
761
1194
#endif /* MNG_SKIPCANVAS_RGBA8 */
762
1195
763
1196
/* ************************************************************************** */
764
1197
765
1198
#ifndef MNG_SKIPCANVAS_RGBA8_PM
1199
#ifndef MNG_NO_16BIT_SUPPORT
1200
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
766
1201
mng_retcode mng_display_rgba8_pm (mng_datap pData)
767
1202
{
768
1203
mng_uint8p pScanline;
783
1218
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
784
1219
pDataline = pData->pRGBArow; /* address source row */
785
1220
786
#ifndef MNG_NO_16BIT_SUPPORT
787
1221
if (pData->bIsRGBA16) /* adjust source row starting-point */
788
1222
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
789
1223
else
790
#endif
791
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
792
793
if (pData->bIsOpaque) /* forget about transparency ? */
794
{
795
#ifndef MNG_NO_16BIT_SUPPORT
796
if (pData->bIsRGBA16) /* 16-bit input row ? */
797
{
798
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
799
{ /* scale down by dropping the LSB */
800
if ((s = pDataline[6]) == 0)
801
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
802
else
803
{
804
if (s == 255)
805
{
806
pScanline[0] = pDataline[0];
807
pScanline[1] = pDataline[2];
808
pScanline[2] = pDataline[4];
809
pScanline[3] = 255;
810
}
811
else
812
{
813
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
814
int i;
815
for (i=2; i >= 0; i--)
816
{
817
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
818
}
819
#else
820
pScanline[0] = DIV255B8(s * pDataline[0]);
821
pScanline[1] = DIV255B8(s * pDataline[2]);
822
pScanline[2] = DIV255B8(s * pDataline[4]);
823
#endif
824
pScanline[3] = (mng_uint8)s;
825
}
826
}
827
pScanline += (pData->iColinc << 2);
828
pDataline += 8;
829
}
830
}
831
else
832
#endif
833
{
834
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
835
{ /* copy the values and premultiply */
836
if ((s = pDataline[3]) == 0)
837
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
838
else
839
{
840
if (s == 255)
841
{
842
#ifdef MNG_BIGENDIAN_SUPPORTED
843
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
844
#else
845
pScanline[0] = pDataline[0];
846
pScanline[1] = pDataline[1];
847
pScanline[2] = pDataline[2];
848
pScanline[3] = 255;
849
#endif
850
}
851
else
852
{
853
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
854
int i;
855
for (i=2; i >= 0; i--)
856
{
857
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
858
}
859
#else
860
pScanline[0] = DIV255B8(s * pDataline[0]);
861
pScanline[1] = DIV255B8(s * pDataline[1]);
862
pScanline[2] = DIV255B8(s * pDataline[2]);
863
#endif
864
pScanline[3] = (mng_uint8)s;
865
}
866
}
867
868
pScanline += (pData->iColinc << 2);
869
pDataline += 4;
870
}
871
}
872
}
873
else
874
{
875
#ifndef MNG_NO_16BIT_SUPPORT
876
if (pData->bIsRGBA16) /* 16-bit input row ? */
877
{
878
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
879
{ /* get alpha values */
880
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
881
{ /* fully opaque or background fully transparent ? */
882
if (s == 255)
883
{ /* plain copy it */
884
pScanline[0] = pDataline[0];
885
pScanline[1] = pDataline[2];
886
pScanline[2] = pDataline[4];
887
pScanline[3] = 255;
888
}
889
else
890
{ /* now blend (premultiplied) */
891
t = 255 - s;
892
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
893
{
894
int i;
895
for (i=2; i >= 0; i--)
896
{
897
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
898
pScanline[2-i]);
899
}
900
}
901
#else
902
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
903
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
904
pScanline[2] = DIV255B8(s * pDataline[4] + t * pScanline[2]);
905
#endif
906
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
907
}
908
}
909
910
pScanline += (pData->iColinc << 2);
911
pDataline += 8;
912
}
913
}
914
else
915
#endif
916
{
917
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
918
{
919
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
920
{ /* fully opaque ? */
921
if (s == 255)
922
{ /* then simply copy the values */
923
#ifdef MNG_BIGENDIAN_SUPPORTED
924
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
925
#else
926
pScanline[0] = pDataline[0];
927
pScanline[1] = pDataline[1];
928
pScanline[2] = pDataline[2];
929
pScanline[3] = 255;
930
#endif
931
}
932
else
933
{ /* now blend (premultiplied) */
934
t = 255 - s;
935
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
936
{
937
int i;
938
for (i=2; i >= 0; i--)
939
{
940
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
941
pScanline[2-i]);
942
}
943
}
944
#else
945
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
946
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
947
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
948
#endif
949
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
950
}
951
}
952
953
pScanline += (pData->iColinc << 2);
954
pDataline += 4;
955
}
956
}
957
}
958
}
959
960
check_update_region (pData);
961
962
#ifdef MNG_SUPPORT_TRACE
963
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
964
#endif
965
966
return MNG_NOERROR;
967
}
1224
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1225
1226
if (pData->bIsOpaque) /* forget about transparency ? */
1227
{
1228
if (pData->bIsRGBA16) /* 16-bit input row ? */
1229
{
1230
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1231
iX += pData->iColinc)
1232
{ /* scale down by dropping the LSB */
1233
if ((s = pDataline[6]) == 0)
1234
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1235
else
1236
{
1237
if (s == 255)
1238
{
1239
pScanline[0] = pDataline[0];
1240
pScanline[1] = pDataline[2];
1241
pScanline[2] = pDataline[4];
1242
pScanline[3] = 255;
1243
}
1244
else
1245
{
1246
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1247
int i;
1248
for (i=2; i >= 0; i--)
1249
{
1250
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
1251
}
1252
#else
1253
pScanline[0] = DIV255B8(s * pDataline[0]);
1254
pScanline[1] = DIV255B8(s * pDataline[2]);
1255
pScanline[2] = DIV255B8(s * pDataline[4]);
1256
#endif
1257
pScanline[3] = (mng_uint8)s;
1258
}
1259
}
1260
pScanline += (pData->iColinc << 2);
1261
pDataline += 8;
1262
}
1263
}
1264
else
1265
{
1266
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1267
iX += pData->iColinc)
1268
{ /* copy the values and premultiply */
1269
if ((s = pDataline[3]) == 0)
1270
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1271
else
1272
{
1273
if (s == 255)
1274
{
1275
#ifdef MNG_BIGENDIAN_SUPPORTED
1276
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1277
#else
1278
pScanline[0] = pDataline[0];
1279
pScanline[1] = pDataline[1];
1280
pScanline[2] = pDataline[2];
1281
pScanline[3] = 255;
1282
#endif
1283
}
1284
else
1285
{
1286
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1287
int i;
1288
for (i=2; i >= 0; i--)
1289
{
1290
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
1291
}
1292
#else
1293
pScanline[0] = DIV255B8(s * pDataline[0]);
1294
pScanline[1] = DIV255B8(s * pDataline[1]);
1295
pScanline[2] = DIV255B8(s * pDataline[2]);
1296
#endif
1297
pScanline[3] = (mng_uint8)s;
1298
}
1299
}
1300
1301
pScanline += (pData->iColinc << 2);
1302
pDataline += 4;
1303
}
1304
}
1305
}
1306
else
1307
{
1308
if (pData->bIsRGBA16) /* 16-bit input row ? */
1309
{
1310
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1311
iX += pData->iColinc)
1312
{ /* get alpha values */
1313
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
1314
{ /* fully opaque or background fully transparent ? */
1315
if (s == 255)
1316
{ /* plain copy it */
1317
pScanline[0] = pDataline[0];
1318
pScanline[1] = pDataline[2];
1319
pScanline[2] = pDataline[4];
1320
pScanline[3] = 255;
1321
}
1322
else
1323
{ /* now blend (premultiplied) */
1324
t = 255 - s;
1325
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1326
{
1327
int i;
1328
for (i=2; i >= 0; i--)
1329
{
1330
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
1331
pScanline[2-i]);
1332
}
1333
}
1334
#else
1335
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
1336
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
1337
pScanline[2] = DIV255B8(s * pDataline[4] + t * pScanline[2]);
1338
#endif
1339
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1340
}
1341
}
1342
1343
pScanline += (pData->iColinc << 2);
1344
pDataline += 8;
1345
}
1346
}
1347
else
1348
{
1349
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1350
iX += pData->iColinc)
1351
{
1352
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1353
{ /* fully opaque ? */
1354
if (s == 255)
1355
{ /* then simply copy the values */
1356
#ifdef MNG_BIGENDIAN_SUPPORTED
1357
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1358
#else
1359
pScanline[0] = pDataline[0];
1360
pScanline[1] = pDataline[1];
1361
pScanline[2] = pDataline[2];
1362
pScanline[3] = 255;
1363
#endif
1364
}
1365
else
1366
{ /* now blend (premultiplied) */
1367
t = 255 - s;
1368
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1369
{
1370
int i;
1371
for (i=2; i >= 0; i--)
1372
{
1373
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
1374
pScanline[2-i]);
1375
}
1376
}
1377
#else
1378
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
1379
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
1380
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
1381
#endif
1382
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1383
}
1384
}
1385
1386
pScanline += (pData->iColinc << 2);
1387
pDataline += 4;
1388
}
1389
}
1390
}
1391
}
1392
1393
check_update_region (pData);
1394
1395
#ifdef MNG_SUPPORT_TRACE
1396
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1397
#endif
1398
1399
return MNG_NOERROR;
1400
}
1401
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1402
mng_retcode mng_display_rgba8_pm (mng_datap pData)
1403
{
1404
mng_uint8p pScanline;
1405
mng_uint8p pDataline;
1406
mng_int32 iX;
1407
mng_uint32 s, t;
1408
mng_uint8 iBps;
1409
1410
#ifdef MNG_SUPPORT_TRACE
1411
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
1412
#endif
1413
1414
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
1415
/* viewable row ? */
1416
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
1417
{ /* address destination row */
1418
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
1419
pData->iRow + pData->iDestt -
1420
pData->iSourcet);
1421
/* adjust destination row starting-point */
1422
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1423
pDataline = pData->pRGBArow; /* address source row */
1424
1425
/* adjust source row starting-point */
1426
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
1427
1428
if (pData->bIsOpaque) /* forget about transparency ? */
1429
{
1430
if (pData->bIsRGBA16) /* 16-bit input row ? */
1431
{
1432
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1433
iX += pData->iColinc)
1434
{ /* scale down by dropping the LSB */
1435
if ((s = pDataline[6]) == 0)
1436
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1437
else
1438
{
1439
if (s == 255)
1440
{
1441
pScanline[0] = pDataline[0];
1442
pScanline[1] = pDataline[2];
1443
pScanline[2] = pDataline[4];
1444
pScanline[3] = 255;
1445
}
1446
else
1447
{
1448
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1449
int i;
1450
for (i=2; i >= 0; i--)
1451
{
1452
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
1453
}
1454
#else
1455
pScanline[0] = DIV255B8(s * pDataline[0]);
1456
pScanline[1] = DIV255B8(s * pDataline[2]);
1457
pScanline[2] = DIV255B8(s * pDataline[4]);
1458
#endif
1459
pScanline[3] = (mng_uint8)s;
1460
}
1461
}
1462
pScanline += (pData->iColinc << 2);
1463
pDataline += 8;
1464
}
1465
}
1466
else
1467
{
1468
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1469
iX += pData->iColinc)
1470
{ /* copy the values and premultiply */
1471
if ((s = pDataline[3]) == 0)
1472
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1473
else
1474
{
1475
if (s == 255)
1476
{
1477
#ifdef MNG_BIGENDIAN_SUPPORTED
1478
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1479
#else
1480
pScanline[0] = pDataline[0];
1481
pScanline[1] = pDataline[1];
1482
pScanline[2] = pDataline[2];
1483
pScanline[3] = 255;
1484
#endif
1485
}
1486
else
1487
{
1488
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1489
int i;
1490
for (i=2; i >= 0; i--)
1491
{
1492
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
1493
}
1494
#else
1495
pScanline[0] = DIV255B8(s * pDataline[0]);
1496
pScanline[1] = DIV255B8(s * pDataline[1]);
1497
pScanline[2] = DIV255B8(s * pDataline[2]);
1498
#endif
1499
pScanline[3] = (mng_uint8)s;
1500
}
1501
}
1502
1503
pScanline += (pData->iColinc << 2);
1504
pDataline += 4;
1505
}
1506
}
1507
}
1508
else
1509
{
1510
if (pData->bIsRGBA16) /* 16-bit input row ? */
1511
{
1512
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1513
iX += pData->iColinc)
1514
{ /* get alpha values */
1515
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
1516
{ /* fully opaque or background fully transparent ? */
1517
if (s == 255)
1518
{ /* plain copy it */
1519
pScanline[0] = pDataline[0];
1520
pScanline[1] = pDataline[2];
1521
pScanline[2] = pDataline[4];
1522
pScanline[3] = 255;
1523
}
1524
else
1525
{ /* now blend (premultiplied) */
1526
t = 255 - s;
1527
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1528
{
1529
int i;
1530
for (i=2; i >= 0; i--)
1531
{
1532
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
1533
pScanline[2-i]);
1534
}
1535
}
1536
#else
1537
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
1538
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
1539
pScanline[2] = DIV255B8(s * pDataline[4] + t * pScanline[2]);
1540
#endif
1541
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1542
}
1543
}
1544
1545
pScanline += (pData->iColinc << 2);
1546
pDataline += 8;
1547
}
1548
}
1549
else
1550
{
1551
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1552
iX += pData->iColinc)
1553
{
1554
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1555
{ /* fully opaque ? */
1556
if (s == 255)
1557
{ /* then simply copy the values */
1558
#ifdef MNG_BIGENDIAN_SUPPORTED
1559
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1560
#else
1561
pScanline[0] = pDataline[0];
1562
pScanline[1] = pDataline[1];
1563
pScanline[2] = pDataline[2];
1564
pScanline[3] = 255;
1565
#endif
1566
}
1567
else
1568
{ /* now blend (premultiplied) */
1569
t = 255 - s;
1570
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1571
{
1572
int i;
1573
for (i=2; i >= 0; i--)
1574
{
1575
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
1576
pScanline[2-i]);
1577
}
1578
}
1579
#else
1580
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
1581
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
1582
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
1583
#endif
1584
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1585
}
1586
}
1587
1588
pScanline += (pData->iColinc << 2);
1589
pDataline += 4;
1590
}
1591
}
1592
}
1593
}
1594
1595
check_update_region (pData);
1596
1597
#ifdef MNG_SUPPORT_TRACE
1598
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1599
#endif
1600
1601
return MNG_NOERROR;
1602
}
1603
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1604
#else /* MNG_NO_16BIT_SUPPORT */
1605
mng_retcode mng_display_rgba8_pm (mng_datap pData)
1606
{
1607
mng_uint8p pScanline;
1608
mng_uint8p pDataline;
1609
mng_int32 iX;
1610
mng_uint32 s, t;
1611
1612
#ifdef MNG_SUPPORT_TRACE
1613
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
1614
#endif
1615
/* viewable row ? */
1616
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
1617
{ /* address destination row */
1618
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
1619
pData->iRow + pData->iDestt -
1620
pData->iSourcet);
1621
/* adjust destination row starting-point */
1622
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1623
pDataline = pData->pRGBArow; /* address source row */
1624
1625
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1626
1627
if (pData->bIsOpaque) /* forget about transparency ? */
1628
{
1629
{
1630
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1631
iX += pData->iColinc)
1632
{ /* copy the values and premultiply */
1633
if ((s = pDataline[3]) == 0)
1634
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1635
else
1636
{
1637
if (s == 255)
1638
{
1639
#ifdef MNG_BIGENDIAN_SUPPORTED
1640
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1641
#else
1642
pScanline[0] = pDataline[0];
1643
pScanline[1] = pDataline[1];
1644
pScanline[2] = pDataline[2];
1645
pScanline[3] = 255;
1646
#endif
1647
}
1648
else
1649
{
1650
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1651
int i;
1652
for (i=2; i >= 0; i--)
1653
{
1654
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
1655
}
1656
#else
1657
pScanline[0] = DIV255B8(s * pDataline[0]);
1658
pScanline[1] = DIV255B8(s * pDataline[1]);
1659
pScanline[2] = DIV255B8(s * pDataline[2]);
1660
#endif
1661
pScanline[3] = (mng_uint8)s;
1662
}
1663
}
1664
1665
pScanline += (pData->iColinc << 2);
1666
pDataline += 4;
1667
}
1668
}
1669
}
1670
else
1671
{
1672
{
1673
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1674
iX += pData->iColinc)
1675
{
1676
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1677
{ /* fully opaque ? */
1678
if (s == 255)
1679
{ /* then simply copy the values */
1680
#ifdef MNG_BIGENDIAN_SUPPORTED
1681
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1682
#else
1683
pScanline[0] = pDataline[0];
1684
pScanline[1] = pDataline[1];
1685
pScanline[2] = pDataline[2];
1686
pScanline[3] = 255;
1687
#endif
1688
}
1689
else
1690
{ /* now blend (premultiplied) */
1691
t = 255 - s;
1692
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1693
{
1694
int i;
1695
for (i=2; i >= 0; i--)
1696
{
1697
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
1698
pScanline[2-i]);
1699
}
1700
}
1701
#else
1702
pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
1703
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
1704
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
1705
#endif
1706
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1707
}
1708
}
1709
1710
pScanline += (pData->iColinc << 2);
1711
pDataline += 4;
1712
}
1713
}
1714
}
1715
}
1716
1717
check_update_region (pData);
1718
1719
#ifdef MNG_SUPPORT_TRACE
1720
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1721
#endif
1722
1723
return MNG_NOERROR;
1724
}
1725
#endif /* MNG_NO_16BIT_SUPPORT */
968
1726
#endif /* MNG_SKIPCANVAS_RGBA8_PM */
969
1727
970
1728
/* ************************************************************************** */
971
1729
972
1730
#ifndef MNG_SKIPCANVAS_ARGB8
1731
#ifndef MNG_NO_16BIT_SUPPORT
1732
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
973
1733
mng_retcode mng_display_argb8 (mng_datap pData)
974
1734
{
975
1735
mng_uint8p pScanline;
976
1736
mng_uint8p pDataline;
977
1737
mng_int32 iX;
978
1738
mng_uint8 iFGa8, iBGa8, iCa8;
979
#ifndef MNG_NO_16BIT_SUPPORT
980
1739
mng_uint16 iFGa16, iBGa16, iCa16;
981
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
982
1740
mng_uint16 iFGr16, iFGg16, iFGb16;
983
#else
984
mng_uint16 iFGg16;
985
#endif
986
1741
mng_uint16 iBGr16, iBGg16, iBGb16;
987
1742
mng_uint16 iCr16, iCg16, iCb16;
988
#endif
989
1743
mng_uint8 iCr8, iCg8, iCb8;
990
1744
991
1745
#ifdef MNG_SUPPORT_TRACE
1002
1756
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1003
1757
pDataline = pData->pRGBArow; /* address source row */
1004
1758
1005
#ifndef MNG_NO_16BIT_SUPPORT
1006
1759
if (pData->bIsRGBA16) /* adjust source row starting-point */
1007
1760
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
1008
1761
else
1009
#endif
1010
1762
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1011
1763
1012
1764
if (pData->bIsOpaque) /* forget about transparency ? */
1013
1765
{
1014
#ifndef MNG_NO_16BIT_SUPPORT
1015
1766
if (pData->bIsRGBA16) /* 16-bit input row ? */
1016
1767
{
1017
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1768
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1769
iX += pData->iColinc)
1018
1770
{ /* scale down by dropping the LSB */
1019
1771
*pScanline = *(pDataline+6);
1020
1772
*(pScanline+1) = *pDataline;
1026
1778
}
1027
1779
}
1028
1780
else
1029
#endif
1030
1781
{
1031
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1782
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1783
iX += pData->iColinc)
1032
1784
{ /* copy the values */
1033
1785
*pScanline = *(pDataline+3);
1034
1786
*(pScanline+1) = *pDataline;
1042
1794
}
1043
1795
else
1044
1796
{
1045
#ifndef MNG_NO_16BIT_SUPPORT
1046
if (pData->bIsRGBA16) /* 16-bit input row ? */
1047
{
1048
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1049
{ /* get alpha values */
1050
iFGa16 = mng_get_uint16 (pDataline+6);
1051
iBGa16 = (mng_uint16)(*pScanline);
1052
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
1053
1054
if (iFGa16) /* any opacity at all ? */
1055
{ /* fully opaque or background fully transparent ? */
1056
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
1057
{ /* plain copy it */
1058
*pScanline = *(pDataline+6);
1059
*(pScanline+1) = *pDataline;
1060
*(pScanline+2) = *(pDataline+2);
1061
*(pScanline+3) = *(pDataline+4);
1062
}
1063
else
1064
{
1065
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
1066
{ /* get the proper values */
1067
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1797
if (pData->bIsRGBA16) /* 16-bit input row ? */
1798
{
1799
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1800
iX += pData->iColinc)
1801
{ /* get alpha values */
1802
iFGa16 = mng_get_uint16 (pDataline+6);
1803
iBGa16 = (mng_uint16)(*pScanline);
1804
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
1805
1806
if (iFGa16) /* any opacity at all ? */
1807
{ /* fully opaque or background fully transparent ? */
1808
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
1809
{ /* plain copy it */
1810
*pScanline = *(pDataline+6);
1811
*(pScanline+1) = *pDataline;
1812
*(pScanline+2) = *(pDataline+2);
1813
*(pScanline+3) = *(pDataline+4);
1814
}
1815
else
1816
{
1817
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
1818
{ /* get the proper values */
1819
iFGr16 = mng_get_uint16 (pDataline );
1820
iFGg16 = mng_get_uint16 (pDataline+2);
1821
iFGb16 = mng_get_uint16 (pDataline+4);
1822
/* scale background up */
1823
iBGr16 = (mng_uint16)(*(pScanline+1));
1824
iBGg16 = (mng_uint16)(*(pScanline+2));
1825
iBGb16 = (mng_uint16)(*(pScanline+3));
1826
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
1827
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1828
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
1829
/* now compose */
1830
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
1831
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
1832
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
1833
/* and return the composed values */
1834
/* alpha remains fully opaque !!! */
1835
*(pScanline+1) = (mng_uint8)(iFGr16 >> 8);
1836
*(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
1837
*(pScanline+3) = (mng_uint8)(iFGb16 >> 8);
1838
}
1839
else
1840
{ /* scale background up */
1841
iBGr16 = (mng_uint16)(*(pScanline+1));
1842
iBGg16 = (mng_uint16)(*(pScanline+2));
1843
iBGb16 = (mng_uint16)(*(pScanline+3));
1844
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
1845
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1846
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
1847
/* let's blend */
1848
MNG_BLEND16 (mng_get_uint16 (pDataline ),
1849
mng_get_uint16 (pDataline+2),
1850
mng_get_uint16 (pDataline+4), iFGa16,
1851
iBGr16, iBGg16, iBGb16, iBGa16,
1852
iCr16, iCg16, iCb16, iCa16);
1853
/* and return the composed values */
1854
*pScanline = (mng_uint8)(iCa16 >> 8);
1855
*(pScanline+1) = (mng_uint8)(iCr16 >> 8);
1856
*(pScanline+2) = (mng_uint8)(iCg16 >> 8);
1857
*(pScanline+3) = (mng_uint8)(iCb16 >> 8);
1858
}
1859
}
1860
}
1861
1862
pScanline += (pData->iColinc << 2);
1863
pDataline += 8;
1864
}
1865
}
1866
else
1867
{
1868
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1869
iX += pData->iColinc)
1870
{
1871
iFGa8 = *(pDataline+3); /* get alpha values */
1872
iBGa8 = *pScanline;
1873
1874
if (iFGa8) /* any opacity at all ? */
1875
{ /* fully opaque or background fully transparent ? */
1876
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
1877
{ /* then simply copy the values */
1878
*pScanline = *(pDataline+3);
1879
*(pScanline+1) = *pDataline;
1880
*(pScanline+2) = *(pDataline+1);
1881
*(pScanline+3) = *(pDataline+2);
1882
}
1883
else
1884
{
1885
if (iBGa8 == 0xFF) /* background fully opaque ? */
1886
{ /* do simple alpha composing */
1887
/* alpha itself remains fully opaque !!! */
1888
}
1889
else
1890
{ /* now blend */
1891
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
1892
*(pScanline+1), *(pScanline+2), *(pScanline+3), iBGa8,
1893
iCr8, iCg8, iCb8, iCa8);
1894
/* and return the composed values */
1895
*pScanline = iCa8;
1896
*(pScanline+1) = iCr8;
1897
*(pScanline+2) = iCg8;
1898
*(pScanline+3) = iCb8;
1899
}
1900
}
1901
}
1902
1903
pScanline += (pData->iColinc << 2);
1904
pDataline += 4;
1905
}
1906
}
1907
}
1908
}
1909
1910
check_update_region (pData);
1911
1912
#ifdef MNG_SUPPORT_TRACE
1913
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_END);
1914
#endif
1915
1916
return MNG_NOERROR;
1917
}
1918
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1919
mng_retcode mng_display_argb8 (mng_datap pData)
1920
{
1921
mng_uint8p pScanline;
1922
mng_uint8p pDataline;
1923
mng_int32 iX;
1924
mng_uint8 iFGa8, iBGa8, iCa8;
1925
mng_uint16 iFGa16, iBGa16, iCa16;
1926
mng_uint16 iFGg16;
1927
mng_uint16 iBGr16, iBGg16, iBGb16;
1928
mng_uint16 iCr16, iCg16, iCb16;
1929
mng_uint8 iCr8, iCg8, iCb8;
1930
mng_uint8 iBps;
1931
1932
#ifdef MNG_SUPPORT_TRACE
1933
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_START);
1934
#endif
1935
1936
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
1937
/* viewable row ? */
1938
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
1939
{ /* address destination row */
1940
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
1941
pData->iRow + pData->iDestt -
1942
pData->iSourcet);
1943
/* adjust destination row starting-point */
1944
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1945
pDataline = pData->pRGBArow; /* address source row */
1946
1947
/* adjust source row starting-point */
1948
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
1949
1950
if (pData->bIsOpaque) /* forget about transparency ? */
1951
{
1952
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1953
iX += pData->iColinc)
1954
{ /* scale down by dropping the LSB */
1955
*pScanline = *(pDataline+3*iBps);
1956
*(pScanline+1) = *pDataline;
1957
*(pScanline+2) = *(pDataline+iBps);
1958
*(pScanline+3) = *(pDataline+2*iBps);
1959
1960
pScanline += (pData->iColinc << 2);
1961
pDataline += 4*iBps;
1962
}
1963
}
1964
else
1965
{
1966
if (pData->bIsRGBA16) /* 16-bit input row ? */
1967
{
1968
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1969
iX += pData->iColinc)
1970
{ /* get alpha values */
1971
iFGa16 = mng_get_uint16 (pDataline+6);
1972
iBGa16 = (mng_uint16)(*pScanline);
1973
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
1974
1975
if (iFGa16) /* any opacity at all ? */
1976
{ /* fully opaque or background fully transparent ? */
1977
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
1978
{ /* plain copy it */
1979
*pScanline = *(pDataline+6);
1980
*(pScanline+1) = *pDataline;
1981
*(pScanline+2) = *(pDataline+2);
1982
*(pScanline+3) = *(pDataline+4);
1983
}
1984
else
1985
{
1986
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
1987
{ /* get the proper values */
1068
1988
int i;
1069
1989
for (i=2; i >= 0; i--)
1070
1990
{
1078
1998
/* alpha remains fully opaque !!! */
1079
1999
*(pScanline+i+1) = (mng_uint8)(iFGg16 >> 8);
1080
2000
}
1081
#else
1082
iFGr16 = mng_get_uint16 (pDataline );
1083
iFGg16 = mng_get_uint16 (pDataline+2);
1084
iFGb16 = mng_get_uint16 (pDataline+4);
1085
/* scale background up */
1086
iBGr16 = (mng_uint16)(*(pScanline+1));
1087
iBGg16 = (mng_uint16)(*(pScanline+2));
1088
iBGb16 = (mng_uint16)(*(pScanline+3));
1089
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
1090
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1091
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
1092
/* now compose */
1093
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
1094
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
1095
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
1096
/* and return the composed values */
1097
/* alpha remains fully opaque !!! */
1098
*(pScanline+1) = (mng_uint8)(iFGr16 >> 8);
1099
*(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
1100
*(pScanline+3) = (mng_uint8)(iFGb16 >> 8);
1101
#endif
1102
2001
}
1103
2002
else
1104
2003
{ /* scale background up */
1128
2027
}
1129
2028
}
1130
2029
else
1131
#endif
1132
{
1133
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2030
{
2031
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2032
iX += pData->iColinc)
2033
{
2034
iFGa8 = *(pDataline+3); /* get alpha values */
2035
iBGa8 = *pScanline;
2036
2037
if (iFGa8) /* any opacity at all ? */
2038
{ /* fully opaque or background fully transparent ? */
2039
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
2040
{ /* then simply copy the values */
2041
*pScanline = *(pDataline+3);
2042
*(pScanline+1) = *pDataline;
2043
*(pScanline+2) = *(pDataline+1);
2044
*(pScanline+3) = *(pDataline+2);
2045
}
2046
else
2047
{
2048
if (iBGa8 == 0xFF) /* background fully opaque ? */
2049
{ /* do simple alpha composing */
2050
/* alpha itself remains fully opaque !!! */
2051
int i;
2052
for (i=2; i >= 0; i--)
2053
{
2054
MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+i), iFGa8, *(pScanline+i+1));
2055
}
2056
}
2057
else
2058
{ /* now blend */
2059
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
2060
*(pScanline+1), *(pScanline+2), *(pScanline+3), iBGa8,
2061
iCr8, iCg8, iCb8, iCa8);
2062
/* and return the composed values */
2063
*pScanline = iCa8;
2064
*(pScanline+1) = iCr8;
2065
*(pScanline+2) = iCg8;
2066
*(pScanline+3) = iCb8;
2067
}
2068
}
2069
}
2070
2071
pScanline += (pData->iColinc << 2);
2072
pDataline += 4;
2073
}
2074
}
2075
}
2076
}
2077
2078
check_update_region (pData);
2079
2080
#ifdef MNG_SUPPORT_TRACE
2081
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_END);
2082
#endif
2083
2084
return MNG_NOERROR;
2085
}
2086
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2087
#else /* MNG_NO_16BIT_SUPPORT */
2088
mng_retcode mng_display_argb8 (mng_datap pData)
2089
{
2090
mng_uint8p pScanline;
2091
mng_uint8p pDataline;
2092
mng_int32 iX;
2093
mng_uint8 iFGa8, iBGa8, iCa8;
2094
mng_uint8 iCr8, iCg8, iCb8;
2095
2096
#ifdef MNG_SUPPORT_TRACE
2097
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_START);
2098
#endif
2099
2100
/* viewable row ? */
2101
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
2102
{ /* address destination row */
2103
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
2104
pData->iRow + pData->iDestt -
2105
pData->iSourcet);
2106
/* adjust destination row starting-point */
2107
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2108
pDataline = pData->pRGBArow; /* address source row */
2109
2110
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2111
2112
if (pData->bIsOpaque) /* forget about transparency ? */
2113
{
2114
{
2115
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2116
iX += pData->iColinc)
2117
{ /* copy the values */
2118
*pScanline = *(pDataline+3);
2119
*(pScanline+1) = *pDataline;
2120
*(pScanline+2) = *(pDataline+1);
2121
*(pScanline+3) = *(pDataline+2);
2122
2123
pScanline += (pData->iColinc << 2);
2124
pDataline += 4;
2125
}
2126
}
2127
}
2128
else
2129
{
2130
{
2131
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2132
iX += pData->iColinc)
1134
2133
{
1135
2134
iFGa8 = *(pDataline+3); /* get alpha values */
1136
2135
iBGa8 = *pScanline;
1190
2189
1191
2190
return MNG_NOERROR;
1192
2191
}
2192
#endif /* MNG_NO_16BIT_SUPPORT */
1193
2193
#endif /* MNG_SKIPCANVAS_ARGB8 */
1194
2194
1195
2195
/* ************************************************************************** */
1196
2196
1197
2197
#ifndef MNG_SKIPCANVAS_ARGB8_PM
2198
#ifndef MNG_NO_16BIT_SUPPORT
2199
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1198
2200
mng_retcode mng_display_argb8_pm (mng_datap pData)
1199
2201
{
1200
2202
mng_uint8p pScanline;
1215
2217
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1216
2218
pDataline = pData->pRGBArow; /* address source row */
1217
2219
1218
#ifndef MNG_NO_16BIT_SUPPORT
1219
2220
if (pData->bIsRGBA16) /* adjust source row starting-point */
1220
2221
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
1221
2222
else
1222
#endif
1223
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1224
1225
if (pData->bIsOpaque) /* forget about transparency ? */
1226
{
1227
#ifndef MNG_NO_16BIT_SUPPORT
1228
if (pData->bIsRGBA16) /* 16-bit input row ? */
1229
{
1230
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1231
{ /* scale down by dropping the LSB */
1232
if ((s = pDataline[6]) == 0)
1233
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1234
else
1235
{
1236
if (s == 255)
1237
{
1238
pScanline[0] = 255;
1239
pScanline[1] = pDataline[0];
1240
pScanline[2] = pDataline[2];
1241
pScanline[3] = pDataline[4];
1242
}
1243
else
1244
{
1245
pScanline[0] = (mng_uint8)s;
1246
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1247
{
1248
int i;
1249
for (i=2; i >= 0; i--)
1250
{
1251
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
1252
}
1253
}
1254
#else
1255
pScanline[1] = DIV255B8(s * pDataline[0]);
1256
pScanline[2] = DIV255B8(s * pDataline[2]);
1257
pScanline[3] = DIV255B8(s * pDataline[4]);
1258
#endif
1259
}
1260
}
1261
pScanline += (pData->iColinc << 2);
1262
pDataline += 8;
1263
}
1264
}
1265
else
1266
#endif
1267
{
1268
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1269
{ /* copy the values and premultiply */
1270
if ((s = pDataline[3]) == 0)
1271
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
1272
else
1273
{
1274
if (s == 255)
1275
{
1276
pScanline[0] = 255;
1277
pScanline[1] = pDataline[0];
1278
pScanline[2] = pDataline[1];
1279
pScanline[3] = pDataline[2];
1280
}
1281
else
1282
{
1283
pScanline[0] = (mng_uint8)s;
1284
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1285
{
1286
int i;
1287
for (i=2; i >= 0; i--)
1288
{
1289
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
1290
}
1291
}
1292
#else
1293
pScanline[1] = DIV255B8(s * pDataline[0]);
1294
pScanline[2] = DIV255B8(s * pDataline[1]);
1295
pScanline[3] = DIV255B8(s * pDataline[2]);
1296
#endif
1297
}
1298
}
1299
1300
pScanline += (pData->iColinc << 2);
1301
pDataline += 4;
1302
}
1303
}
1304
}
1305
else
1306
{
1307
#ifndef MNG_NO_16BIT_SUPPORT
1308
if (pData->bIsRGBA16) /* 16-bit input row ? */
1309
{
1310
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1311
{ /* get alpha values */
1312
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
1313
{ /* fully opaque or background fully transparent ? */
1314
if (s == 255)
1315
{ /* plain copy it */
1316
pScanline[0] = 255;
1317
pScanline[1] = pDataline[0];
1318
pScanline[2] = pDataline[2];
1319
pScanline[3] = pDataline[4];
1320
}
1321
else
1322
{ /* now blend (premultiplied) */
1323
t = 255 - s;
1324
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
1325
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1326
{
1327
int i;
1328
for (i=2; i >= 0; i--)
1329
{
1330
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
1331
pScanline[3-i]);
1332
}
1333
}
1334
#else
1335
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
1336
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
1337
pScanline[3] = DIV255B8(s * pDataline[4] + t * pScanline[3]);
1338
#endif
1339
}
1340
}
1341
1342
pScanline += (pData->iColinc << 2);
1343
pDataline += 8;
1344
}
1345
}
1346
else
1347
#endif
1348
{
1349
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1350
{
1351
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1352
{ /* fully opaque ? */
1353
if (s == 255)
1354
{ /* then simply copy the values */
1355
pScanline[0] = 255;
1356
pScanline[1] = pDataline[0];
1357
pScanline[2] = pDataline[1];
1358
pScanline[3] = pDataline[2];
1359
}
1360
else
1361
{ /* now blend (premultiplied) */
1362
t = 255 - s;
1363
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
1364
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1365
{
1366
int i;
1367
for (i=2; i >= 0; i--)
1368
{
1369
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
1370
pScanline[3-i]);
1371
}
1372
}
1373
#else
1374
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
1375
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
1376
pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
1377
#endif
1378
}
1379
}
1380
1381
pScanline += (pData->iColinc << 2);
1382
pDataline += 4;
1383
}
1384
}
1385
}
1386
}
1387
1388
check_update_region (pData);
1389
1390
#ifdef MNG_SUPPORT_TRACE
1391
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
1392
#endif
1393
1394
return MNG_NOERROR;
1395
}
2223
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2224
2225
if (pData->bIsOpaque) /* forget about transparency ? */
2226
{
2227
if (pData->bIsRGBA16) /* 16-bit input row ? */
2228
{
2229
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2230
iX += pData->iColinc)
2231
{ /* scale down by dropping the LSB */
2232
if ((s = pDataline[6]) == 0)
2233
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2234
else
2235
{
2236
if (s == 255)
2237
{
2238
pScanline[0] = 255;
2239
pScanline[1] = pDataline[0];
2240
pScanline[2] = pDataline[2];
2241
pScanline[3] = pDataline[4];
2242
}
2243
else
2244
{
2245
pScanline[0] = (mng_uint8)s;
2246
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2247
{
2248
int i;
2249
for (i=2; i >= 0; i--)
2250
{
2251
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
2252
}
2253
}
2254
#else
2255
pScanline[1] = DIV255B8(s * pDataline[0]);
2256
pScanline[2] = DIV255B8(s * pDataline[2]);
2257
pScanline[3] = DIV255B8(s * pDataline[4]);
2258
#endif
2259
}
2260
}
2261
pScanline += (pData->iColinc << 2);
2262
pDataline += 8;
2263
}
2264
}
2265
else
2266
{
2267
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2268
iX += pData->iColinc)
2269
{ /* copy the values and premultiply */
2270
if ((s = pDataline[3]) == 0)
2271
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2272
else
2273
{
2274
if (s == 255)
2275
{
2276
pScanline[0] = 255;
2277
pScanline[1] = pDataline[0];
2278
pScanline[2] = pDataline[1];
2279
pScanline[3] = pDataline[2];
2280
}
2281
else
2282
{
2283
pScanline[0] = (mng_uint8)s;
2284
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2285
{
2286
int i;
2287
for (i=2; i >= 0; i--)
2288
{
2289
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
2290
}
2291
}
2292
#else
2293
pScanline[1] = DIV255B8(s * pDataline[0]);
2294
pScanline[2] = DIV255B8(s * pDataline[1]);
2295
pScanline[3] = DIV255B8(s * pDataline[2]);
2296
#endif
2297
}
2298
}
2299
2300
pScanline += (pData->iColinc << 2);
2301
pDataline += 4;
2302
}
2303
}
2304
}
2305
else
2306
{
2307
if (pData->bIsRGBA16) /* 16-bit input row ? */
2308
{
2309
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2310
iX += pData->iColinc)
2311
{ /* get alpha values */
2312
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
2313
{ /* fully opaque or background fully transparent ? */
2314
if (s == 255)
2315
{ /* plain copy it */
2316
pScanline[0] = 255;
2317
pScanline[1] = pDataline[0];
2318
pScanline[2] = pDataline[2];
2319
pScanline[3] = pDataline[4];
2320
}
2321
else
2322
{ /* now blend (premultiplied) */
2323
t = 255 - s;
2324
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2325
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2326
{
2327
int i;
2328
for (i=2; i >= 0; i--)
2329
{
2330
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
2331
pScanline[3-i]);
2332
}
2333
}
2334
#else
2335
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
2336
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
2337
pScanline[3] = DIV255B8(s * pDataline[4] + t * pScanline[3]);
2338
#endif
2339
}
2340
}
2341
2342
pScanline += (pData->iColinc << 2);
2343
pDataline += 8;
2344
}
2345
}
2346
else
2347
{
2348
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2349
iX += pData->iColinc)
2350
{
2351
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2352
{ /* fully opaque ? */
2353
if (s == 255)
2354
{ /* then simply copy the values */
2355
pScanline[0] = 255;
2356
pScanline[1] = pDataline[0];
2357
pScanline[2] = pDataline[1];
2358
pScanline[3] = pDataline[2];
2359
}
2360
else
2361
{ /* now blend (premultiplied) */
2362
t = 255 - s;
2363
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2364
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2365
{
2366
int i;
2367
for (i=2; i >= 0; i--)
2368
{
2369
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
2370
pScanline[3-i]);
2371
}
2372
}
2373
#else
2374
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
2375
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
2376
pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
2377
#endif
2378
}
2379
}
2380
2381
pScanline += (pData->iColinc << 2);
2382
pDataline += 4;
2383
}
2384
}
2385
}
2386
}
2387
2388
check_update_region (pData);
2389
2390
#ifdef MNG_SUPPORT_TRACE
2391
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2392
#endif
2393
2394
return MNG_NOERROR;
2395
}
2396
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2397
mng_retcode mng_display_argb8_pm (mng_datap pData)
2398
{
2399
mng_uint8p pScanline;
2400
mng_uint8p pDataline;
2401
mng_int32 iX;
2402
mng_uint32 s, t;
2403
mng_uint8 iBps;
2404
2405
#ifdef MNG_SUPPORT_TRACE
2406
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
2407
#endif
2408
2409
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
2410
/* viewable row ? */
2411
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
2412
{ /* address destination row */
2413
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
2414
pData->iRow + pData->iDestt -
2415
pData->iSourcet);
2416
/* adjust destination row starting-point */
2417
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2418
pDataline = pData->pRGBArow; /* address source row */
2419
2420
/* adjust source row starting-point */
2421
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
2422
2423
if (pData->bIsOpaque) /* forget about transparency ? */
2424
{
2425
if (pData->bIsRGBA16) /* 16-bit input row ? */
2426
{
2427
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2428
iX += pData->iColinc)
2429
{ /* scale down by dropping the LSB */
2430
if ((s = pDataline[6]) == 0)
2431
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2432
else
2433
{
2434
if (s == 255)
2435
{
2436
pScanline[0] = 255;
2437
pScanline[1] = pDataline[0];
2438
pScanline[2] = pDataline[2];
2439
pScanline[3] = pDataline[4];
2440
}
2441
else
2442
{
2443
pScanline[0] = (mng_uint8)s;
2444
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2445
{
2446
int i;
2447
for (i=2; i >= 0; i--)
2448
{
2449
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
2450
}
2451
}
2452
#else
2453
pScanline[1] = DIV255B8(s * pDataline[0]);
2454
pScanline[2] = DIV255B8(s * pDataline[2]);
2455
pScanline[3] = DIV255B8(s * pDataline[4]);
2456
#endif
2457
}
2458
}
2459
pScanline += (pData->iColinc << 2);
2460
pDataline += 8;
2461
}
2462
}
2463
else
2464
{
2465
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2466
iX += pData->iColinc)
2467
{ /* copy the values and premultiply */
2468
if ((s = pDataline[3]) == 0)
2469
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2470
else
2471
{
2472
if (s == 255)
2473
{
2474
pScanline[0] = 255;
2475
pScanline[1] = pDataline[0];
2476
pScanline[2] = pDataline[1];
2477
pScanline[3] = pDataline[2];
2478
}
2479
else
2480
{
2481
pScanline[0] = (mng_uint8)s;
2482
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2483
{
2484
int i;
2485
for (i=2; i >= 0; i--)
2486
{
2487
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
2488
}
2489
}
2490
#else
2491
pScanline[1] = DIV255B8(s * pDataline[0]);
2492
pScanline[2] = DIV255B8(s * pDataline[1]);
2493
pScanline[3] = DIV255B8(s * pDataline[2]);
2494
#endif
2495
}
2496
}
2497
2498
pScanline += (pData->iColinc << 2);
2499
pDataline += 4;
2500
}
2501
}
2502
}
2503
else
2504
{
2505
if (pData->bIsRGBA16) /* 16-bit input row ? */
2506
{
2507
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2508
iX += pData->iColinc)
2509
{ /* get alpha values */
2510
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
2511
{ /* fully opaque or background fully transparent ? */
2512
if (s == 255)
2513
{ /* plain copy it */
2514
pScanline[0] = 255;
2515
pScanline[1] = pDataline[0];
2516
pScanline[2] = pDataline[2];
2517
pScanline[3] = pDataline[4];
2518
}
2519
else
2520
{ /* now blend (premultiplied) */
2521
t = 255 - s;
2522
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2523
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2524
{
2525
int i;
2526
for (i=2; i >= 0; i--)
2527
{
2528
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
2529
pScanline[3-i]);
2530
}
2531
}
2532
#else
2533
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
2534
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
2535
pScanline[3] = DIV255B8(s * pDataline[4] + t * pScanline[3]);
2536
#endif
2537
}
2538
}
2539
2540
pScanline += (pData->iColinc << 2);
2541
pDataline += 8;
2542
}
2543
}
2544
else
2545
{
2546
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2547
iX += pData->iColinc)
2548
{
2549
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2550
{ /* fully opaque ? */
2551
if (s == 255)
2552
{ /* then simply copy the values */
2553
pScanline[0] = 255;
2554
pScanline[1] = pDataline[0];
2555
pScanline[2] = pDataline[1];
2556
pScanline[3] = pDataline[2];
2557
}
2558
else
2559
{ /* now blend (premultiplied) */
2560
t = 255 - s;
2561
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2562
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2563
{
2564
int i;
2565
for (i=2; i >= 0; i--)
2566
{
2567
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
2568
pScanline[3-i]);
2569
}
2570
}
2571
#else
2572
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
2573
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
2574
pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
2575
#endif
2576
}
2577
}
2578
2579
pScanline += (pData->iColinc << 2);
2580
pDataline += 4;
2581
}
2582
}
2583
}
2584
}
2585
2586
check_update_region (pData);
2587
2588
#ifdef MNG_SUPPORT_TRACE
2589
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2590
#endif
2591
2592
return MNG_NOERROR;
2593
}
2594
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2595
#else /* MNG_NO_16BIT_SUPPORT */
2596
mng_retcode mng_display_argb8_pm (mng_datap pData)
2597
{
2598
mng_uint8p pScanline;
2599
mng_uint8p pDataline;
2600
mng_int32 iX;
2601
mng_uint32 s, t;
2602
2603
#ifdef MNG_SUPPORT_TRACE
2604
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
2605
#endif
2606
/* viewable row ? */
2607
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
2608
{ /* address destination row */
2609
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
2610
pData->iRow + pData->iDestt -
2611
pData->iSourcet);
2612
/* adjust destination row starting-point */
2613
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2614
pDataline = pData->pRGBArow; /* address source row */
2615
2616
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2617
2618
if (pData->bIsOpaque) /* forget about transparency ? */
2619
{
2620
{
2621
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2622
iX += pData->iColinc)
2623
{ /* copy the values and premultiply */
2624
if ((s = pDataline[3]) == 0)
2625
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2626
else
2627
{
2628
if (s == 255)
2629
{
2630
pScanline[0] = 255;
2631
pScanline[1] = pDataline[0];
2632
pScanline[2] = pDataline[1];
2633
pScanline[3] = pDataline[2];
2634
}
2635
else
2636
{
2637
pScanline[0] = (mng_uint8)s;
2638
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2639
{
2640
int i;
2641
for (i=2; i >= 0; i--)
2642
{
2643
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
2644
}
2645
}
2646
#else
2647
pScanline[1] = DIV255B8(s * pDataline[0]);
2648
pScanline[2] = DIV255B8(s * pDataline[1]);
2649
pScanline[3] = DIV255B8(s * pDataline[2]);
2650
#endif
2651
}
2652
}
2653
2654
pScanline += (pData->iColinc << 2);
2655
pDataline += 4;
2656
}
2657
}
2658
}
2659
else
2660
{
2661
{
2662
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2663
iX += pData->iColinc)
2664
{
2665
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2666
{ /* fully opaque ? */
2667
if (s == 255)
2668
{ /* then simply copy the values */
2669
pScanline[0] = 255;
2670
pScanline[1] = pDataline[0];
2671
pScanline[2] = pDataline[1];
2672
pScanline[3] = pDataline[2];
2673
}
2674
else
2675
{ /* now blend (premultiplied) */
2676
t = 255 - s;
2677
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2678
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2679
{
2680
int i;
2681
for (i=2; i >= 0; i--)
2682
{
2683
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
2684
pScanline[3-i]);
2685
}
2686
}
2687
#else
2688
pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
2689
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
2690
pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
2691
#endif
2692
}
2693
}
2694
2695
pScanline += (pData->iColinc << 2);
2696
pDataline += 4;
2697
}
2698
}
2699
}
2700
}
2701
2702
check_update_region (pData);
2703
2704
#ifdef MNG_SUPPORT_TRACE
2705
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2706
#endif
2707
2708
return MNG_NOERROR;
2709
}
2710
#endif /* MNG_NO_16BIT_SUPPORT */
1396
2711
#endif /* MNG_SKIPCANVAS_ARGB8_PM */
1397
2712
1398
2713
/* ************************************************************************** */
1399
2714
1400
2715
#ifndef MNG_SKIPCANVAS_RGB8_A8
2716
#ifndef MNG_NO_16BIT_SUPPORT
2717
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1401
2718
mng_retcode mng_display_rgb8_a8 (mng_datap pData)
1402
2719
{
1403
2720
mng_uint8p pScanline;
1405
2722
mng_uint8p pDataline;
1406
2723
mng_int32 iX;
1407
2724
mng_uint8 iFGa8, iBGa8, iCa8;
1408
#ifndef MNG_NO_16BIT_SUPPORT
1409
2725
mng_uint16 iFGa16, iBGa16, iCa16;
1410
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1411
2726
mng_uint16 iFGr16, iFGg16, iFGb16;
1412
#else
1413
mng_uint16 iFGg16;
1414
#endif
1415
2727
mng_uint16 iBGr16, iBGg16, iBGb16;
1416
2728
mng_uint16 iCr16, iCg16, iCb16;
1417
#endif
1418
2729
mng_uint8 iCr8, iCg8, iCb8;
1419
2730
1420
2731
#ifdef MNG_SUPPORT_TRACE
1435
2746
1436
2747
pDataline = pData->pRGBArow; /* address source row */
1437
2748
1438
#ifndef MNG_NO_16BIT_SUPPORT
1439
2749
if (pData->bIsRGBA16) /* adjust source row starting-point */
1440
2750
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
1441
2751
else
1442
#endif
1443
2752
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1444
2753
1445
2754
if (pData->bIsOpaque) /* forget about transparency ? */
1446
2755
{
1447
#ifndef MNG_NO_16BIT_SUPPORT
1448
2756
if (pData->bIsRGBA16) /* 16-bit input row ? */
1449
2757
{
1450
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2758
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2759
iX += pData->iColinc)
1451
2760
{ /* scale down by dropping the LSB */
1452
2761
*pScanline = *pDataline;
1453
2762
*(pScanline+1) = *(pDataline+2);
1460
2769
}
1461
2770
}
1462
2771
else
1463
#endif
1464
2772
{
1465
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2773
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2774
iX += pData->iColinc)
1466
2775
{ /* copy the values */
1467
2776
*pScanline = *pDataline;
1468
2777
*(pScanline+1) = *(pDataline+1);
1477
2786
}
1478
2787
else
1479
2788
{
1480
#ifndef MNG_NO_16BIT_SUPPORT
1481
2789
if (pData->bIsRGBA16) /* 16-bit input row ? */
1482
2790
{
1483
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2791
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2792
iX += pData->iColinc)
1484
2793
{ /* get alpha values */
1485
2794
iFGa16 = mng_get_uint16 (pDataline+6);
1486
2795
iBGa16 = (mng_uint16)(*pAlphaline);
1499
2808
{
1500
2809
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
1501
2810
{ /* get the proper values */
1502
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1503
int i;
1504
for (i=2; i >= 0; i--)
1505
{
1506
iFGg16 = mng_get_uint16 (pDataline+i+i);
1507
/* scale background up */
1508
iBGg16 = (mng_uint16)(*(pScanline+i));
1509
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1510
/* now compose */
1511
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
1512
/* and return the composed values */
1513
*(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
1514
/* alpha remains fully opaque !!! */
1515
}
1516
#else
1517
2811
iFGr16 = mng_get_uint16 (pDataline );
1518
2812
iFGg16 = mng_get_uint16 (pDataline+2);
1519
2813
iFGb16 = mng_get_uint16 (pDataline+4);
1533
2827
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
1534
2828
*(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
1535
2829
/* alpha remains fully opaque !!! */
1536
#endif
1537
}
1538
else
1539
{ /* scale background up */
1540
iBGr16 = (mng_uint16)(*pScanline );
1541
iBGg16 = (mng_uint16)(*(pScanline+1));
1542
iBGb16 = (mng_uint16)(*(pScanline+2));
1543
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
1544
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1545
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
1546
/* let's blend */
1547
MNG_BLEND16 (mng_get_uint16 (pDataline ),
1548
mng_get_uint16 (pDataline+2),
1549
mng_get_uint16 (pDataline+4), iFGa16,
1550
iBGr16, iBGg16, iBGb16, iBGa16,
1551
iCr16, iCg16, iCb16, iCa16);
1552
/* and return the composed values */
1553
*pScanline = (mng_uint8)(iCr16 >> 8);
1554
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
1555
*(pScanline+2) = (mng_uint8)(iCb16 >> 8);
1556
*pAlphaline = (mng_uint8)(iCa16 >> 8);
1557
}
1558
}
1559
}
1560
1561
pScanline += (pData->iColinc * 3);
1562
pAlphaline += pData->iColinc;
1563
pDataline += 8;
1564
}
1565
}
1566
else
1567
#endif
1568
{
1569
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2830
}
2831
else
2832
{ /* scale background up */
2833
iBGr16 = (mng_uint16)(*pScanline );
2834
iBGg16 = (mng_uint16)(*(pScanline+1));
2835
iBGb16 = (mng_uint16)(*(pScanline+2));
2836
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
2837
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
2838
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
2839
/* let's blend */
2840
MNG_BLEND16 (mng_get_uint16 (pDataline ),
2841
mng_get_uint16 (pDataline+2),
2842
mng_get_uint16 (pDataline+4), iFGa16,
2843
iBGr16, iBGg16, iBGb16, iBGa16,
2844
iCr16, iCg16, iCb16, iCa16);
2845
/* and return the composed values */
2846
*pScanline = (mng_uint8)(iCr16 >> 8);
2847
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
2848
*(pScanline+2) = (mng_uint8)(iCb16 >> 8);
2849
*pAlphaline = (mng_uint8)(iCa16 >> 8);
2850
}
2851
}
2852
}
2853
2854
pScanline += (pData->iColinc * 3);
2855
pAlphaline += pData->iColinc;
2856
pDataline += 8;
2857
}
2858
}
2859
else
2860
{
2861
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2862
iX += pData->iColinc)
2863
{
2864
iFGa8 = *(pDataline+3); /* get alpha values */
2865
iBGa8 = *pAlphaline;
2866
2867
if (iFGa8) /* any opacity at all ? */
2868
{ /* fully opaque or background fully transparent ? */
2869
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
2870
{ /* then simply copy the values */
2871
*pScanline = *pDataline;
2872
*(pScanline+1) = *(pDataline+1);
2873
*(pScanline+2) = *(pDataline+2);
2874
*pAlphaline = *(pDataline+3);
2875
}
2876
else
2877
{
2878
if (iBGa8 == 0xFF) /* background fully opaque ? */
2879
{ /* do alpha composing */
2880
MNG_COMPOSE8 (*pScanline, *pDataline, iFGa8, *pScanline );
2881
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
2882
MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iFGa8, *(pScanline+2));
2883
/* alpha remains fully opaque !!! */
2884
}
2885
else
2886
{ /* now blend */
2887
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
2888
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
2889
iCr8, iCg8, iCb8, iCa8);
2890
/* and return the composed values */
2891
*pScanline = iCr8;
2892
*(pScanline+1) = iCg8;
2893
*(pScanline+2) = iCb8;
2894
*pAlphaline = iCa8;
2895
}
2896
}
2897
}
2898
2899
pScanline += (pData->iColinc * 3);
2900
pAlphaline += pData->iColinc;
2901
pDataline += 4;
2902
}
2903
}
2904
}
2905
}
2906
2907
check_update_region (pData);
2908
2909
#ifdef MNG_SUPPORT_TRACE
2910
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
2911
#endif
2912
2913
return MNG_NOERROR;
2914
}
2915
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2916
mng_retcode mng_display_rgb8_a8 (mng_datap pData)
2917
{
2918
mng_uint8p pScanline;
2919
mng_uint8p pAlphaline;
2920
mng_uint8p pDataline;
2921
mng_int32 iX;
2922
mng_uint8 iFGa8, iBGa8, iCa8;
2923
mng_uint16 iFGa16, iBGa16, iCa16;
2924
mng_uint16 iFGg16;
2925
mng_uint16 iBGr16, iBGg16, iBGb16;
2926
mng_uint16 iCr16, iCg16, iCb16;
2927
mng_uint8 iCr8, iCg8, iCb8;
2928
mng_uint8 iBps;
2929
2930
#ifdef MNG_SUPPORT_TRACE
2931
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
2932
#endif
2933
2934
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
2935
/* viewable row ? */
2936
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
2937
{ /* address destination rows */
2938
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
2939
pData->iRow + pData->iDestt -
2940
pData->iSourcet);
2941
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
2942
pData->iRow + pData->iDestt -
2943
pData->iSourcet);
2944
/* adjust destination rows starting-point */
2945
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
2946
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
2947
2948
pDataline = pData->pRGBArow; /* address source row */
2949
2950
/* adjust source row starting-point */
2951
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
2952
2953
if (pData->bIsOpaque) /* forget about transparency ? */
2954
{
2955
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2956
iX += pData->iColinc)
2957
{ /* scale down by dropping the LSB */
2958
*pScanline = *pDataline;
2959
*(pScanline+1) = *(pDataline+iBps);
2960
*(pScanline+2) = *(pDataline+2*iBps);
2961
*pAlphaline = *(pDataline+3*iBps);
2962
2963
pScanline += (pData->iColinc * 3);
2964
pAlphaline += pData->iColinc;
2965
pDataline += 4*iBps;
2966
}
2967
}
2968
else
2969
{
2970
if (pData->bIsRGBA16) /* 16-bit input row ? */
2971
{
2972
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2973
iX += pData->iColinc)
2974
{ /* get alpha values */
2975
iFGa16 = mng_get_uint16 (pDataline+6);
2976
iBGa16 = (mng_uint16)(*pAlphaline);
2977
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
2978
2979
if (iFGa16) /* any opacity at all ? */
2980
{ /* fully opaque or background fully transparent ? */
2981
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
2982
{ /* plain copy it */
2983
*pScanline = *pDataline;
2984
*(pScanline+1) = *(pDataline+2);
2985
*(pScanline+2) = *(pDataline+4);
2986
*pAlphaline = *(pDataline+6);
2987
}
2988
else
2989
{
2990
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
2991
{ /* get the proper values */
2992
int i;
2993
for (i=2; i >= 0; i--)
2994
{
2995
iFGg16 = mng_get_uint16 (pDataline+i+i);
2996
/* scale background up */
2997
iBGg16 = (mng_uint16)(*(pScanline+i));
2998
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
2999
/* now compose */
3000
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
3001
/* and return the composed values */
3002
*(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
3003
/* alpha remains fully opaque !!! */
3004
}
3005
}
3006
else
3007
{ /* scale background up */
3008
iBGr16 = (mng_uint16)(*pScanline );
3009
iBGg16 = (mng_uint16)(*(pScanline+1));
3010
iBGb16 = (mng_uint16)(*(pScanline+2));
3011
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3012
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3013
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3014
/* let's blend */
3015
MNG_BLEND16 (mng_get_uint16 (pDataline ),
3016
mng_get_uint16 (pDataline+2),
3017
mng_get_uint16 (pDataline+4), iFGa16,
3018
iBGr16, iBGg16, iBGb16, iBGa16,
3019
iCr16, iCg16, iCb16, iCa16);
3020
/* and return the composed values */
3021
*pScanline = (mng_uint8)(iCr16 >> 8);
3022
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
3023
*(pScanline+2) = (mng_uint8)(iCb16 >> 8);
3024
*pAlphaline = (mng_uint8)(iCa16 >> 8);
3025
}
3026
}
3027
}
3028
3029
pScanline += (pData->iColinc * 3);
3030
pAlphaline += pData->iColinc;
3031
pDataline += 8;
3032
}
3033
}
3034
else
3035
{
3036
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3037
iX += pData->iColinc)
3038
{
3039
iFGa8 = *(pDataline+3); /* get alpha values */
3040
iBGa8 = *pAlphaline;
3041
3042
if (iFGa8) /* any opacity at all ? */
3043
{ /* fully opaque or background fully transparent ? */
3044
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
3045
{ /* then simply copy the values */
3046
*pScanline = *pDataline;
3047
*(pScanline+1) = *(pDataline+1);
3048
*(pScanline+2) = *(pDataline+2);
3049
*pAlphaline = *(pDataline+3);
3050
}
3051
else
3052
{
3053
if (iBGa8 == 0xFF) /* background fully opaque ? */
3054
{ /* do alpha composing */
3055
int i;
3056
for (i=2; i >= 0; i--)
3057
{
3058
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
3059
}
3060
/* alpha remains fully opaque !!! */
3061
}
3062
else
3063
{ /* now blend */
3064
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
3065
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
3066
iCr8, iCg8, iCb8, iCa8);
3067
/* and return the composed values */
3068
*pScanline = iCr8;
3069
*(pScanline+1) = iCg8;
3070
*(pScanline+2) = iCb8;
3071
*pAlphaline = iCa8;
3072
}
3073
}
3074
}
3075
3076
pScanline += (pData->iColinc * 3);
3077
pAlphaline += pData->iColinc;
3078
pDataline += 4;
3079
}
3080
}
3081
}
3082
}
3083
3084
check_update_region (pData);
3085
3086
#ifdef MNG_SUPPORT_TRACE
3087
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
3088
#endif
3089
3090
return MNG_NOERROR;
3091
}
3092
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
3093
#else /* MNG_NO_16BIT_SUPPORT */
3094
mng_retcode mng_display_rgb8_a8 (mng_datap pData)
3095
{
3096
mng_uint8p pScanline;
3097
mng_uint8p pAlphaline;
3098
mng_uint8p pDataline;
3099
mng_int32 iX;
3100
mng_uint8 iFGa8, iBGa8, iCa8;
3101
mng_uint8 iCr8, iCg8, iCb8;
3102
3103
#ifdef MNG_SUPPORT_TRACE
3104
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
3105
#endif
3106
/* viewable row ? */
3107
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
3108
{ /* address destination rows */
3109
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
3110
pData->iRow + pData->iDestt -
3111
pData->iSourcet);
3112
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
3113
pData->iRow + pData->iDestt -
3114
pData->iSourcet);
3115
/* adjust destination rows starting-point */
3116
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
3117
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
3118
3119
pDataline = pData->pRGBArow; /* address source row */
3120
3121
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
3122
3123
if (pData->bIsOpaque) /* forget about transparency ? */
3124
{
3125
{
3126
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3127
iX += pData->iColinc)
3128
{ /* copy the values */
3129
*pScanline = *pDataline;
3130
*(pScanline+1) = *(pDataline+1);
3131
*(pScanline+2) = *(pDataline+2);
3132
*pAlphaline = *(pDataline+3);
3133
3134
pScanline += (pData->iColinc * 3);
3135
pAlphaline += pData->iColinc;
3136
pDataline += 4;
3137
}
3138
}
3139
}
3140
else
3141
{
3142
{
3143
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3144
iX += pData->iColinc)
1570
3145
{
1571
3146
iFGa8 = *(pDataline+3); /* get alpha values */
1572
3147
iBGa8 = *pAlphaline;
1627
3202
1628
3203
return MNG_NOERROR;
1629
3204
}
3205
#endif /* MNG_NO_16BIT_SUPPORT */
1630
3206
#endif /* MNG_SKIPCANVAS_RGB8_A8 */
1631
3207
1632
3208
/* ************************************************************************** */
1633
3209
1634
3210
#ifndef MNG_SKIPCANVAS_BGR8
1635
mng_retcode mng_display_bgr8 (mng_datap pData)
1636
{
1637
mng_uint8p pScanline;
1638
mng_uint8p pDataline;
1639
mng_int32 iX;
1640
3211
#ifndef MNG_NO_16BIT_SUPPORT
1641
mng_uint16 iA16;
1642
3212
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3213
mng_retcode mng_display_bgr8 (mng_datap pData)
3214
{
3215
mng_uint8p pScanline;
3216
mng_uint8p pDataline;
3217
mng_int32 iX;
3218
mng_uint16 iA16;
1643
3219
mng_uint16 iFGr16, iFGg16, iFGb16;
1644
3220
mng_uint16 iBGr16, iBGg16, iBGb16;
1645
#else
1646
mng_uint16 iFGg16;
1647
mng_uint16 iBGg16;
1648
#endif
1649
#endif
1650
3221
mng_uint8 iA8;
1651
3222
1652
3223
#ifdef MNG_SUPPORT_TRACE
1662
3233
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
1663
3234
pDataline = pData->pRGBArow; /* address source row */
1664
3235
1665
#ifndef MNG_NO_16BIT_SUPPORT
1666
3236
if (pData->bIsRGBA16) /* adjust source row starting-point */
1667
3237
pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 8;
1668
3238
else
1669
#endif
1670
3239
pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
1671
3240
1672
3241
if (pData->bIsOpaque) /* forget about transparency ? */
1673
3242
{
1674
#ifndef MNG_NO_16BIT_SUPPORT
1675
3243
if (pData->bIsRGBA16) /* 16-bit input row ? */
1676
3244
{
1677
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3245
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3246
iX += pData->iColinc)
1678
3247
{ /* scale down by dropping the LSB */
1679
3248
*pScanline = *(pDataline+4);
1680
3249
*(pScanline+1) = *(pDataline+2);
1685
3254
}
1686
3255
}
1687
3256
else
1688
#endif
1689
3257
{
1690
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3258
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3259
iX += pData->iColinc)
1691
3260
{ /* copy the values */
1692
3261
*pScanline = *(pDataline+2);
1693
3262
*(pScanline+1) = *(pDataline+1);
1700
3269
}
1701
3270
else
1702
3271
{
1703
#ifndef MNG_NO_16BIT_SUPPORT
1704
3272
if (pData->bIsRGBA16) /* 16-bit input row ? */
1705
3273
{
1706
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3274
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3275
iX += pData->iColinc)
1707
3276
{ /* get alpha value */
1708
3277
iA16 = mng_get_uint16 (pDataline+6);
1709
3278
1717
3286
}
1718
3287
else
1719
3288
{ /* get the proper values */
1720
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1721
int i;
1722
for (i=2; i >= 0; i--)
1723
{
1724
iFGg16 = mng_get_uint16 (pDataline+i+i);
1725
/* scale background up */
1726
iBGg16 = (mng_uint16)(*(pScanline+2-i));
1727
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1728
/* now compose */
1729
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
1730
/* and return the composed values */
1731
*(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
1732
}
1733
#else
1734
3289
iFGr16 = mng_get_uint16 (pDataline );
1735
3290
iFGg16 = mng_get_uint16 (pDataline+2);
1736
3291
iFGb16 = mng_get_uint16 (pDataline+4);
1749
3304
*pScanline = (mng_uint8)(iFGb16 >> 8);
1750
3305
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
1751
3306
*(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
1752
#endif
1753
}
1754
}
1755
1756
pScanline += (pData->iColinc * 3);
1757
pDataline += 8;
1758
}
1759
}
1760
else
1761
#endif
1762
{
1763
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3307
}
3308
}
3309
3310
pScanline += (pData->iColinc * 3);
3311
pDataline += 8;
3312
}
3313
}
3314
else
3315
{
3316
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3317
iX += pData->iColinc)
3318
{
3319
iA8 = *(pDataline+3); /* get alpha value */
3320
3321
if (iA8) /* any opacity at all ? */
3322
{
3323
if (iA8 == 0xFF) /* fully opaque ? */
3324
{ /* then simply copy the values */
3325
*pScanline = *(pDataline+2);
3326
*(pScanline+1) = *(pDataline+1);
3327
*(pScanline+2) = *pDataline;
3328
}
3329
else
3330
{ /* do alpha composing */
3331
MNG_COMPOSE8 (*pScanline, *(pDataline+2), iA8, *pScanline );
3332
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
3333
MNG_COMPOSE8 (*(pScanline+2), *pDataline, iA8, *(pScanline+2));
3334
}
3335
}
3336
3337
pScanline += (pData->iColinc * 3);
3338
pDataline += 4;
3339
}
3340
}
3341
}
3342
}
3343
3344
check_update_region (pData);
3345
3346
#ifdef MNG_SUPPORT_TRACE
3347
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_END);
3348
#endif
3349
3350
return MNG_NOERROR;
3351
}
3352
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
3353
mng_retcode mng_display_bgr8 (mng_datap pData)
3354
{
3355
mng_uint8p pScanline;
3356
mng_uint8p pDataline;
3357
mng_int32 iX;
3358
mng_uint16 iA16;
3359
mng_uint16 iFGg16;
3360
mng_uint16 iBGg16;
3361
mng_uint8 iA8;
3362
mng_uint8 iBps;
3363
3364
#ifdef MNG_SUPPORT_TRACE
3365
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_START);
3366
#endif
3367
3368
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
3369
/* viewable row ? */
3370
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
3371
{ /* address destination row */
3372
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
3373
pData->iRow + pData->iDestt -
3374
pData->iSourcet);
3375
/* adjust destination row starting-point */
3376
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
3377
pDataline = pData->pRGBArow; /* address source row */
3378
3379
/* adjust source row starting-point */
3380
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
3381
3382
if (pData->bIsOpaque) /* forget about transparency ? */
3383
{
3384
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3385
iX += pData->iColinc)
3386
{ /* scale down by dropping the LSB */
3387
*pScanline = *(pDataline+2*iBps);
3388
*(pScanline+1) = *(pDataline+iBps);
3389
*(pScanline+2) = *pDataline;
3390
3391
pScanline += (pData->iColinc * 3);
3392
pDataline += 4*iBps;
3393
}
3394
}
3395
else
3396
{
3397
if (pData->bIsRGBA16) /* 16-bit input row ? */
3398
{
3399
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3400
iX += pData->iColinc)
3401
{ /* get alpha value */
3402
iA16 = mng_get_uint16 (pDataline+6);
3403
3404
if (iA16) /* any opacity at all ? */
3405
{
3406
if (iA16 == 0xFFFF) /* fully opaque ? */
3407
{ /* scale down by dropping the LSB */
3408
*pScanline = *(pDataline+4);
3409
*(pScanline+1) = *(pDataline+2);
3410
*(pScanline+2) = *pDataline;
3411
}
3412
else
3413
{ /* get the proper values */
3414
int i;
3415
for (i=2; i >= 0; i--)
3416
{
3417
iFGg16 = mng_get_uint16 (pDataline+i+i);
3418
/* scale background up */
3419
iBGg16 = (mng_uint16)(*(pScanline+2-i));
3420
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3421
/* now compose */
3422
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
3423
/* and return the composed values */
3424
*(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
3425
}
3426
}
3427
}
3428
3429
pScanline += (pData->iColinc * 3);
3430
pDataline += 8;
3431
}
3432
}
3433
else
3434
{
3435
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3436
iX += pData->iColinc)
3437
{
3438
iA8 = *(pDataline+3); /* get alpha value */
3439
3440
if (iA8) /* any opacity at all ? */
3441
{
3442
if (iA8 == 0xFF) /* fully opaque ? */
3443
{ /* then simply copy the values */
3444
*pScanline = *(pDataline+2);
3445
*(pScanline+1) = *(pDataline+1);
3446
*(pScanline+2) = *pDataline;
3447
}
3448
else
3449
{ /* do alpha composing */
3450
int i;
3451
for (i=2; i >= 0; i--)
3452
{
3453
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iA8, *(pScanline+i));
3454
}
3455
}
3456
}
3457
3458
pScanline += (pData->iColinc * 3);
3459
pDataline += 4;
3460
}
3461
}
3462
}
3463
}
3464
3465
check_update_region (pData);
3466
3467
#ifdef MNG_SUPPORT_TRACE
3468
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_END);
3469
#endif
3470
3471
return MNG_NOERROR;
3472
}
3473
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
3474
#else /* MNG_NO_16BIT_SUPPORT */
3475
mng_retcode mng_display_bgr8 (mng_datap pData)
3476
{
3477
mng_uint8p pScanline;
3478
mng_uint8p pDataline;
3479
mng_int32 iX;
3480
mng_uint8 iA8;
3481
3482
#ifdef MNG_SUPPORT_TRACE
3483
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_START);
3484
#endif
3485
/* viewable row ? */
3486
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
3487
{ /* address destination row */
3488
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
3489
pData->iRow + pData->iDestt -
3490
pData->iSourcet);
3491
/* adjust destination row starting-point */
3492
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
3493
pDataline = pData->pRGBArow; /* address source row */
3494
3495
pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
3496
3497
if (pData->bIsOpaque) /* forget about transparency ? */
3498
{
3499
{
3500
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3501
iX += pData->iColinc)
3502
{ /* copy the values */
3503
*pScanline = *(pDataline+2);
3504
*(pScanline+1) = *(pDataline+1);
3505
*(pScanline+2) = *pDataline;
3506
3507
pScanline += (pData->iColinc * 3);
3508
pDataline += 4;
3509
}
3510
}
3511
}
3512
else
3513
{
3514
{
3515
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3516
iX += pData->iColinc)
1764
3517
{
1765
3518
iA8 = *(pDataline+3); /* get alpha value */
1766
3519
1803
3556
1804
3557
return MNG_NOERROR;
1805
3558
}
3559
#endif /* MNG_NO_16BIT_SUPPORT */
1806
3560
#endif /* MNG_SKIPCANVAS_BGR8 */
1807
3561
1808
3562
/* ************************************************************************** */
1809
3563
1810
3564
#ifndef MNG_SKIPCANVAS_BGRX8
1811
mng_retcode mng_display_bgrx8 (mng_datap pData)
1812
{
1813
mng_uint8p pScanline;
1814
mng_uint8p pDataline;
1815
mng_int32 iX;
1816
3565
#ifndef MNG_NO_16BIT_SUPPORT
1817
mng_uint16 iA16;
1818
3566
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3567
mng_retcode mng_display_bgrx8 (mng_datap pData)
3568
{
3569
mng_uint8p pScanline;
3570
mng_uint8p pDataline;
3571
mng_int32 iX;
3572
mng_uint16 iA16;
1819
3573
mng_uint16 iFGr16, iFGg16, iFGb16;
1820
3574
mng_uint16 iBGr16, iBGg16, iBGb16;
1821
#else
1822
mng_uint16 iFGg16;
1823
mng_uint16 iBGg16;
1824
#endif
1825
#endif
1826
3575
mng_uint8 iA8;
1827
3576
1828
3577
#ifdef MNG_SUPPORT_TRACE
1838
3587
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1839
3588
pDataline = pData->pRGBArow; /* address source row */
1840
3589
1841
#ifndef MNG_NO_16BIT_SUPPORT
1842
3590
if (pData->bIsRGBA16) /* adjust source row starting-point */
1843
3591
pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 8;
1844
3592
else
1845
#endif
1846
3593
pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
1847
3594
1848
3595
if (pData->bIsOpaque) /* forget about transparency ? */
1849
3596
{
1850
#ifndef MNG_NO_16BIT_SUPPORT
1851
3597
if (pData->bIsRGBA16) /* 16-bit input row ? */
1852
3598
{
1853
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3599
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3600
iX += pData->iColinc)
1854
3601
{ /* scale down by dropping the LSB */
1855
3602
*pScanline = *(pDataline+4);
1856
3603
*(pScanline+1) = *(pDataline+2);
1862
3609
}
1863
3610
}
1864
3611
else
1865
#endif
1866
3612
{
1867
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3613
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3614
iX += pData->iColinc)
1868
3615
{ /* copy the values */
1869
3616
*pScanline = *(pDataline+2);
1870
3617
*(pScanline+1) = *(pDataline+1);
1878
3625
}
1879
3626
else
1880
3627
{
1881
#ifndef MNG_NO_16BIT_SUPPORT
1882
3628
if (pData->bIsRGBA16) /* 16-bit input row ? */
1883
3629
{
1884
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3630
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3631
iX += pData->iColinc)
1885
3632
{ /* get alpha value */
1886
3633
iA16 = mng_get_uint16 (pDataline+6);
1887
3634
1896
3643
}
1897
3644
else
1898
3645
{ /* get the proper values */
1899
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
1900
int i;
1901
for (i=2; i >= 0; i--)
1902
{
1903
iFGg16 = mng_get_uint16 (pDataline+i+i);
1904
/* scale background up */
1905
iBGg16 = (mng_uint16)(*(pScanline+2-i));
1906
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
1907
/* now compose */
1908
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
1909
/* and return the composed values */
1910
*(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
1911
}
1912
#else
1913
3646
iFGr16 = mng_get_uint16 (pDataline );
1914
3647
iFGg16 = mng_get_uint16 (pDataline+2);
1915
3648
iFGb16 = mng_get_uint16 (pDataline+4);
1928
3661
*pScanline = (mng_uint8)(iFGb16 >> 8);
1929
3662
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
1930
3663
*(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
1931
#endif
1932
*(pScanline+3) = 0xFF; /* filler byte */
1933
}
1934
}
1935
1936
pScanline += (pData->iColinc << 2);
1937
pDataline += 8;
1938
}
1939
}
1940
else
1941
#endif
1942
{
1943
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3664
*(pScanline+3) = 0xFF; /* filler byte */
3665
}
3666
}
3667
3668
pScanline += (pData->iColinc << 2);
3669
pDataline += 8;
3670
}
3671
}
3672
else
3673
{
3674
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3675
iX += pData->iColinc)
3676
{
3677
iA8 = *(pDataline+3); /* get alpha value */
3678
3679
if (iA8) /* any opacity at all ? */
3680
{
3681
if (iA8 == 0xFF) /* fully opaque ? */
3682
{ /* then simply copy the values */
3683
*pScanline = *(pDataline+2);
3684
*(pScanline+1) = *(pDataline+1);
3685
*(pScanline+2) = *pDataline;
3686
*(pScanline+3) = 0xFF; /* filler byte */
3687
}
3688
else
3689
{ /* do alpha composing */
3690
MNG_COMPOSE8 (*pScanline, *(pDataline+2), iA8, *pScanline );
3691
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
3692
MNG_COMPOSE8 (*(pScanline+2), *pDataline, iA8, *(pScanline+2));
3693
*(pScanline+3) = 0xFF; /* filler byte */
3694
}
3695
}
3696
3697
pScanline += (pData->iColinc << 2);
3698
pDataline += 4;
3699
}
3700
}
3701
}
3702
}
3703
3704
check_update_region (pData);
3705
3706
#ifdef MNG_SUPPORT_TRACE
3707
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_END);
3708
#endif
3709
3710
return MNG_NOERROR;
3711
}
3712
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
3713
mng_retcode mng_display_bgrx8 (mng_datap pData)
3714
{
3715
mng_uint8p pScanline;
3716
mng_uint8p pDataline;
3717
mng_int32 iX;
3718
mng_uint16 iA16;
3719
mng_uint16 iFGg16;
3720
mng_uint16 iBGg16;
3721
mng_uint8 iA8;
3722
mng_uint8 iBps;
3723
3724
#ifdef MNG_SUPPORT_TRACE
3725
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_START);
3726
#endif
3727
3728
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
3729
/* viewable row ? */
3730
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
3731
{ /* address destination row */
3732
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
3733
pData->iRow + pData->iDestt -
3734
pData->iSourcet);
3735
/* adjust destination row starting-point */
3736
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
3737
pDataline = pData->pRGBArow; /* address source row */
3738
3739
/* adjust source row starting-point */
3740
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
3741
3742
if (pData->bIsOpaque) /* forget about transparency ? */
3743
{
3744
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3745
iX += pData->iColinc)
3746
{ /* scale down by dropping the LSB */
3747
*pScanline = *(pDataline+2*iBps);
3748
*(pScanline+1) = *(pDataline+iBps);
3749
*(pScanline+2) = *pDataline;
3750
*(pScanline+3) = 0xFF; /* filler byte */
3751
3752
pScanline += (pData->iColinc << 2);
3753
pDataline += 4*iBps;
3754
}
3755
}
3756
else
3757
{
3758
if (pData->bIsRGBA16) /* 16-bit input row ? */
3759
{
3760
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3761
iX += pData->iColinc)
3762
{ /* get alpha value */
3763
iA16 = mng_get_uint16 (pDataline+6);
3764
3765
if (iA16) /* any opacity at all ? */
3766
{
3767
if (iA16 == 0xFFFF) /* fully opaque ? */
3768
{ /* scale down by dropping the LSB */
3769
*pScanline = *(pDataline+4);
3770
*(pScanline+1) = *(pDataline+2);
3771
*(pScanline+2) = *pDataline;
3772
*(pScanline+3) = 0xFF; /* filler byte */
3773
}
3774
else
3775
{ /* get the proper values */
3776
int i;
3777
for (i=2; i >= 0; i--)
3778
{
3779
iFGg16 = mng_get_uint16 (pDataline+i+i);
3780
/* scale background up */
3781
iBGg16 = (mng_uint16)(*(pScanline+2-i));
3782
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3783
/* now compose */
3784
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
3785
/* and return the composed values */
3786
*(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
3787
}
3788
*(pScanline+3) = 0xFF; /* filler byte */
3789
}
3790
}
3791
3792
pScanline += (pData->iColinc << 2);
3793
pDataline += 8;
3794
}
3795
}
3796
else
3797
{
3798
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3799
iX += pData->iColinc)
3800
{
3801
iA8 = *(pDataline+3); /* get alpha value */
3802
3803
if (iA8) /* any opacity at all ? */
3804
{
3805
if (iA8 == 0xFF) /* fully opaque ? */
3806
{ /* then simply copy the values */
3807
*pScanline = *(pDataline+2);
3808
*(pScanline+1) = *(pDataline+1);
3809
*(pScanline+2) = *pDataline;
3810
*(pScanline+3) = 0xFF; /* filler byte */
3811
}
3812
else
3813
{ /* do alpha composing */
3814
int i;
3815
for (i=2; i >= 0; i--)
3816
{
3817
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iA8, *(pScanline+i));
3818
}
3819
*(pScanline+3) = 0xFF; /* filler byte */
3820
}
3821
}
3822
3823
pScanline += (pData->iColinc << 2);
3824
pDataline += 4;
3825
}
3826
}
3827
}
3828
}
3829
3830
check_update_region (pData);
3831
3832
#ifdef MNG_SUPPORT_TRACE
3833
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_END);
3834
#endif
3835
3836
return MNG_NOERROR;
3837
}
3838
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
3839
#else /* MNG_NO_16BIT_SUPPORT */
3840
mng_retcode mng_display_bgrx8 (mng_datap pData)
3841
{
3842
mng_uint8p pScanline;
3843
mng_uint8p pDataline;
3844
mng_int32 iX;
3845
mng_uint8 iA8;
3846
3847
#ifdef MNG_SUPPORT_TRACE
3848
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_START);
3849
#endif
3850
/* viewable row ? */
3851
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
3852
{ /* address destination row */
3853
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
3854
pData->iRow + pData->iDestt -
3855
pData->iSourcet);
3856
/* adjust destination row starting-point */
3857
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
3858
pDataline = pData->pRGBArow; /* address source row */
3859
3860
pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
3861
3862
if (pData->bIsOpaque) /* forget about transparency ? */
3863
{
3864
{
3865
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3866
iX += pData->iColinc)
3867
{ /* copy the values */
3868
*pScanline = *(pDataline+2);
3869
*(pScanline+1) = *(pDataline+1);
3870
*(pScanline+2) = *pDataline;
3871
*(pScanline+3) = 0xFF; /* filler byte */
3872
3873
pScanline += (pData->iColinc << 2);
3874
pDataline += 4;
3875
}
3876
}
3877
}
3878
else
3879
{
3880
{
3881
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3882
iX += pData->iColinc)
1944
3883
{
1945
3884
iA8 = *(pDataline+3); /* get alpha value */
1946
3885
1985
3924
1986
3925
return MNG_NOERROR;
1987
3926
}
3927
#endif /* MNG_NO_16BIT_SUPPORT */
1988
3928
#endif /* MNG_SKIPCANVAS_BGRX8 */
1989
3929
1990
3930
/* ************************************************************************** */
1991
3931
1992
3932
#ifndef MNG_SKIPCANVAS_BGRA8
1993
mng_retcode mng_display_bgra8 (mng_datap pData)
1994
{
1995
mng_uint8p pScanline;
1996
mng_uint8p pDataline;
1997
mng_int32 iX;
1998
mng_uint8 iFGa8, iBGa8, iCa8;
1999
3933
#ifndef MNG_NO_16BIT_SUPPORT
2000
mng_uint16 iFGa16, iBGa16, iCa16;
2001
3934
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3935
mng_retcode mng_display_bgra8 (mng_datap pData)
3936
{
3937
mng_uint8p pScanline;
3938
mng_uint8p pDataline;
3939
mng_int32 iX;
3940
mng_uint8 iFGa8, iBGa8, iCa8;
3941
mng_uint16 iFGa16, iBGa16, iCa16;
2002
3942
mng_uint16 iFGr16, iFGg16, iFGb16;
2003
#else
2004
mng_uint16 iFGg16;
2005
#endif
2006
3943
mng_uint16 iBGr16, iBGg16, iBGb16;
2007
3944
mng_uint16 iCr16, iCg16, iCb16;
2008
#endif
2009
3945
mng_uint8 iCr8, iCg8, iCb8;
2010
3946
2011
3947
#ifdef MNG_SUPPORT_TRACE
2021
3957
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2022
3958
pDataline = pData->pRGBArow; /* address source row */
2023
3959
2024
#ifndef MNG_NO_16BIT_SUPPORT
2025
3960
if (pData->bIsRGBA16) /* adjust source row starting-point */
2026
3961
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
2027
3962
else
2028
#endif
2029
3963
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2030
3964
2031
3965
if (pData->bIsOpaque) /* forget about transparency ? */
2032
3966
{
2033
#ifndef MNG_NO_16BIT_SUPPORT
2034
3967
if (pData->bIsRGBA16) /* 16-bit input row ? */
2035
3968
{
2036
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3969
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3970
iX += pData->iColinc)
2037
3971
{ /* scale down by dropping the LSB */
2038
3972
*pScanline = *(pDataline+4);
2039
3973
*(pScanline+1) = *(pDataline+2);
2045
3979
}
2046
3980
}
2047
3981
else
2048
#endif
2049
3982
{
2050
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3983
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3984
iX += pData->iColinc)
2051
3985
{ /* copy the values */
2052
3986
*pScanline = *(pDataline+2);
2053
3987
*(pScanline+1) = *(pDataline+1);
2061
3995
}
2062
3996
else
2063
3997
{
2064
#ifndef MNG_NO_16BIT_SUPPORT
2065
if (pData->bIsRGBA16) /* 16-bit input row ? */
2066
{
2067
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2068
{ /* get alpha values */
2069
iFGa16 = mng_get_uint16 (pDataline+6);
2070
iBGa16 = (mng_uint16)(*(pScanline+3));
2071
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
2072
2073
if (iFGa16) /* any opacity at all ? */
2074
{ /* fully opaque or background fully transparent ? */
2075
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
2076
{ /* plain copy it */
2077
*pScanline = *(pDataline+4);
2078
*(pScanline+1) = *(pDataline+2);
2079
*(pScanline+2) = *pDataline;
2080
*(pScanline+3) = *(pDataline+6);
2081
}
2082
else
2083
{
2084
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
2085
{ /* get the proper values */
2086
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3998
if (pData->bIsRGBA16) /* 16-bit input row ? */
3999
{
4000
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4001
iX += pData->iColinc)
4002
{ /* get alpha values */
4003
iFGa16 = mng_get_uint16 (pDataline+6);
4004
iBGa16 = (mng_uint16)(*(pScanline+3));
4005
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
4006
4007
if (iFGa16) /* any opacity at all ? */
4008
{ /* fully opaque or background fully transparent ? */
4009
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
4010
{ /* plain copy it */
4011
*pScanline = *(pDataline+4);
4012
*(pScanline+1) = *(pDataline+2);
4013
*(pScanline+2) = *pDataline;
4014
*(pScanline+3) = *(pDataline+6);
4015
}
4016
else
4017
{
4018
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
4019
{ /* get the proper values */
4020
iFGr16 = mng_get_uint16 (pDataline );
4021
iFGg16 = mng_get_uint16 (pDataline+2);
4022
iFGb16 = mng_get_uint16 (pDataline+4);
4023
/* scale background up */
4024
iBGr16 = (mng_uint16)(*(pScanline+2));
4025
iBGg16 = (mng_uint16)(*(pScanline+1));
4026
iBGb16 = (mng_uint16)(*pScanline );
4027
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
4028
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
4029
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
4030
/* now compose */
4031
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
4032
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
4033
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
4034
/* and return the composed values */
4035
*pScanline = (mng_uint8)(iFGb16 >> 8);
4036
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
4037
*(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
4038
/* alpha remains fully opaque !!! */
4039
}
4040
else
4041
{ /* scale background up */
4042
iBGr16 = (mng_uint16)(*(pScanline+2));
4043
iBGg16 = (mng_uint16)(*(pScanline+1));
4044
iBGb16 = (mng_uint16)(*pScanline );
4045
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
4046
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
4047
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
4048
/* let's blend */
4049
MNG_BLEND16 (mng_get_uint16 (pDataline ),
4050
mng_get_uint16 (pDataline+2),
4051
mng_get_uint16 (pDataline+4), iFGa16,
4052
iBGr16, iBGg16, iBGb16, iBGa16,
4053
iCr16, iCg16, iCb16, iCa16);
4054
/* and return the composed values */
4055
*pScanline = (mng_uint8)(iCb16 >> 8);
4056
*(pScanline+1) = (mng_uint8)(iCg16 >> 8);
4057
*(pScanline+2) = (mng_uint8)(iCr16 >> 8);
4058
*(pScanline+3) = (mng_uint8)(iCa16 >> 8);
4059
}
4060
}
4061
}
4062
4063
pScanline += (pData->iColinc << 2);
4064
pDataline += 8;
4065
}
4066
}
4067
else
4068
{
4069
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4070
iX += pData->iColinc)
4071
{
4072
iFGa8 = *(pDataline+3); /* get alpha values */
4073
iBGa8 = *(pScanline+3);
4074
4075
if (iFGa8) /* any opacity at all ? */
4076
{ /* fully opaque or background fully transparent ? */
4077
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
4078
{ /* then simply copy the values */
4079
*pScanline = *(pDataline+2);
4080
*(pScanline+1) = *(pDataline+1);
4081
*(pScanline+2) = *pDataline;
4082
*(pScanline+3) = *(pDataline+3);
4083
}
4084
else
4085
{
4086
if (iBGa8 == 0xFF) /* background fully opaque ? */
4087
{ /* do alpha composing */
4088
MNG_COMPOSE8 (*pScanline, *(pDataline+2), iFGa8, *pScanline );
4089
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
4090
MNG_COMPOSE8 (*(pScanline+2), *pDataline, iFGa8, *(pScanline+2));
4091
/* alpha remains fully opaque !!! */
4092
}
4093
else
4094
{ /* now blend */
4095
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
4096
*(pScanline+2), *(pScanline+1), *pScanline, iBGa8,
4097
iCr8, iCg8, iCb8, iCa8);
4098
/* and return the composed values */
4099
*pScanline = iCb8;
4100
*(pScanline+1) = iCg8;
4101
*(pScanline+2) = iCr8;
4102
*(pScanline+3) = iCa8;
4103
}
4104
}
4105
}
4106
4107
pScanline += (pData->iColinc << 2);
4108
pDataline += 4;
4109
}
4110
}
4111
}
4112
}
4113
4114
check_update_region (pData);
4115
4116
#ifdef MNG_SUPPORT_TRACE
4117
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_END);
4118
#endif
4119
4120
return MNG_NOERROR;
4121
}
4122
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
4123
mng_retcode mng_display_bgra8 (mng_datap pData)
4124
{
4125
mng_uint8p pScanline;
4126
mng_uint8p pDataline;
4127
mng_int32 iX;
4128
mng_uint8 iFGa8, iBGa8, iCa8;
4129
mng_uint16 iFGa16, iBGa16, iCa16;
4130
mng_uint16 iFGg16;
4131
mng_uint16 iBGr16, iBGg16, iBGb16;
4132
mng_uint16 iCr16, iCg16, iCb16;
4133
mng_uint8 iCr8, iCg8, iCb8;
4134
mng_uint8 iBps;
4135
4136
#ifdef MNG_SUPPORT_TRACE
4137
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_START);
4138
#endif
4139
4140
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
4141
/* viewable row ? */
4142
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
4143
{ /* address destination row */
4144
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
4145
pData->iRow + pData->iDestt -
4146
pData->iSourcet);
4147
/* adjust destination row starting-point */
4148
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
4149
pDataline = pData->pRGBArow; /* address source row */
4150
4151
/* adjust source row starting-point */
4152
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
4153
4154
if (pData->bIsOpaque) /* forget about transparency ? */
4155
{
4156
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4157
iX += pData->iColinc)
4158
{ /* scale down by dropping the LSB */
4159
*pScanline = *(pDataline+2*iBps);
4160
*(pScanline+1) = *(pDataline+iBps);
4161
*(pScanline+2) = *pDataline;
4162
*(pScanline+3) = *(pDataline+3*iBps);
4163
4164
pScanline += (pData->iColinc << 2);
4165
pDataline += 4*iBps;
4166
}
4167
}
4168
else
4169
{
4170
if (pData->bIsRGBA16) /* 16-bit input row ? */
4171
{
4172
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4173
iX += pData->iColinc)
4174
{ /* get alpha values */
4175
iFGa16 = mng_get_uint16 (pDataline+6);
4176
iBGa16 = (mng_uint16)(*(pScanline+3));
4177
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
4178
4179
if (iFGa16) /* any opacity at all ? */
4180
{ /* fully opaque or background fully transparent ? */
4181
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
4182
{ /* plain copy it */
4183
*pScanline = *(pDataline+4);
4184
*(pScanline+1) = *(pDataline+2);
4185
*(pScanline+2) = *pDataline;
4186
*(pScanline+3) = *(pDataline+6);
4187
}
4188
else
4189
{
4190
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
4191
{ /* get the proper values */
2087
4192
int i;
2088
4193
for (i=2; i >= 0; i--)
2089
4194
{
2097
4202
*(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
2098
4203
/* alpha remains fully opaque !!! */
2099
4204
}
2100
#else
2101
iFGr16 = mng_get_uint16 (pDataline );
2102
iFGg16 = mng_get_uint16 (pDataline+2);
2103
iFGb16 = mng_get_uint16 (pDataline+4);
2104
/* scale background up */
2105
iBGr16 = (mng_uint16)(*(pScanline+2));
2106
iBGg16 = (mng_uint16)(*(pScanline+1));
2107
iBGb16 = (mng_uint16)(*pScanline );
2108
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
2109
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
2110
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
2111
/* now compose */
2112
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
2113
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
2114
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
2115
/* and return the composed values */
2116
*pScanline = (mng_uint8)(iFGb16 >> 8);
2117
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
2118
*(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
2119
/* alpha remains fully opaque !!! */
2120
#endif
2121
4205
}
2122
4206
else
2123
4207
{ /* scale background up */
2147
4231
}
2148
4232
}
2149
4233
else
2150
#endif
2151
{
2152
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
4234
{
4235
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4236
iX += pData->iColinc)
4237
{
4238
iFGa8 = *(pDataline+3); /* get alpha values */
4239
iBGa8 = *(pScanline+3);
4240
4241
if (iFGa8) /* any opacity at all ? */
4242
{ /* fully opaque or background fully transparent ? */
4243
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
4244
{ /* then simply copy the values */
4245
*pScanline = *(pDataline+2);
4246
*(pScanline+1) = *(pDataline+1);
4247
*(pScanline+2) = *pDataline;
4248
*(pScanline+3) = *(pDataline+3);
4249
}
4250
else
4251
{
4252
if (iBGa8 == 0xFF) /* background fully opaque ? */
4253
{ /* do alpha composing */
4254
int i;
4255
for (i=2; i >= 0; i--)
4256
{
4257
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iFGa8, *(pScanline+i));
4258
}
4259
/* alpha remains fully opaque !!! */
4260
}
4261
else
4262
{ /* now blend */
4263
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
4264
*(pScanline+2), *(pScanline+1), *pScanline, iBGa8,
4265
iCr8, iCg8, iCb8, iCa8);
4266
/* and return the composed values */
4267
*pScanline = iCb8;
4268
*(pScanline+1) = iCg8;
4269
*(pScanline+2) = iCr8;
4270
*(pScanline+3) = iCa8;
4271
}
4272
}
4273
}
4274
4275
pScanline += (pData->iColinc << 2);
4276
pDataline += 4;
4277
}
4278
}
4279
}
4280
}
4281
4282
check_update_region (pData);
4283
4284
#ifdef MNG_SUPPORT_TRACE
4285
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_END);
4286
#endif
4287
4288
return MNG_NOERROR;
4289
}
4290
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
4291
#else /* MNG_NO_16BIT_SUPPORT */
4292
mng_retcode mng_display_bgra8 (mng_datap pData)
4293
{
4294
mng_uint8p pScanline;
4295
mng_uint8p pDataline;
4296
mng_int32 iX;
4297
mng_uint8 iFGa8, iBGa8, iCa8;
4298
mng_uint8 iCr8, iCg8, iCb8;
4299
4300
#ifdef MNG_SUPPORT_TRACE
4301
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_START);
4302
#endif
4303
/* viewable row ? */
4304
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
4305
{ /* address destination row */
4306
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
4307
pData->iRow + pData->iDestt -
4308
pData->iSourcet);
4309
/* adjust destination row starting-point */
4310
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
4311
pDataline = pData->pRGBArow; /* address source row */
4312
4313
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
4314
4315
if (pData->bIsOpaque) /* forget about transparency ? */
4316
{
4317
{
4318
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4319
iX += pData->iColinc)
4320
{ /* copy the values */
4321
*pScanline = *(pDataline+2);
4322
*(pScanline+1) = *(pDataline+1);
4323
*(pScanline+2) = *pDataline;
4324
*(pScanline+3) = *(pDataline+3);
4325
4326
pScanline += (pData->iColinc << 2);
4327
pDataline += 4;
4328
}
4329
}
4330
}
4331
else
4332
{
4333
{
4334
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4335
iX += pData->iColinc)
2153
4336
{
2154
4337
iFGa8 = *(pDataline+3); /* get alpha values */
2155
4338
iBGa8 = *(pScanline+3);
2209
4392
2210
4393
return MNG_NOERROR;
2211
4394
}
4395
#endif /* MNG_NO_16BIT_SUPPORT */
2212
4396
#endif /* MNG_SKIPCANVAS_BGRA8 */
2213
4397
2214
4398
/* ************************************************************************** */
2215
4399
2216
4400
#ifndef MNG_SKIPCANVAS_BGRA8_PM
4401
#ifndef MNG_NO_16BIT_SUPPORT
4402
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
2217
4403
mng_retcode mng_display_bgra8_pm (mng_datap pData)
2218
4404
{
2219
4405
mng_uint8p pScanline;
2234
4420
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2235
4421
pDataline = pData->pRGBArow; /* address source row */
2236
4422
2237
#ifndef MNG_NO_16BIT_SUPPORT
2238
4423
if (pData->bIsRGBA16) /* adjust source row starting-point */
2239
4424
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
2240
4425
else
2241
#endif
2242
4426
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2243
4427
2244
4428
if (pData->bIsOpaque) /* forget about transparency ? */
2245
4429
{
2246
#ifndef MNG_NO_16BIT_SUPPORT
2247
if (pData->bIsRGBA16) /* 16-bit input row ? */
2248
{
2249
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
4430
if (pData->bIsRGBA16) /* 16-bit input row ? */
4431
{
4432
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4433
iX += pData->iColinc)
4434
{ /* scale down by dropping the LSB */
4435
if ((s = pDataline[6]) == 0)
4436
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
4437
else
4438
{
4439
if (s == 255)
4440
{
4441
pScanline[0] = pDataline[4];
4442
pScanline[1] = pDataline[2];
4443
pScanline[2] = pDataline[0];
4444
pScanline[3] = 255;
4445
}
4446
else
4447
{
4448
pScanline[0] = DIV255B8(s * pDataline[4]);
4449
pScanline[1] = DIV255B8(s * pDataline[2]);
4450
pScanline[2] = DIV255B8(s * pDataline[0]);
4451
pScanline[3] = (mng_uint8)s;
4452
}
4453
}
4454
pScanline += (pData->iColinc << 2);
4455
pDataline += 8;
4456
}
4457
}
4458
else
4459
{
4460
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4461
iX += pData->iColinc)
4462
{ /* copy the values and premultiply */
4463
if ((s = pDataline[3]) == 0)
4464
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
4465
else
4466
{
4467
if (s == 255)
4468
{
4469
pScanline[0] = pDataline[2];
4470
pScanline[1] = pDataline[1];
4471
pScanline[2] = pDataline[0];
4472
pScanline[3] = 255;
4473
}
4474
else
4475
{
4476
pScanline[0] = DIV255B8(s * pDataline[2]);
4477
pScanline[1] = DIV255B8(s * pDataline[1]);
4478
pScanline[2] = DIV255B8(s * pDataline[0]);
4479
pScanline[3] = (mng_uint8)s;
4480
}
4481
}
4482
4483
pScanline += (pData->iColinc << 2);
4484
pDataline += 4;
4485
}
4486
}
4487
}
4488
else
4489
{
4490
if (pData->bIsRGBA16) /* 16-bit input row ? */
4491
{
4492
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4493
iX += pData->iColinc)
4494
{ /* get alpha values */
4495
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
4496
{ /* fully opaque or background fully transparent ? */
4497
if (s == 255)
4498
{ /* plain copy it */
4499
pScanline[0] = pDataline[4];
4500
pScanline[1] = pDataline[2];
4501
pScanline[2] = pDataline[0];
4502
pScanline[3] = 255;
4503
}
4504
else
4505
{ /* now blend (premultiplied) */
4506
t = 255 - s;
4507
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
4508
{
4509
int i;
4510
for (i=2; i >= 0; i--)
4511
{
4512
pScanline[i] = DIV255B8(s * pDataline[4-i-i] + t *
4513
pScanline[i]);
4514
}
4515
}
4516
#else
4517
pScanline[0] = DIV255B8(s * pDataline[4] + t * pScanline[0]);
4518
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
4519
pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
4520
#endif
4521
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
4522
}
4523
}
4524
4525
pScanline += (pData->iColinc << 2);
4526
pDataline += 8;
4527
}
4528
}
4529
else
4530
{
4531
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4532
iX += pData->iColinc)
4533
{
4534
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
4535
{ /* fully opaque ? */
4536
if (s == 255)
4537
{ /* then simply copy the values */
4538
pScanline[0] = pDataline[2];
4539
pScanline[1] = pDataline[1];
4540
pScanline[2] = pDataline[0];
4541
pScanline[3] = 255;
4542
}
4543
else
4544
{ /* now blend (premultiplied) */
4545
t = 255 - s;
4546
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
4547
{
4548
int i;
4549
for (i=2; i >= 0; i--)
4550
{
4551
pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
4552
pScanline[i]);
4553
}
4554
}
4555
#else
4556
pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
4557
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
4558
pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
4559
#endif
4560
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
4561
}
4562
}
4563
4564
pScanline += (pData->iColinc << 2);
4565
pDataline += 4;
4566
}
4567
}
4568
}
4569
}
4570
4571
check_update_region (pData);
4572
4573
#ifdef MNG_SUPPORT_TRACE
4574
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
4575
#endif
4576
4577
return MNG_NOERROR;
4578
}
4579
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
4580
mng_retcode mng_display_bgra8_pm (mng_datap pData)
4581
{
4582
mng_uint8p pScanline;
4583
mng_uint8p pDataline;
4584
mng_int32 iX;
4585
mng_uint32 s, t;
4586
mng_uint8 iBps;
4587
4588
#ifdef MNG_SUPPORT_TRACE
4589
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_START);
4590
#endif
4591
4592
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
4593
/* viewable row ? */
4594
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
4595
{ /* address destination row */
4596
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
4597
pData->iRow + pData->iDestt -
4598
pData->iSourcet);
4599
/* adjust destination row starting-point */
4600
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
4601
pDataline = pData->pRGBArow; /* address source row */
4602
4603
/* adjust source row starting-point */
4604
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
4605
4606
if (pData->bIsOpaque) /* forget about transparency ? */
4607
{
4608
if (pData->bIsRGBA16) /* 16-bit input row ? */
4609
{
4610
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4611
iX += pData->iColinc)
2250
4612
{ /* scale down by dropping the LSB */
2251
4613
if ((s = pDataline[6]) == 0)
2252
4614
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2271
4633
pScanline[0] = DIV255B8(s * pDataline[4]);
2272
4634
pScanline[1] = DIV255B8(s * pDataline[2]);
2273
4635
pScanline[2] = DIV255B8(s * pDataline[0]);
2274
#endif
4636
#endif
2275
4637
pScanline[3] = (mng_uint8)s;
2276
4638
}
2277
4639
}
2280
4642
}
2281
4643
}
2282
4644
else
2283
#endif
2284
4645
{
2285
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
4646
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4647
iX += pData->iColinc)
2286
4648
{ /* copy the values and premultiply */
2287
4649
if ((s = pDataline[3]) == 0)
2288
4650
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2319
4681
}
2320
4682
else
2321
4683
{
2322
#ifndef MNG_NO_16BIT_SUPPORT
2323
4684
if (pData->bIsRGBA16) /* 16-bit input row ? */
2324
4685
{
2325
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
4686
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4687
iX += pData->iColinc)
2326
4688
{ /* get alpha values */
2327
4689
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
2328
4690
{ /* fully opaque or background fully transparent ? */
2359
4721
}
2360
4722
}
2361
4723
else
2362
#endif
2363
{
2364
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2365
{
2366
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2367
{ /* fully opaque ? */
2368
if (s == 255)
2369
{ /* then simply copy the values */
2370
pScanline[0] = pDataline[2];
2371
pScanline[1] = pDataline[1];
2372
pScanline[2] = pDataline[0];
2373
pScanline[3] = 255;
2374
}
2375
else
2376
{ /* now blend (premultiplied) */
2377
t = 255 - s;
2378
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2379
{
2380
int i;
2381
for (i=2; i >= 0; i--)
2382
{
2383
pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
2384
pScanline[i]);
2385
}
2386
}
2387
#else
2388
pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
2389
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
2390
pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
2391
#endif
2392
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
2393
}
2394
}
2395
2396
pScanline += (pData->iColinc << 2);
2397
pDataline += 4;
2398
}
2399
}
2400
}
2401
}
2402
2403
check_update_region (pData);
2404
2405
#ifdef MNG_SUPPORT_TRACE
2406
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
2407
#endif
2408
2409
return MNG_NOERROR;
2410
}
4724
{
4725
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4726
iX += pData->iColinc)
4727
{
4728
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
4729
{ /* fully opaque ? */
4730
if (s == 255)
4731
{ /* then simply copy the values */
4732
pScanline[0] = pDataline[2];
4733
pScanline[1] = pDataline[1];
4734
pScanline[2] = pDataline[0];
4735
pScanline[3] = 255;
4736
}
4737
else
4738
{ /* now blend (premultiplied) */
4739
t = 255 - s;
4740
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
4741
{
4742
int i;
4743
for (i=2; i >= 0; i--)
4744
{
4745
pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
4746
pScanline[i]);
4747
}
4748
}
4749
#else
4750
pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
4751
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
4752
pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
4753
#endif
4754
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
4755
}
4756
}
4757
4758
pScanline += (pData->iColinc << 2);
4759
pDataline += 4;
4760
}
4761
}
4762
}
4763
}
4764
4765
check_update_region (pData);
4766
4767
#ifdef MNG_SUPPORT_TRACE
4768
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
4769
#endif
4770
4771
return MNG_NOERROR;
4772
}
4773
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
4774
#else /* MNG_NO_16BIT_SUPPORT */
4775
mng_retcode mng_display_bgra8_pm (mng_datap pData)
4776
{
4777
mng_uint8p pScanline;
4778
mng_uint8p pDataline;
4779
mng_int32 iX;
4780
mng_uint32 s, t;
4781
4782
#ifdef MNG_SUPPORT_TRACE
4783
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_START);
4784
#endif
4785
/* viewable row ? */
4786
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
4787
{ /* address destination row */
4788
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
4789
pData->iRow + pData->iDestt -
4790
pData->iSourcet);
4791
/* adjust destination row starting-point */
4792
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
4793
pDataline = pData->pRGBArow; /* address source row */
4794
4795
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
4796
4797
if (pData->bIsOpaque) /* forget about transparency ? */
4798
{
4799
{
4800
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4801
iX += pData->iColinc)
4802
{ /* copy the values and premultiply */
4803
if ((s = pDataline[3]) == 0)
4804
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
4805
else
4806
{
4807
if (s == 255)
4808
{
4809
pScanline[0] = pDataline[2];
4810
pScanline[1] = pDataline[1];
4811
pScanline[2] = pDataline[0];
4812
pScanline[3] = 255;
4813
}
4814
else
4815
{
4816
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
4817
int i;
4818
for (i=2; i >= 0; i--)
4819
{
4820
pScanline[i] = DIV255B8(s * pDataline[2-i]);
4821
}
4822
#else
4823
pScanline[0] = DIV255B8(s * pDataline[2]);
4824
pScanline[1] = DIV255B8(s * pDataline[1]);
4825
pScanline[2] = DIV255B8(s * pDataline[0]);
4826
#endif
4827
pScanline[3] = (mng_uint8)s;
4828
}
4829
}
4830
4831
pScanline += (pData->iColinc << 2);
4832
pDataline += 4;
4833
}
4834
}
4835
}
4836
else
4837
{
4838
{
4839
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4840
iX += pData->iColinc)
4841
{
4842
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
4843
{ /* fully opaque ? */
4844
if (s == 255)
4845
{ /* then simply copy the values */
4846
pScanline[0] = pDataline[2];
4847
pScanline[1] = pDataline[1];
4848
pScanline[2] = pDataline[0];
4849
pScanline[3] = 255;
4850
}
4851
else
4852
{ /* now blend (premultiplied) */
4853
t = 255 - s;
4854
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
4855
{
4856
int i;
4857
for (i=2; i >= 0; i--)
4858
{
4859
pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
4860
pScanline[i]);
4861
}
4862
}
4863
#else
4864
pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
4865
pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
4866
pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
4867
#endif
4868
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
4869
}
4870
}
4871
4872
pScanline += (pData->iColinc << 2);
4873
pDataline += 4;
4874
}
4875
}
4876
}
4877
}
4878
4879
check_update_region (pData);
4880
4881
#ifdef MNG_SUPPORT_TRACE
4882
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
4883
#endif
4884
4885
return MNG_NOERROR;
4886
}
4887
#endif /* MNG_NO_16BIT_SUPPORT */
2411
4888
#endif /* MNG_SKIPCANVAS_BGRA8_PM */
2412
4889
2413
4890
/* ************************************************************************** */
2414
4891
2415
4892
#ifndef MNG_SKIPCANVAS_ABGR8
4893
#ifndef MNG_NO_16BIT_SUPPORT
4894
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
2416
4895
mng_retcode mng_display_abgr8 (mng_datap pData)
2417
4896
{
2418
4897
mng_uint8p pScanline;
2419
4898
mng_uint8p pDataline;
2420
4899
mng_int32 iX;
2421
4900
mng_uint8 iFGa8, iBGa8, iCa8;
2422
#ifndef MNG_NO_16BIT_SUPPORT
2423
4901
mng_uint16 iFGa16, iBGa16, iCa16;
2424
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
2425
4902
mng_uint16 iFGr16, iFGg16, iFGb16;
2426
#else
2427
mng_uint16 iFGg16;
2428
#endif
2429
4903
mng_uint16 iBGr16, iBGg16, iBGb16;
2430
4904
mng_uint16 iCr16, iCg16, iCb16;
2431
#endif
2432
4905
mng_uint8 iCr8, iCg8, iCb8;
2433
4906
2434
4907
#ifdef MNG_SUPPORT_TRACE
2444
4917
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2445
4918
pDataline = pData->pRGBArow; /* address source row */
2446
4919
2447
#ifndef MNG_NO_16BIT_SUPPORT
2448
4920
if (pData->bIsRGBA16) /* adjust source row starting-point */
2449
4921
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
2450
4922
else
2451
#endif
2452
4923
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2453
4924
2454
4925
if (pData->bIsOpaque) /* forget about transparency ? */
2455
4926
{
2456
#ifndef MNG_NO_16BIT_SUPPORT
2457
4927
if (pData->bIsRGBA16) /* 16-bit input row ? */
2458
4928
{
2459
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
4929
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4930
iX += pData->iColinc)
2460
4931
{ /* scale down by dropping the LSB */
2461
4932
*pScanline = *(pDataline+6);
2462
4933
*(pScanline+1) = *(pDataline+4);
2468
4939
}
2469
4940
}
2470
4941
else
2471
#endif
2472
4942
{
2473
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
4943
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4944
iX += pData->iColinc)
2474
4945
{ /* copy the values */
2475
4946
*pScanline = *(pDataline+3);
2476
4947
*(pScanline+1) = *(pDataline+2);
2484
4955
}
2485
4956
else
2486
4957
{
2487
#ifndef MNG_NO_16BIT_SUPPORT
2488
if (pData->bIsRGBA16) /* 16-bit input row ? */
2489
{
2490
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2491
{ /* get alpha values */
2492
iFGa16 = mng_get_uint16 (pDataline+6);
2493
iBGa16 = (mng_uint16)(*pScanline);
2494
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
2495
2496
if (iFGa16) /* any opacity at all ? */
2497
{ /* fully opaque or background fully transparent ? */
2498
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
2499
{ /* plain copy it */
2500
*pScanline = *(pDataline+6);
2501
*(pScanline+1) = *(pDataline+4);
2502
*(pScanline+2) = *(pDataline+2);
2503
*(pScanline+3) = *pDataline;
2504
}
2505
else
2506
{
2507
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
2508
{ /* get the proper values */
2509
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
4958
if (pData->bIsRGBA16) /* 16-bit input row ? */
4959
{
4960
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
4961
iX += pData->iColinc)
4962
{ /* get alpha values */
4963
iFGa16 = mng_get_uint16 (pDataline+6);
4964
iBGa16 = (mng_uint16)(*pScanline);
4965
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
4966
4967
if (iFGa16) /* any opacity at all ? */
4968
{ /* fully opaque or background fully transparent ? */
4969
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
4970
{ /* plain copy it */
4971
*pScanline = *(pDataline+6);
4972
*(pScanline+1) = *(pDataline+4);
4973
*(pScanline+2) = *(pDataline+2);
4974
*(pScanline+3) = *pDataline;
4975
}
4976
else
4977
{
4978
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
4979
{ /* get the proper values */
4980
iFGr16 = mng_get_uint16 (pDataline );
4981
iFGg16 = mng_get_uint16 (pDataline+2);
4982
iFGb16 = mng_get_uint16 (pDataline+4);
4983
/* scale background up */
4984
iBGr16 = (mng_uint16)(*(pScanline+3));
4985
iBGg16 = (mng_uint16)(*(pScanline+2));
4986
iBGb16 = (mng_uint16)(*(pScanline+1));
4987
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
4988
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
4989
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
4990
/* now compose */
4991
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
4992
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
4993
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
4994
/* and return the composed values */
4995
/* alpha itself remains fully opaque !!! */
4996
*(pScanline+1) = (mng_uint8)(iFGb16 >> 8);
4997
*(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
4998
*(pScanline+3) = (mng_uint8)(iFGr16 >> 8);
4999
}
5000
else
5001
{ /* scale background up */
5002
iBGr16 = (mng_uint16)(*(pScanline+3));
5003
iBGg16 = (mng_uint16)(*(pScanline+2));
5004
iBGb16 = (mng_uint16)(*(pScanline+1));
5005
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
5006
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
5007
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
5008
/* let's blend */
5009
MNG_BLEND16 (mng_get_uint16 (pDataline ),
5010
mng_get_uint16 (pDataline+2),
5011
mng_get_uint16 (pDataline+4), iFGa16,
5012
iBGr16, iBGg16, iBGb16, iBGa16,
5013
iCr16, iCg16, iCb16, iCa16);
5014
/* and return the composed values */
5015
*pScanline = (mng_uint8)(iCa16 >> 8);
5016
*(pScanline+1) = (mng_uint8)(iCb16 >> 8);
5017
*(pScanline+2) = (mng_uint8)(iCg16 >> 8);
5018
*(pScanline+3) = (mng_uint8)(iCr16 >> 8);
5019
}
5020
}
5021
}
5022
5023
pScanline += (pData->iColinc << 2);
5024
pDataline += 8;
5025
}
5026
}
5027
else
5028
{
5029
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5030
iX += pData->iColinc)
5031
{
5032
iFGa8 = *(pDataline+3); /* get alpha values */
5033
iBGa8 = *pScanline;
5034
5035
if (iFGa8) /* any opacity at all ? */
5036
{ /* fully opaque or background fully transparent ? */
5037
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
5038
{ /* then simply copy the values */
5039
*pScanline = *(pDataline+3);
5040
*(pScanline+1) = *(pDataline+2);
5041
*(pScanline+2) = *(pDataline+1);
5042
*(pScanline+3) = *pDataline;
5043
}
5044
else
5045
{
5046
if (iBGa8 == 0xFF) /* background fully opaque ? */
5047
{ /* do simple alpha composing */
5048
/* alpha itself remains fully opaque !!! */
5049
MNG_COMPOSE8 (*(pScanline+1), *(pDataline+2), iFGa8, *(pScanline+1));
5050
MNG_COMPOSE8 (*(pScanline+2), *(pDataline+1), iFGa8, *(pScanline+2));
5051
MNG_COMPOSE8 (*(pScanline+3), *pDataline, iFGa8, *(pScanline+3));
5052
}
5053
else
5054
{ /* now blend */
5055
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
5056
*(pScanline+3), *(pScanline+2), *(pScanline+1), iBGa8,
5057
iCr8, iCg8, iCb8, iCa8);
5058
/* and return the composed values */
5059
*pScanline = iCa8;
5060
*(pScanline+1) = iCb8;
5061
*(pScanline+2) = iCg8;
5062
*(pScanline+3) = iCr8;
5063
}
5064
}
5065
}
5066
5067
pScanline += (pData->iColinc << 2);
5068
pDataline += 4;
5069
}
5070
}
5071
}
5072
}
5073
5074
check_update_region (pData);
5075
5076
#ifdef MNG_SUPPORT_TRACE
5077
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_END);
5078
#endif
5079
5080
return MNG_NOERROR;
5081
}
5082
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
5083
mng_retcode mng_display_abgr8 (mng_datap pData)
5084
{
5085
mng_uint8p pScanline;
5086
mng_uint8p pDataline;
5087
mng_int32 iX;
5088
mng_uint8 iFGa8, iBGa8, iCa8;
5089
mng_uint16 iFGa16, iBGa16, iCa16;
5090
mng_uint16 iFGg16;
5091
mng_uint16 iBGr16, iBGg16, iBGb16;
5092
mng_uint16 iCr16, iCg16, iCb16;
5093
mng_uint8 iCr8, iCg8, iCb8;
5094
mng_uint8 iBps;
5095
5096
#ifdef MNG_SUPPORT_TRACE
5097
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_START);
5098
#endif
5099
5100
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
5101
/* viewable row ? */
5102
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
5103
{ /* address destination row */
5104
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
5105
pData->iRow + pData->iDestt -
5106
pData->iSourcet);
5107
/* adjust destination row starting-point */
5108
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
5109
pDataline = pData->pRGBArow; /* address source row */
5110
5111
/* adjust source row starting-point */
5112
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
5113
5114
if (pData->bIsOpaque) /* forget about transparency ? */
5115
{
5116
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5117
iX += pData->iColinc)
5118
{ /* scale down by dropping the LSB */
5119
*pScanline = *(pDataline+3*iBps);
5120
*(pScanline+1) = *(pDataline+2*iBps);
5121
*(pScanline+2) = *(pDataline+iBps);
5122
*(pScanline+3) = *pDataline;
5123
5124
pScanline += (pData->iColinc << 2);
5125
pDataline += 4*iBps;
5126
}
5127
}
5128
else
5129
{
5130
if (pData->bIsRGBA16) /* 16-bit input row ? */
5131
{
5132
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5133
iX += pData->iColinc)
5134
{ /* get alpha values */
5135
iFGa16 = mng_get_uint16 (pDataline+6);
5136
iBGa16 = (mng_uint16)(*pScanline);
5137
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
5138
5139
if (iFGa16) /* any opacity at all ? */
5140
{ /* fully opaque or background fully transparent ? */
5141
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
5142
{ /* plain copy it */
5143
*pScanline = *(pDataline+6);
5144
*(pScanline+1) = *(pDataline+4);
5145
*(pScanline+2) = *(pDataline+2);
5146
*(pScanline+3) = *pDataline;
5147
}
5148
else
5149
{
5150
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
5151
{ /* get the proper values */
2510
5152
int i;
2511
5153
for (i=2; i >= 0; i--)
2512
5154
{
2520
5162
/* alpha itself remains fully opaque !!! */
2521
5163
*(pScanline+3-i) = (mng_uint8)(iFGg16 >> 8);
2522
5164
}
2523
#else
2524
iFGr16 = mng_get_uint16 (pDataline );
2525
iFGg16 = mng_get_uint16 (pDataline+2);
2526
iFGb16 = mng_get_uint16 (pDataline+4);
2527
/* scale background up */
2528
iBGr16 = (mng_uint16)(*(pScanline+3));
2529
iBGg16 = (mng_uint16)(*(pScanline+2));
2530
iBGb16 = (mng_uint16)(*(pScanline+1));
2531
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
2532
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
2533
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
2534
/* now compose */
2535
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
2536
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
2537
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
2538
/* and return the composed values */
2539
/* alpha itself remains fully opaque !!! */
2540
*(pScanline+1) = (mng_uint8)(iFGb16 >> 8);
2541
*(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
2542
*(pScanline+3) = (mng_uint8)(iFGr16 >> 8);
2543
#endif
2544
5165
}
2545
5166
else
2546
5167
{ /* scale background up */
2570
5191
}
2571
5192
}
2572
5193
else
2573
#endif
2574
{
2575
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
5194
{
5195
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5196
iX += pData->iColinc)
5197
{
5198
iFGa8 = *(pDataline+3); /* get alpha values */
5199
iBGa8 = *pScanline;
5200
5201
if (iFGa8) /* any opacity at all ? */
5202
{ /* fully opaque or background fully transparent ? */
5203
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
5204
{ /* then simply copy the values */
5205
*pScanline = *(pDataline+3);
5206
*(pScanline+1) = *(pDataline+2);
5207
*(pScanline+2) = *(pDataline+1);
5208
*(pScanline+3) = *pDataline;
5209
}
5210
else
5211
{
5212
if (iBGa8 == 0xFF) /* background fully opaque ? */
5213
{ /* do simple alpha composing */
5214
/* alpha itself remains fully opaque !!! */
5215
int i;
5216
for (i=2; i >= 0; i--)
5217
{
5218
MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+2-i), iFGa8, *(pScanline+i+1));
5219
}
5220
}
5221
else
5222
{ /* now blend */
5223
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
5224
*(pScanline+3), *(pScanline+2), *(pScanline+1), iBGa8,
5225
iCr8, iCg8, iCb8, iCa8);
5226
/* and return the composed values */
5227
*pScanline = iCa8;
5228
*(pScanline+1) = iCb8;
5229
*(pScanline+2) = iCg8;
5230
*(pScanline+3) = iCr8;
5231
}
5232
}
5233
}
5234
5235
pScanline += (pData->iColinc << 2);
5236
pDataline += 4;
5237
}
5238
}
5239
}
5240
}
5241
5242
check_update_region (pData);
5243
5244
#ifdef MNG_SUPPORT_TRACE
5245
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_END);
5246
#endif
5247
5248
return MNG_NOERROR;
5249
}
5250
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
5251
#else /* MNG_NO_16BIT_SUPPORT */
5252
mng_retcode mng_display_abgr8 (mng_datap pData)
5253
{
5254
mng_uint8p pScanline;
5255
mng_uint8p pDataline;
5256
mng_int32 iX;
5257
mng_uint8 iFGa8, iBGa8, iCa8;
5258
mng_uint8 iCr8, iCg8, iCb8;
5259
5260
#ifdef MNG_SUPPORT_TRACE
5261
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_START);
5262
#endif
5263
/* viewable row ? */
5264
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
5265
{ /* address destination row */
5266
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
5267
pData->iRow + pData->iDestt -
5268
pData->iSourcet);
5269
/* adjust destination row starting-point */
5270
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
5271
pDataline = pData->pRGBArow; /* address source row */
5272
5273
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
5274
5275
if (pData->bIsOpaque) /* forget about transparency ? */
5276
{
5277
{
5278
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5279
iX += pData->iColinc)
5280
{ /* copy the values */
5281
*pScanline = *(pDataline+3);
5282
*(pScanline+1) = *(pDataline+2);
5283
*(pScanline+2) = *(pDataline+1);
5284
*(pScanline+3) = *pDataline;
5285
5286
pScanline += (pData->iColinc << 2);
5287
pDataline += 4;
5288
}
5289
}
5290
}
5291
else
5292
{
5293
{
5294
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5295
iX += pData->iColinc)
2576
5296
{
2577
5297
iFGa8 = *(pDataline+3); /* get alpha values */
2578
5298
iBGa8 = *pScanline;
2632
5352
2633
5353
return MNG_NOERROR;
2634
5354
}
5355
#endif /* MNG_NO_16BIT_SUPPORT */
2635
5356
#endif /* MNG_SKIPCANVAS_ABGR8 */
2636
5357
2637
5358
/* ************************************************************************** */
2638
5359
2639
5360
#ifndef MNG_SKIPCANVAS_ABGR8_PM
5361
#ifndef MNG_NO_16BIT_SUPPORT
5362
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
2640
5363
mng_retcode mng_display_abgr8_pm (mng_datap pData)
2641
5364
{
2642
5365
mng_uint8p pScanline;
2657
5380
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2658
5381
pDataline = pData->pRGBArow; /* address source row */
2659
5382
2660
#ifndef MNG_NO_16BIT_SUPPORT
2661
5383
if (pData->bIsRGBA16) /* adjust source row starting-point */
2662
5384
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
2663
5385
else
2664
#endif
2665
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2666
2667
if (pData->bIsOpaque) /* forget about transparency ? */
2668
{
2669
#ifndef MNG_NO_16BIT_SUPPORT
2670
if (pData->bIsRGBA16) /* 16-bit input row ? */
2671
{
2672
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2673
{ /* scale down by dropping the LSB */
2674
if ((s = pDataline[6]) == 0)
2675
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2676
else
2677
{
2678
if (s == 255)
2679
{
2680
pScanline[0] = 255;
2681
pScanline[1] = pDataline[4];
2682
pScanline[2] = pDataline[2];
2683
pScanline[3] = pDataline[0];
2684
}
2685
else
2686
{
2687
pScanline[0] = (mng_uint8)s;
2688
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2689
{
2690
int i;
2691
for (i=2; i >= 0; i--)
2692
{
2693
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
2694
}
2695
}
2696
#else
2697
pScanline[1] = DIV255B8(s * pDataline[4]);
2698
pScanline[2] = DIV255B8(s * pDataline[2]);
2699
pScanline[3] = DIV255B8(s * pDataline[0]);
2700
#endif
2701
}
2702
}
2703
pScanline += (pData->iColinc << 2);
2704
pDataline += 8;
2705
}
2706
}
2707
else
2708
#endif
2709
{
2710
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2711
{ /* copy the values and premultiply */
2712
if ((s = pDataline[3]) == 0)
2713
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
2714
else
2715
{
2716
if (s == 255)
2717
{
2718
pScanline[0] = 255;
2719
pScanline[1] = pDataline[2];
2720
pScanline[2] = pDataline[1];
2721
pScanline[3] = pDataline[0];
2722
}
2723
else
2724
{
2725
pScanline[0] = (mng_uint8)s;
2726
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2727
{
2728
int i;
2729
for (i=2; i >= 0; i--)
2730
{
2731
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
2732
}
2733
}
2734
#else
2735
pScanline[1] = DIV255B8(s * pDataline[2]);
2736
pScanline[2] = DIV255B8(s * pDataline[1]);
2737
pScanline[3] = DIV255B8(s * pDataline[0]);
2738
#endif
2739
}
2740
}
2741
2742
pScanline += (pData->iColinc << 2);
2743
pDataline += 4;
2744
}
2745
}
2746
}
2747
else
2748
{
2749
#ifndef MNG_NO_16BIT_SUPPORT
2750
if (pData->bIsRGBA16) /* 16-bit input row ? */
2751
{
2752
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2753
{ /* get alpha values */
2754
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
2755
{ /* fully opaque or background fully transparent ? */
2756
if (s == 255)
2757
{ /* plain copy it */
2758
pScanline[0] = 255;
2759
pScanline[1] = pDataline[4];
2760
pScanline[2] = pDataline[2];
2761
pScanline[3] = pDataline[0];
2762
}
2763
else
2764
{ /* now blend (premultiplied) */
2765
t = 255 - s;
2766
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2767
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2768
{
2769
int i;
2770
for (i=2; i >= 0; i--)
2771
{
2772
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
2773
pScanline[i+1]);
2774
}
2775
}
2776
#else
2777
pScanline[1] = DIV255B8(s * pDataline[4] + t * pScanline[1]);
2778
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
2779
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
2780
#endif
2781
}
2782
}
2783
2784
pScanline += (pData->iColinc << 2);
2785
pDataline += 8;
2786
}
2787
}
2788
else
2789
#endif
2790
{
2791
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2792
{
2793
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2794
{ /* fully opaque ? */
2795
if (s == 255)
2796
{ /* then simply copy the values */
2797
pScanline[0] = 255;
2798
pScanline[1] = pDataline[2];
2799
pScanline[2] = pDataline[1];
2800
pScanline[3] = pDataline[0];
2801
}
2802
else
2803
{ /* now blend (premultiplied) */
2804
t = 255 - s;
2805
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2806
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2807
{
2808
int i;
2809
for (i=2; i >= 0; i--)
2810
{
2811
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
2812
pScanline[i+1]);
2813
}
2814
}
2815
#else
2816
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
2817
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
2818
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
2819
#endif
2820
}
2821
}
2822
2823
pScanline += (pData->iColinc << 2);
2824
pDataline += 4;
2825
}
2826
}
2827
}
2828
}
2829
2830
check_update_region (pData);
2831
2832
#ifdef MNG_SUPPORT_TRACE
2833
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
2834
#endif
2835
2836
return MNG_NOERROR;
2837
}
5386
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
5387
5388
if (pData->bIsOpaque) /* forget about transparency ? */
5389
{
5390
if (pData->bIsRGBA16) /* 16-bit input row ? */
5391
{
5392
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5393
iX += pData->iColinc)
5394
{ /* scale down by dropping the LSB */
5395
if ((s = pDataline[6]) == 0)
5396
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
5397
else
5398
{
5399
if (s == 255)
5400
{
5401
pScanline[0] = 255;
5402
pScanline[1] = pDataline[4];
5403
pScanline[2] = pDataline[2];
5404
pScanline[3] = pDataline[0];
5405
}
5406
else
5407
{
5408
pScanline[0] = (mng_uint8)s;
5409
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5410
{
5411
int i;
5412
for (i=2; i >= 0; i--)
5413
{
5414
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
5415
}
5416
}
5417
#else
5418
pScanline[1] = DIV255B8(s * pDataline[4]);
5419
pScanline[2] = DIV255B8(s * pDataline[2]);
5420
pScanline[3] = DIV255B8(s * pDataline[0]);
5421
#endif
5422
}
5423
}
5424
pScanline += (pData->iColinc << 2);
5425
pDataline += 8;
5426
}
5427
}
5428
else
5429
{
5430
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5431
iX += pData->iColinc)
5432
{ /* copy the values and premultiply */
5433
if ((s = pDataline[3]) == 0)
5434
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
5435
else
5436
{
5437
if (s == 255)
5438
{
5439
pScanline[0] = 255;
5440
pScanline[1] = pDataline[2];
5441
pScanline[2] = pDataline[1];
5442
pScanline[3] = pDataline[0];
5443
}
5444
else
5445
{
5446
pScanline[0] = (mng_uint8)s;
5447
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5448
{
5449
int i;
5450
for (i=2; i >= 0; i--)
5451
{
5452
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
5453
}
5454
}
5455
#else
5456
pScanline[1] = DIV255B8(s * pDataline[2]);
5457
pScanline[2] = DIV255B8(s * pDataline[1]);
5458
pScanline[3] = DIV255B8(s * pDataline[0]);
5459
#endif
5460
}
5461
}
5462
5463
pScanline += (pData->iColinc << 2);
5464
pDataline += 4;
5465
}
5466
}
5467
}
5468
else
5469
{
5470
if (pData->bIsRGBA16) /* 16-bit input row ? */
5471
{
5472
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5473
iX += pData->iColinc)
5474
{ /* get alpha values */
5475
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
5476
{ /* fully opaque or background fully transparent ? */
5477
if (s == 255)
5478
{ /* plain copy it */
5479
pScanline[0] = 255;
5480
pScanline[1] = pDataline[4];
5481
pScanline[2] = pDataline[2];
5482
pScanline[3] = pDataline[0];
5483
}
5484
else
5485
{ /* now blend (premultiplied) */
5486
t = 255 - s;
5487
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5488
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5489
{
5490
int i;
5491
for (i=2; i >= 0; i--)
5492
{
5493
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
5494
pScanline[i+1]);
5495
}
5496
}
5497
#else
5498
pScanline[1] = DIV255B8(s * pDataline[4] + t * pScanline[1]);
5499
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
5500
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
5501
#endif
5502
}
5503
}
5504
5505
pScanline += (pData->iColinc << 2);
5506
pDataline += 8;
5507
}
5508
}
5509
else
5510
{
5511
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5512
iX += pData->iColinc)
5513
{
5514
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
5515
{ /* fully opaque ? */
5516
if (s == 255)
5517
{ /* then simply copy the values */
5518
pScanline[0] = 255;
5519
pScanline[1] = pDataline[2];
5520
pScanline[2] = pDataline[1];
5521
pScanline[3] = pDataline[0];
5522
}
5523
else
5524
{ /* now blend (premultiplied) */
5525
t = 255 - s;
5526
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5527
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5528
{
5529
int i;
5530
for (i=2; i >= 0; i--)
5531
{
5532
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
5533
pScanline[i+1]);
5534
}
5535
}
5536
#else
5537
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
5538
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
5539
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
5540
#endif
5541
}
5542
}
5543
5544
pScanline += (pData->iColinc << 2);
5545
pDataline += 4;
5546
}
5547
}
5548
}
5549
}
5550
5551
check_update_region (pData);
5552
5553
#ifdef MNG_SUPPORT_TRACE
5554
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5555
#endif
5556
5557
return MNG_NOERROR;
5558
}
5559
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
5560
mng_retcode mng_display_abgr8_pm (mng_datap pData)
5561
{
5562
mng_uint8p pScanline;
5563
mng_uint8p pDataline;
5564
mng_int32 iX;
5565
mng_uint32 s, t;
5566
mng_uint8 iBps;
5567
5568
#ifdef MNG_SUPPORT_TRACE
5569
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
5570
#endif
5571
5572
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
5573
/* viewable row ? */
5574
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
5575
{ /* address destination row */
5576
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
5577
pData->iRow + pData->iDestt -
5578
pData->iSourcet);
5579
/* adjust destination row starting-point */
5580
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
5581
pDataline = pData->pRGBArow; /* address source row */
5582
5583
/* adjust source row starting-point */
5584
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
5585
5586
if (pData->bIsOpaque) /* forget about transparency ? */
5587
{
5588
if (pData->bIsRGBA16) /* 16-bit input row ? */
5589
{
5590
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5591
iX += pData->iColinc)
5592
{ /* scale down by dropping the LSB */
5593
if ((s = pDataline[6]) == 0)
5594
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
5595
else
5596
{
5597
if (s == 255)
5598
{
5599
pScanline[0] = 255;
5600
pScanline[1] = pDataline[4];
5601
pScanline[2] = pDataline[2];
5602
pScanline[3] = pDataline[0];
5603
}
5604
else
5605
{
5606
pScanline[0] = (mng_uint8)s;
5607
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5608
{
5609
int i;
5610
for (i=2; i >= 0; i--)
5611
{
5612
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
5613
}
5614
}
5615
#else
5616
pScanline[1] = DIV255B8(s * pDataline[4]);
5617
pScanline[2] = DIV255B8(s * pDataline[2]);
5618
pScanline[3] = DIV255B8(s * pDataline[0]);
5619
#endif
5620
}
5621
}
5622
pScanline += (pData->iColinc << 2);
5623
pDataline += 8;
5624
}
5625
}
5626
else
5627
{
5628
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5629
iX += pData->iColinc)
5630
{ /* copy the values and premultiply */
5631
if ((s = pDataline[3]) == 0)
5632
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
5633
else
5634
{
5635
if (s == 255)
5636
{
5637
pScanline[0] = 255;
5638
pScanline[1] = pDataline[2];
5639
pScanline[2] = pDataline[1];
5640
pScanline[3] = pDataline[0];
5641
}
5642
else
5643
{
5644
pScanline[0] = (mng_uint8)s;
5645
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5646
{
5647
int i;
5648
for (i=2; i >= 0; i--)
5649
{
5650
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
5651
}
5652
}
5653
#else
5654
pScanline[1] = DIV255B8(s * pDataline[2]);
5655
pScanline[2] = DIV255B8(s * pDataline[1]);
5656
pScanline[3] = DIV255B8(s * pDataline[0]);
5657
#endif
5658
}
5659
}
5660
5661
pScanline += (pData->iColinc << 2);
5662
pDataline += 4;
5663
}
5664
}
5665
}
5666
else
5667
{
5668
if (pData->bIsRGBA16) /* 16-bit input row ? */
5669
{
5670
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5671
iX += pData->iColinc)
5672
{ /* get alpha values */
5673
if ((s = pDataline[6]) != 0) /* any opacity at all ? */
5674
{ /* fully opaque or background fully transparent ? */
5675
if (s == 255)
5676
{ /* plain copy it */
5677
pScanline[0] = 255;
5678
pScanline[1] = pDataline[4];
5679
pScanline[2] = pDataline[2];
5680
pScanline[3] = pDataline[0];
5681
}
5682
else
5683
{ /* now blend (premultiplied) */
5684
t = 255 - s;
5685
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5686
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5687
{
5688
int i;
5689
for (i=2; i >= 0; i--)
5690
{
5691
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
5692
pScanline[i+1]);
5693
}
5694
}
5695
#else
5696
pScanline[1] = DIV255B8(s * pDataline[4] + t * pScanline[1]);
5697
pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
5698
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
5699
#endif
5700
}
5701
}
5702
5703
pScanline += (pData->iColinc << 2);
5704
pDataline += 8;
5705
}
5706
}
5707
else
5708
{
5709
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5710
iX += pData->iColinc)
5711
{
5712
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
5713
{ /* fully opaque ? */
5714
if (s == 255)
5715
{ /* then simply copy the values */
5716
pScanline[0] = 255;
5717
pScanline[1] = pDataline[2];
5718
pScanline[2] = pDataline[1];
5719
pScanline[3] = pDataline[0];
5720
}
5721
else
5722
{ /* now blend (premultiplied) */
5723
t = 255 - s;
5724
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5725
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5726
{
5727
int i;
5728
for (i=2; i >= 0; i--)
5729
{
5730
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
5731
pScanline[i+1]);
5732
}
5733
}
5734
#else
5735
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
5736
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
5737
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
5738
#endif
5739
}
5740
}
5741
5742
pScanline += (pData->iColinc << 2);
5743
pDataline += 4;
5744
}
5745
}
5746
}
5747
}
5748
5749
check_update_region (pData);
5750
5751
#ifdef MNG_SUPPORT_TRACE
5752
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5753
#endif
5754
5755
return MNG_NOERROR;
5756
}
5757
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
5758
#else /* MNG_NO_16BIT_SUPPORT */
5759
mng_retcode mng_display_abgr8_pm (mng_datap pData)
5760
{
5761
mng_uint8p pScanline;
5762
mng_uint8p pDataline;
5763
mng_int32 iX;
5764
mng_uint32 s, t;
5765
5766
#ifdef MNG_SUPPORT_TRACE
5767
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
5768
#endif
5769
/* viewable row ? */
5770
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
5771
{ /* address destination row */
5772
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
5773
pData->iRow + pData->iDestt -
5774
pData->iSourcet);
5775
/* adjust destination row starting-point */
5776
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
5777
pDataline = pData->pRGBArow; /* address source row */
5778
5779
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
5780
5781
if (pData->bIsOpaque) /* forget about transparency ? */
5782
{
5783
{
5784
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5785
iX += pData->iColinc)
5786
{ /* copy the values and premultiply */
5787
if ((s = pDataline[3]) == 0)
5788
*(mng_uint32*) pScanline = 0; /* set all components = 0 */
5789
else
5790
{
5791
if (s == 255)
5792
{
5793
pScanline[0] = 255;
5794
pScanline[1] = pDataline[2];
5795
pScanline[2] = pDataline[1];
5796
pScanline[3] = pDataline[0];
5797
}
5798
else
5799
{
5800
pScanline[0] = (mng_uint8)s;
5801
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5802
{
5803
int i;
5804
for (i=2; i >= 0; i--)
5805
{
5806
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
5807
}
5808
}
5809
#else
5810
pScanline[1] = DIV255B8(s * pDataline[2]);
5811
pScanline[2] = DIV255B8(s * pDataline[1]);
5812
pScanline[3] = DIV255B8(s * pDataline[0]);
5813
#endif
5814
}
5815
}
5816
5817
pScanline += (pData->iColinc << 2);
5818
pDataline += 4;
5819
}
5820
}
5821
}
5822
else
5823
{
5824
{
5825
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5826
iX += pData->iColinc)
5827
{
5828
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
5829
{ /* fully opaque ? */
5830
if (s == 255)
5831
{ /* then simply copy the values */
5832
pScanline[0] = 255;
5833
pScanline[1] = pDataline[2];
5834
pScanline[2] = pDataline[1];
5835
pScanline[3] = pDataline[0];
5836
}
5837
else
5838
{ /* now blend (premultiplied) */
5839
t = 255 - s;
5840
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5841
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5842
{
5843
int i;
5844
for (i=2; i >= 0; i--)
5845
{
5846
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
5847
pScanline[i+1]);
5848
}
5849
}
5850
#else
5851
pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
5852
pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
5853
pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
5854
#endif
5855
}
5856
}
5857
5858
pScanline += (pData->iColinc << 2);
5859
pDataline += 4;
5860
}
5861
}
5862
}
5863
}
5864
5865
check_update_region (pData);
5866
5867
#ifdef MNG_SUPPORT_TRACE
5868
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5869
#endif
5870
5871
return MNG_NOERROR;
5872
}
5873
#endif /* MNG_NO_16BIT_SUPPORT */
2838
5874
#endif /* MNG_SKIPCANVAS_ABGR8_PM */
2839
5875
2840
5876
/* ************************************************************************** */
2841
5877
2842
5878
#ifndef MNG_SKIPCANVAS_BGR565
5879
#ifndef MNG_NO_16BIT_SUPPORT
5880
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
2843
5881
mng_retcode mng_display_bgr565 (mng_datap pData)
2844
5882
{
2845
5883
mng_uint8p pScanline;
2846
5884
mng_uint8p pDataline;
2847
5885
mng_int32 iX;
2848
#ifndef MNG_NO_16BIT_SUPPORT
2849
5886
mng_uint16 iA16;
2850
5887
mng_uint16 iFGr16, iFGg16, iFGb16;
2851
5888
mng_uint16 iBGr16, iBGg16, iBGb16;
2852
#endif
2853
5889
mng_uint8 iA8;
2854
5890
2855
5891
#ifdef MNG_SUPPORT_TRACE
2865
5901
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
2866
5902
pDataline = pData->pRGBArow; /* address source row */
2867
5903
2868
#ifndef MNG_NO_16BIT_SUPPORT
2869
5904
if (pData->bIsRGBA16) /* adjust source row starting-point */
2870
5905
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
2871
5906
else
2872
#endif
2873
5907
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2874
5908
2875
5909
if (pData->bIsOpaque) /* forget about transparency ? */
2876
5910
{
2877
#ifndef MNG_NO_16BIT_SUPPORT
2878
5911
if (pData->bIsRGBA16) /* 16-bit input row ? */
2879
5912
{
2880
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
5913
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5914
iX += pData->iColinc)
2881
5915
{ /* scale down by dropping the LSB */
2882
5916
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+2)>>5) ) );
2883
5917
*pScanline = (mng_uint8)( ( (*(pDataline+4)) >>3) | ( (*(pDataline+2)&0xFC) << 3) );
2887
5921
}
2888
5922
}
2889
5923
else
2890
#endif
2891
{
2892
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2893
{ /* copy the values */
2894
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
2895
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
2896
2897
2898
pScanline += (pData->iColinc * 2);
2899
pDataline += 4;
2900
}
2901
}
2902
}
2903
else
2904
{
2905
#ifndef MNG_NO_16BIT_SUPPORT
2906
if (pData->bIsRGBA16) /* 16-bit input row ? */
2907
{
2908
2909
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2910
{
2911
iA16 = mng_get_uint16 (pDataline+6);
2912
2913
if (iA16) /* any opacity at all ? */
2914
{
2915
if (iA16 == 0xFFFF) /* fully opaque ? */
2916
{ /* scale down by dropping the LSB */
2917
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
2918
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
2919
}
2920
else
2921
{ /* get the proper values */
2922
iFGr16 = mng_get_uint16 (pDataline );
2923
iFGg16 = mng_get_uint16 (pDataline+2);
2924
iFGb16 = mng_get_uint16 (pDataline+4);
2925
/* scale background up */
2926
2927
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
2928
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
2929
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
2930
2931
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
2932
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
2933
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
2934
/* now compose */
2935
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
2936
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
2937
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
2938
/* and return the composed values */
2939
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
2940
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
2941
}
2942
}
2943
2944
pScanline += (pData->iColinc * 2);
2945
pDataline += 8;
2946
}
2947
}
2948
else
2949
#endif
2950
{
2951
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2952
{
2953
iA8 = *(pDataline+3); /* get alpha value */
2954
2955
if (iA8) /* any opacity at all ? */
2956
{
2957
if (iA8 == 0xFF) /* fully opaque ? */
2958
{ /* then simply copy the values */
2959
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
2960
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
2961
}
2962
else
2963
{ /* do alpha composing */
2964
mng_uint8 iRed, iGreen, iBlue;
2965
2966
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
2967
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
2968
iBlue = (mng_uint8) ( (*pScanline << 3) );
2969
2970
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
2971
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
2972
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
2973
2974
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
2975
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
2976
}
2977
}
2978
2979
pScanline += (pData->iColinc * 2);
2980
pDataline += 4;
2981
}
2982
}
2983
}
2984
}
2985
2986
check_update_region (pData);
2987
2988
#ifdef MNG_SUPPORT_TRACE
2989
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
2990
#endif
2991
2992
return MNG_NOERROR;
2993
}
5924
{
5925
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5926
iX += pData->iColinc)
5927
{ /* copy the values */
5928
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
5929
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
5930
5931
5932
pScanline += (pData->iColinc * 2);
5933
pDataline += 4;
5934
}
5935
}
5936
}
5937
else
5938
{
5939
if (pData->bIsRGBA16) /* 16-bit input row ? */
5940
{
5941
5942
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5943
iX += pData->iColinc)
5944
{
5945
iA16 = mng_get_uint16 (pDataline+6);
5946
5947
if (iA16) /* any opacity at all ? */
5948
{
5949
if (iA16 == 0xFFFF) /* fully opaque ? */
5950
{ /* scale down by dropping the LSB */
5951
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
5952
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
5953
}
5954
else
5955
{ /* get the proper values */
5956
iFGr16 = mng_get_uint16 (pDataline );
5957
iFGg16 = mng_get_uint16 (pDataline+2);
5958
iFGb16 = mng_get_uint16 (pDataline+4);
5959
/* scale background up */
5960
5961
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
5962
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
5963
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
5964
5965
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
5966
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
5967
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
5968
/* now compose */
5969
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
5970
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
5971
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
5972
/* and return the composed values */
5973
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
5974
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
5975
}
5976
}
5977
5978
pScanline += (pData->iColinc * 2);
5979
pDataline += 8;
5980
}
5981
}
5982
else
5983
{
5984
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5985
iX += pData->iColinc)
5986
{
5987
iA8 = *(pDataline+3); /* get alpha value */
5988
5989
if (iA8) /* any opacity at all ? */
5990
{
5991
if (iA8 == 0xFF) /* fully opaque ? */
5992
{ /* then simply copy the values */
5993
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
5994
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
5995
}
5996
else
5997
{ /* do alpha composing */
5998
mng_uint8 iRed, iGreen, iBlue;
5999
6000
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6001
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6002
iBlue = (mng_uint8) ( (*pScanline << 3) );
6003
6004
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
6005
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6006
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
6007
6008
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6009
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6010
}
6011
}
6012
6013
pScanline += (pData->iColinc * 2);
6014
pDataline += 4;
6015
}
6016
}
6017
}
6018
}
6019
6020
check_update_region (pData);
6021
6022
#ifdef MNG_SUPPORT_TRACE
6023
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
6024
#endif
6025
6026
return MNG_NOERROR;
6027
}
6028
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6029
mng_retcode mng_display_bgr565 (mng_datap pData)
6030
{
6031
mng_uint8p pScanline;
6032
mng_uint8p pDataline;
6033
mng_int32 iX;
6034
mng_uint16 iA16;
6035
mng_uint16 iFGr16, iFGg16, iFGb16;
6036
mng_uint16 iBGr16, iBGg16, iBGb16;
6037
mng_uint8 iA8;
6038
mng_uint8 iBps;
6039
6040
#ifdef MNG_SUPPORT_TRACE
6041
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
6042
#endif
6043
6044
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
6045
/* viewable row ? */
6046
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
6047
{ /* address destination row */
6048
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
6049
pData->iRow + pData->iDestt -
6050
pData->iSourcet);
6051
/* adjust destination row starting-point */
6052
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6053
pDataline = pData->pRGBArow; /* address source row */
6054
6055
/* adjust source row starting-point */
6056
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
6057
6058
if (pData->bIsOpaque) /* forget about transparency ? */
6059
{
6060
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6061
iX += pData->iColinc)
6062
{ /* scale down by dropping the LSB */
6063
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) |
6064
( (*(pDataline+iBps)>>5) ) );
6065
*pScanline = (mng_uint8)( ( (*(pDataline+2*iBps)) >>3) |
6066
( (*(pDataline+iBps)&0xFC) << 3) );
6067
6068
pScanline += (pData->iColinc * 2);
6069
pDataline += 4*iBps;
6070
}
6071
}
6072
else
6073
{
6074
if (pData->bIsRGBA16) /* 16-bit input row ? */
6075
{
6076
6077
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6078
iX += pData->iColinc)
6079
{
6080
iA16 = mng_get_uint16 (pDataline+6);
6081
6082
if (iA16) /* any opacity at all ? */
6083
{
6084
if (iA16 == 0xFFFF) /* fully opaque ? */
6085
{ /* scale down by dropping the LSB */
6086
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
6087
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
6088
}
6089
else
6090
{ /* get the proper values */
6091
iFGr16 = mng_get_uint16 (pDataline );
6092
iFGg16 = mng_get_uint16 (pDataline+2);
6093
iFGb16 = mng_get_uint16 (pDataline+4);
6094
/* scale background up */
6095
6096
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
6097
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
6098
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
6099
6100
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6101
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6102
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6103
/* now compose */
6104
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
6105
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
6106
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
6107
/* and return the composed values */
6108
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
6109
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
6110
}
6111
}
6112
6113
pScanline += (pData->iColinc * 2);
6114
pDataline += 8;
6115
}
6116
}
6117
else
6118
{
6119
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6120
iX += pData->iColinc)
6121
{
6122
iA8 = *(pDataline+3); /* get alpha value */
6123
6124
if (iA8) /* any opacity at all ? */
6125
{
6126
if (iA8 == 0xFF) /* fully opaque ? */
6127
{ /* then simply copy the values */
6128
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
6129
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
6130
}
6131
else
6132
{ /* do alpha composing */
6133
mng_uint8 iRed, iGreen, iBlue;
6134
6135
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6136
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6137
iBlue = (mng_uint8) ( (*pScanline << 3) );
6138
6139
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
6140
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6141
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
6142
6143
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6144
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6145
}
6146
}
6147
6148
pScanline += (pData->iColinc * 2);
6149
pDataline += 4;
6150
}
6151
}
6152
}
6153
}
6154
6155
check_update_region (pData);
6156
6157
#ifdef MNG_SUPPORT_TRACE
6158
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
6159
#endif
6160
6161
return MNG_NOERROR;
6162
}
6163
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6164
#else /* MNG_NO_16BIT_SUPPORT */
6165
mng_retcode mng_display_bgr565 (mng_datap pData)
6166
{
6167
mng_uint8p pScanline;
6168
mng_uint8p pDataline;
6169
mng_int32 iX;
6170
mng_uint8 iA8;
6171
6172
#ifdef MNG_SUPPORT_TRACE
6173
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
6174
#endif
6175
/* viewable row ? */
6176
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
6177
{ /* address destination row */
6178
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
6179
pData->iRow + pData->iDestt -
6180
pData->iSourcet);
6181
/* adjust destination row starting-point */
6182
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6183
pDataline = pData->pRGBArow; /* address source row */
6184
6185
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
6186
6187
if (pData->bIsOpaque) /* forget about transparency ? */
6188
{
6189
{
6190
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6191
iX += pData->iColinc)
6192
{ /* copy the values */
6193
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
6194
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
6195
6196
6197
pScanline += (pData->iColinc * 2);
6198
pDataline += 4;
6199
}
6200
}
6201
}
6202
else
6203
{
6204
{
6205
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6206
iX += pData->iColinc)
6207
{
6208
iA8 = *(pDataline+3); /* get alpha value */
6209
6210
if (iA8) /* any opacity at all ? */
6211
{
6212
if (iA8 == 0xFF) /* fully opaque ? */
6213
{ /* then simply copy the values */
6214
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
6215
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
6216
}
6217
else
6218
{ /* do alpha composing */
6219
mng_uint8 iRed, iGreen, iBlue;
6220
6221
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6222
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6223
iBlue = (mng_uint8) ( (*pScanline << 3) );
6224
6225
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
6226
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6227
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
6228
6229
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6230
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6231
}
6232
}
6233
6234
pScanline += (pData->iColinc * 2);
6235
pDataline += 4;
6236
}
6237
}
6238
}
6239
}
6240
6241
check_update_region (pData);
6242
6243
#ifdef MNG_SUPPORT_TRACE
6244
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
6245
#endif
6246
6247
return MNG_NOERROR;
6248
}
6249
#endif /* MNG_NO_16BIT_SUPPORT */
2994
6250
#endif /* MNG_SKIPCANVAS_BGR565 */
2995
6251
2996
6252
/* ************************************************************************** */
2997
6253
2998
6254
#ifndef MNG_SKIPCANVAS_RGB565
6255
#ifndef MNG_NO_16BIT_SUPPORT
6256
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
2999
6257
mng_retcode mng_display_rgb565 (mng_datap pData)
3000
6258
{
3001
6259
mng_uint8p pScanline;
3002
6260
mng_uint8p pDataline;
3003
6261
mng_int32 iX;
3004
#ifndef MNG_NO_16BIT_SUPPORT
3005
6262
mng_uint16 iA16;
3006
6263
mng_uint16 iFGr16, iFGg16, iFGb16;
3007
6264
mng_uint16 iBGr16, iBGg16, iBGb16;
3008
#endif
3009
6265
mng_uint8 iA8;
3010
6266
3011
6267
#ifdef MNG_SUPPORT_TRACE
3021
6277
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
3022
6278
pDataline = pData->pRGBArow; /* address source row */
3023
6279
3024
#ifndef MNG_NO_16BIT_SUPPORT
3025
6280
if (pData->bIsRGBA16) /* adjust source row starting-point */
3026
6281
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
3027
6282
else
3028
#endif
3029
6283
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
3030
6284
3031
6285
if (pData->bIsOpaque) /* forget about transparency ? */
3032
6286
{
3033
#ifndef MNG_NO_16BIT_SUPPORT
3034
6287
if (pData->bIsRGBA16) /* 16-bit input row ? */
3035
6288
{
3036
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
6289
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6290
iX += pData->iColinc)
3037
6291
{ /* scale down by dropping the LSB */
3038
6292
*(pScanline+1) = (mng_uint8)( ( ( *(pDataline+4)) & 0xF8) | (*(pDataline+2) >> 5 ) );
3039
6293
*pScanline = (mng_uint8)( ( ( *(pDataline )) >> 3 ) | ((*(pDataline+2) & 0xFC) << 3) );
3043
6297
}
3044
6298
}
3045
6299
else
3046
#endif
3047
{
3048
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3049
{ /* copy the values */
3050
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | (*(pDataline+1) >> 5 ) );
3051
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xFC) << 3) );
3052
3053
pScanline += (pData->iColinc * 2);
3054
pDataline += 4;
3055
}
3056
}
3057
}
3058
else
3059
{
3060
#ifndef MNG_NO_16BIT_SUPPORT
3061
if (pData->bIsRGBA16) /* 16-bit input row ? */
3062
{
3063
3064
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3065
{
3066
iA16 = mng_get_uint16 (pDataline+6);
3067
3068
if (iA16) /* any opacity at all ? */
3069
{
3070
if (iA16 == 0xFFFF) /* fully opaque ? */
3071
{ /* scale down by dropping the LSB */
3072
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+4)) & 0xF8) | (*(pDataline+2)>>5) );
3073
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ((*(pDataline+2)&0xFC) << 3) );
3074
}
3075
else
3076
{ /* get the proper values */
3077
iFGr16 = mng_get_uint16 (pDataline );
3078
iFGg16 = mng_get_uint16 (pDataline+2);
3079
iFGb16 = mng_get_uint16 (pDataline+4);
3080
3081
/* scale background up */
3082
iBGr16 = (mng_uint8)( *(pScanline+1) & 0xF8 );
3083
iBGg16 = (mng_uint8)( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0) >> 3 ) );
3084
iBGb16 = (mng_uint8)( *(pScanline ) << 3 );
3085
3086
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3087
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3088
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3089
/* now compose */
3090
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
3091
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
3092
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
3093
/* and return the composed values */
3094
*(pScanline+1) = (mng_uint8)( (mng_uint8)((iFGb16 >> 8) &0xF8) | ( (mng_uint8)(iFGg16 >> 8) >> 5 ) );
3095
*pScanline = (mng_uint8)( (mng_uint8) (iFGr16 >>11) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xFC) << 3) );
3096
}
3097
}
3098
3099
pScanline += (pData->iColinc * 2);
3100
pDataline += 8;
3101
}
3102
}
3103
else
3104
#endif
3105
{
3106
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3107
{
3108
iA8 = *(pDataline+3); /* get alpha value */
3109
3110
if (iA8) /* any opacity at all ? */
3111
{
3112
if (iA8 == 0xFF) /* fully opaque ? */
3113
{ /* then simply copy the values */
3114
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | ( *(pDataline+1) >> 5 ) );
3115
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ( (*(pDataline+1) & 0xFC) << 3 ) );
3116
}
3117
else
3118
{ /* do alpha composing */
3119
mng_uint8 iRed, iGreen, iBlue;
3120
3121
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
3122
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
3123
iBlue = (mng_uint8)( *(pScanline ) << 3 );
3124
3125
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
3126
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
3127
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
3128
3129
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
3130
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
3131
}
3132
}
3133
3134
pScanline += (pData->iColinc * 2);
3135
pDataline += 4;
3136
}
3137
}
3138
}
3139
}
3140
3141
check_update_region (pData);
3142
3143
#ifdef MNG_SUPPORT_TRACE
3144
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
3145
#endif
3146
3147
return MNG_NOERROR;
3148
}
6300
{
6301
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6302
iX += pData->iColinc)
6303
{ /* copy the values */
6304
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | (*(pDataline+1) >> 5 ) );
6305
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xFC) << 3) );
6306
6307
pScanline += (pData->iColinc * 2);
6308
pDataline += 4;
6309
}
6310
}
6311
}
6312
else
6313
{
6314
if (pData->bIsRGBA16) /* 16-bit input row ? */
6315
{
6316
6317
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6318
iX += pData->iColinc)
6319
{
6320
iA16 = mng_get_uint16 (pDataline+6);
6321
6322
if (iA16) /* any opacity at all ? */
6323
{
6324
if (iA16 == 0xFFFF) /* fully opaque ? */
6325
{ /* scale down by dropping the LSB */
6326
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+4)) & 0xF8) | (*(pDataline+2)>>5) );
6327
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ((*(pDataline+2)&0xFC) << 3) );
6328
}
6329
else
6330
{ /* get the proper values */
6331
iFGr16 = mng_get_uint16 (pDataline );
6332
iFGg16 = mng_get_uint16 (pDataline+2);
6333
iFGb16 = mng_get_uint16 (pDataline+4);
6334
6335
/* scale background up */
6336
iBGr16 = (mng_uint8)( *(pScanline+1) & 0xF8 );
6337
iBGg16 = (mng_uint8)( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0) >> 3 ) );
6338
iBGb16 = (mng_uint8)( *(pScanline ) << 3 );
6339
6340
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6341
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6342
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6343
/* now compose */
6344
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
6345
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
6346
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
6347
/* and return the composed values */
6348
*(pScanline+1) = (mng_uint8)( (mng_uint8)((iFGb16 >> 8) &0xF8) | ( (mng_uint8)(iFGg16 >> 8) >> 5 ) );
6349
*pScanline = (mng_uint8)( (mng_uint8) (iFGr16 >>11) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xFC) << 3) );
6350
}
6351
}
6352
6353
pScanline += (pData->iColinc * 2);
6354
pDataline += 8;
6355
}
6356
}
6357
else
6358
{
6359
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6360
iX += pData->iColinc)
6361
{
6362
iA8 = *(pDataline+3); /* get alpha value */
6363
6364
if (iA8) /* any opacity at all ? */
6365
{
6366
if (iA8 == 0xFF) /* fully opaque ? */
6367
{ /* then simply copy the values */
6368
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | ( *(pDataline+1) >> 5 ) );
6369
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ( (*(pDataline+1) & 0xFC) << 3 ) );
6370
}
6371
else
6372
{ /* do alpha composing */
6373
mng_uint8 iRed, iGreen, iBlue;
6374
6375
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
6376
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
6377
iBlue = (mng_uint8)( *(pScanline ) << 3 );
6378
6379
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
6380
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6381
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
6382
6383
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
6384
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6385
}
6386
}
6387
6388
pScanline += (pData->iColinc * 2);
6389
pDataline += 4;
6390
}
6391
}
6392
}
6393
}
6394
6395
check_update_region (pData);
6396
6397
#ifdef MNG_SUPPORT_TRACE
6398
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
6399
#endif
6400
6401
return MNG_NOERROR;
6402
}
6403
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6404
mng_retcode mng_display_rgb565 (mng_datap pData)
6405
{
6406
mng_uint8p pScanline;
6407
mng_uint8p pDataline;
6408
mng_int32 iX;
6409
mng_uint16 iA16;
6410
mng_uint16 iFGr16, iFGg16, iFGb16;
6411
mng_uint16 iBGr16, iBGg16, iBGb16;
6412
mng_uint8 iA8;
6413
mng_uint8 iBps;
6414
6415
#ifdef MNG_SUPPORT_TRACE
6416
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
6417
#endif
6418
6419
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
6420
/* viewable row ? */
6421
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
6422
{ /* address destination row */
6423
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
6424
pData->iRow + pData->iDestt -
6425
pData->iSourcet);
6426
/* adjust destination row starting-point */
6427
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6428
pDataline = pData->pRGBArow; /* address source row */
6429
6430
/* adjust source row starting-point */
6431
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
6432
6433
if (pData->bIsOpaque) /* forget about transparency ? */
6434
{
6435
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6436
iX += pData->iColinc)
6437
{ /* scale down by dropping the LSB */
6438
*(pScanline+1) = (mng_uint8)( ( ( *(pDataline+2*iBps)) & 0xF8) |
6439
(*(pDataline+iBps) >> 5 ) );
6440
*pScanline = (mng_uint8)( ( ( *(pDataline )) >> 3 ) |
6441
((*(pDataline+iBps) & 0xFC) << 3) );
6442
6443
pScanline += (pData->iColinc * 2);
6444
pDataline += 4*iBps;
6445
}
6446
}
6447
else
6448
{
6449
if (pData->bIsRGBA16) /* 16-bit input row ? */
6450
{
6451
6452
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6453
iX += pData->iColinc)
6454
{
6455
iA16 = mng_get_uint16 (pDataline+6);
6456
6457
if (iA16) /* any opacity at all ? */
6458
{
6459
if (iA16 == 0xFFFF) /* fully opaque ? */
6460
{ /* scale down by dropping the LSB */
6461
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+4)) & 0xF8) | (*(pDataline+2)>>5) );
6462
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ((*(pDataline+2)&0xFC) << 3) );
6463
}
6464
else
6465
{ /* get the proper values */
6466
iFGr16 = mng_get_uint16 (pDataline );
6467
iFGg16 = mng_get_uint16 (pDataline+2);
6468
iFGb16 = mng_get_uint16 (pDataline+4);
6469
6470
/* scale background up */
6471
iBGr16 = (mng_uint8)( *(pScanline+1) & 0xF8 );
6472
iBGg16 = (mng_uint8)( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0) >> 3 ) );
6473
iBGb16 = (mng_uint8)( *(pScanline ) << 3 );
6474
6475
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6476
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6477
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6478
/* now compose */
6479
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
6480
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
6481
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
6482
/* and return the composed values */
6483
*(pScanline+1) = (mng_uint8)( (mng_uint8)((iFGb16 >> 8) &0xF8) | ( (mng_uint8)(iFGg16 >> 8) >> 5 ) );
6484
*pScanline = (mng_uint8)( (mng_uint8) (iFGr16 >>11) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xFC) << 3) );
6485
}
6486
}
6487
6488
pScanline += (pData->iColinc * 2);
6489
pDataline += 8;
6490
}
6491
}
6492
else
6493
{
6494
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6495
iX += pData->iColinc)
6496
{
6497
iA8 = *(pDataline+3); /* get alpha value */
6498
6499
if (iA8) /* any opacity at all ? */
6500
{
6501
if (iA8 == 0xFF) /* fully opaque ? */
6502
{ /* then simply copy the values */
6503
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | ( *(pDataline+1) >> 5 ) );
6504
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ( (*(pDataline+1) & 0xFC) << 3 ) );
6505
}
6506
else
6507
{ /* do alpha composing */
6508
mng_uint8 iRed, iGreen, iBlue;
6509
6510
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
6511
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
6512
iBlue = (mng_uint8)( *(pScanline ) << 3 );
6513
6514
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
6515
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6516
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
6517
6518
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
6519
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6520
}
6521
}
6522
6523
pScanline += (pData->iColinc * 2);
6524
pDataline += 4;
6525
}
6526
}
6527
}
6528
}
6529
6530
check_update_region (pData);
6531
6532
#ifdef MNG_SUPPORT_TRACE
6533
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
6534
#endif
6535
6536
return MNG_NOERROR;
6537
}
6538
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6539
#else /* MNG_NO_16BIT_SUPPORT */
6540
mng_retcode mng_display_rgb565 (mng_datap pData)
6541
{
6542
mng_uint8p pScanline;
6543
mng_uint8p pDataline;
6544
mng_int32 iX;
6545
mng_uint8 iA8;
6546
6547
#ifdef MNG_SUPPORT_TRACE
6548
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
6549
#endif
6550
/* viewable row ? */
6551
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
6552
{ /* address destination row */
6553
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
6554
pData->iRow + pData->iDestt -
6555
pData->iSourcet);
6556
/* adjust destination row starting-point */
6557
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6558
pDataline = pData->pRGBArow; /* address source row */
6559
6560
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
6561
6562
if (pData->bIsOpaque) /* forget about transparency ? */
6563
{
6564
{
6565
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6566
iX += pData->iColinc)
6567
{ /* copy the values */
6568
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | (*(pDataline+1) >> 5 ) );
6569
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xFC) << 3) );
6570
6571
pScanline += (pData->iColinc * 2);
6572
pDataline += 4;
6573
}
6574
}
6575
}
6576
else
6577
{
6578
{
6579
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6580
iX += pData->iColinc)
6581
{
6582
iA8 = *(pDataline+3); /* get alpha value */
6583
6584
if (iA8) /* any opacity at all ? */
6585
{
6586
if (iA8 == 0xFF) /* fully opaque ? */
6587
{ /* then simply copy the values */
6588
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8) | ( *(pDataline+1) >> 5 ) );
6589
*pScanline = (mng_uint8)( ( (*(pDataline )) >> 3 ) | ( (*(pDataline+1) & 0xFC) << 3 ) );
6590
}
6591
else
6592
{ /* do alpha composing */
6593
mng_uint8 iRed, iGreen, iBlue;
6594
6595
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
6596
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
6597
iBlue = (mng_uint8)( *(pScanline ) << 3 );
6598
6599
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
6600
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6601
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
6602
6603
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
6604
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6605
}
6606
}
6607
6608
pScanline += (pData->iColinc * 2);
6609
pDataline += 4;
6610
}
6611
}
6612
}
6613
}
6614
6615
check_update_region (pData);
6616
6617
#ifdef MNG_SUPPORT_TRACE
6618
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
6619
#endif
6620
6621
return MNG_NOERROR;
6622
}
6623
#endif /* MNG_NO_16BIT_SUPPORT */
3149
6624
#endif /* MNG_SKIPCANVAS_RGB565 */
3150
6625
3151
6626
/* ************************************************************************** */
3152
6627
3153
6628
#ifndef MNG_SKIPCANVAS_BGRA565
6629
#ifndef MNG_NO_16BIT_SUPPORT
6630
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3154
6631
mng_retcode mng_display_bgra565 (mng_datap pData)
3155
6632
{
3156
6633
mng_uint8p pScanline;
3157
6634
mng_uint8p pDataline;
3158
6635
mng_int32 iX;
3159
6636
mng_uint8 iFGa8, iBGa8, iCa8;
3160
#ifndef MNG_NO_16BIT_SUPPORT
3161
6637
mng_uint16 iFGa16, iBGa16, iCa16;
3162
6638
mng_uint16 iFGr16, iFGg16, iFGb16;
3163
6639
mng_uint16 iBGr16, iBGg16, iBGb16;
3164
6640
mng_uint16 iCr16, iCg16, iCb16;
3165
#endif
3166
6641
mng_uint8 iCr8, iCg8, iCb8;
3167
6642
3168
6643
#ifdef MNG_SUPPORT_TRACE
3178
6653
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
3179
6654
pDataline = pData->pRGBArow; /* address source row */
3180
6655
3181
#ifndef MNG_NO_16BIT_SUPPORT
3182
6656
if (pData->bIsRGBA16) /* adjust source row starting-point */
3183
6657
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
3184
6658
else
3185
#endif
3186
6659
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
3187
6660
3188
6661
if (pData->bIsOpaque) /* forget about transparency ? */
3189
6662
{
3190
#ifndef MNG_NO_16BIT_SUPPORT
3191
6663
if (pData->bIsRGBA16) /* 16-bit input row ? */
3192
6664
{
3193
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
6665
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6666
iX += pData->iColinc)
3194
6667
{ /* scale down by dropping the LSB */
3195
6668
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+2)>>5) ) );
3196
6669
*pScanline = (mng_uint8)( ( (*(pDataline+4)) >>3) | ( (*(pDataline+2)&0xFC) << 3) );
3201
6674
}
3202
6675
}
3203
6676
else
3204
#endif
3205
{
3206
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3207
{ /* copy the values */
3208
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
3209
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
3210
*(pScanline+2) = *(pDataline+3);
3211
3212
pScanline += (pData->iColinc * 3);
3213
pDataline += 4;
3214
}
3215
}
3216
}
3217
else
3218
{
3219
#ifndef MNG_NO_16BIT_SUPPORT
3220
if (pData->bIsRGBA16) /* 16-bit input row ? */
3221
{
3222
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3223
{ /* get alpha values */
3224
iFGa16 = mng_get_uint16 (pDataline+6);
3225
iBGa16 = (mng_uint16)(*(pScanline+2));
3226
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
3227
3228
if (iFGa16) /* any opacity at all ? */
3229
{ /* fully opaque or background fully transparent ? */
3230
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
3231
{ /* plain copy it */
3232
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
3233
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
3234
*(pScanline+2) = *(pDataline+6);
3235
}
3236
else
3237
{
3238
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
3239
{ /* get the proper values */
3240
iFGr16 = mng_get_uint16 (pDataline );
3241
iFGg16 = mng_get_uint16 (pDataline+2);
3242
iFGb16 = mng_get_uint16 (pDataline+4);
3243
/* scale background up */
3244
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3245
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3246
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
3247
3248
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3249
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3250
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3251
3252
/* now compose */
3253
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
3254
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
3255
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
3256
/* and return the composed values */
3257
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
3258
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
3259
}
3260
else
3261
{ /* scale background up */
3262
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3263
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3264
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
3265
3266
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3267
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3268
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3269
/* let's blend */
3270
MNG_BLEND16 (mng_get_uint16 (pDataline ),
3271
mng_get_uint16 (pDataline+2),
3272
mng_get_uint16 (pDataline+4), iFGa16,
3273
iBGr16, iBGg16, iBGb16, iBGa16,
3274
iCr16, iCg16, iCb16, iCa16);
3275
/* and return the composed values */
3276
*(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8) & 0xF8 ) | ( (mng_uint8)(iCg16 >> 8) >> 5 ) );
3277
*pScanline = (mng_uint8) ( ( (iCb16 >> 11) ) | (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
3278
*(pScanline+2) = (mng_uint8)(iCa16 >> 8);
3279
}
3280
}
3281
}
3282
3283
pScanline += (pData->iColinc * 3);
3284
pDataline += 8;
3285
}
3286
}
3287
else
3288
#endif
3289
{
3290
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3291
{
3292
iFGa8 = *(pDataline+3); /* get alpha values */
3293
iBGa8 = *(pScanline+2);
3294
3295
if (iFGa8) /* any opacity at all ? */
3296
{ /* fully opaque or background fully transparent ? */
3297
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
3298
{ /* then simply copy the values */
3299
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
3300
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
3301
*(pScanline+2) = *(pDataline+3);
3302
}
3303
else
3304
{
3305
mng_uint8 iRed, iGreen, iBlue;
3306
3307
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
3308
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
3309
iBlue = (mng_uint8) ( (*pScanline << 3) );
3310
3311
if (iBGa8 == 0xFF) /* background fully opaque ? */
3312
{ /* do alpha composing */
3313
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
3314
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
3315
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
3316
/* alpha remains fully opaque !!! */
3317
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
3318
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
3319
}
3320
else
3321
{ /* now blend */
3322
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
3323
iRed , iGreen , iBlue , iBGa8,
3324
iCr8, iCg8, iCb8, iCa8);
3325
/* and return the composed values */
3326
3327
3328
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
3329
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
3330
*(pScanline+2) = (mng_uint8) iCa8;
3331
}
3332
}
3333
}
3334
3335
pScanline += (pData->iColinc *3);
3336
pDataline += 4;
3337
}
3338
}
3339
}
3340
}
3341
3342
check_update_region (pData);
3343
3344
#ifdef MNG_SUPPORT_TRACE
3345
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
3346
#endif
3347
3348
return MNG_NOERROR;
3349
}
6677
{
6678
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6679
iX += pData->iColinc)
6680
{ /* copy the values */
6681
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
6682
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
6683
*(pScanline+2) = *(pDataline+3);
6684
6685
pScanline += (pData->iColinc * 3);
6686
pDataline += 4;
6687
}
6688
}
6689
}
6690
else
6691
{
6692
if (pData->bIsRGBA16) /* 16-bit input row ? */
6693
{
6694
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6695
iX += pData->iColinc)
6696
{ /* get alpha values */
6697
iFGa16 = mng_get_uint16 (pDataline+6);
6698
iBGa16 = (mng_uint16)(*(pScanline+2));
6699
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
6700
6701
if (iFGa16) /* any opacity at all ? */
6702
{ /* fully opaque or background fully transparent ? */
6703
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
6704
{ /* plain copy it */
6705
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
6706
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
6707
*(pScanline+2) = *(pDataline+6);
6708
}
6709
else
6710
{
6711
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
6712
{ /* get the proper values */
6713
iFGr16 = mng_get_uint16 (pDataline );
6714
iFGg16 = mng_get_uint16 (pDataline+2);
6715
iFGb16 = mng_get_uint16 (pDataline+4);
6716
/* scale background up */
6717
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
6718
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
6719
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
6720
6721
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6722
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6723
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6724
6725
/* now compose */
6726
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
6727
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
6728
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
6729
/* and return the composed values */
6730
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
6731
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
6732
}
6733
else
6734
{ /* scale background up */
6735
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
6736
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
6737
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
6738
6739
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6740
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6741
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6742
/* let's blend */
6743
MNG_BLEND16 (mng_get_uint16 (pDataline ),
6744
mng_get_uint16 (pDataline+2),
6745
mng_get_uint16 (pDataline+4), iFGa16,
6746
iBGr16, iBGg16, iBGb16, iBGa16,
6747
iCr16, iCg16, iCb16, iCa16);
6748
/* and return the composed values */
6749
*(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8) & 0xF8 ) | ( (mng_uint8)(iCg16 >> 8) >> 5 ) );
6750
*pScanline = (mng_uint8) ( ( (iCb16 >> 11) ) | (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
6751
*(pScanline+2) = (mng_uint8)(iCa16 >> 8);
6752
}
6753
}
6754
}
6755
6756
pScanline += (pData->iColinc * 3);
6757
pDataline += 8;
6758
}
6759
}
6760
else
6761
{
6762
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6763
iX += pData->iColinc)
6764
{
6765
iFGa8 = *(pDataline+3); /* get alpha values */
6766
iBGa8 = *(pScanline+2);
6767
6768
if (iFGa8) /* any opacity at all ? */
6769
{ /* fully opaque or background fully transparent ? */
6770
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
6771
{ /* then simply copy the values */
6772
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
6773
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
6774
*(pScanline+2) = *(pDataline+3);
6775
}
6776
else
6777
{
6778
mng_uint8 iRed, iGreen, iBlue;
6779
6780
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6781
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6782
iBlue = (mng_uint8) ( (*pScanline << 3) );
6783
6784
if (iBGa8 == 0xFF) /* background fully opaque ? */
6785
{ /* do alpha composing */
6786
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
6787
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
6788
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
6789
/* alpha remains fully opaque !!! */
6790
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6791
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6792
}
6793
else
6794
{ /* now blend */
6795
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
6796
iRed , iGreen , iBlue , iBGa8,
6797
iCr8, iCg8, iCb8, iCa8);
6798
/* and return the composed values */
6799
6800
6801
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
6802
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
6803
*(pScanline+2) = (mng_uint8) iCa8;
6804
}
6805
}
6806
}
6807
6808
pScanline += (pData->iColinc *3);
6809
pDataline += 4;
6810
}
6811
}
6812
}
6813
}
6814
6815
check_update_region (pData);
6816
6817
#ifdef MNG_SUPPORT_TRACE
6818
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
6819
#endif
6820
6821
return MNG_NOERROR;
6822
}
6823
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6824
mng_retcode mng_display_bgra565 (mng_datap pData)
6825
{
6826
mng_uint8p pScanline;
6827
mng_uint8p pDataline;
6828
mng_int32 iX;
6829
mng_uint8 iFGa8, iBGa8, iCa8;
6830
mng_uint16 iFGa16, iBGa16, iCa16;
6831
mng_uint16 iFGr16, iFGg16, iFGb16;
6832
mng_uint16 iBGr16, iBGg16, iBGb16;
6833
mng_uint16 iCr16, iCg16, iCb16;
6834
mng_uint8 iCr8, iCg8, iCb8;
6835
mng_uint8 iBps;
6836
6837
#ifdef MNG_SUPPORT_TRACE
6838
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
6839
#endif
6840
6841
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
6842
/* viewable row ? */
6843
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
6844
{ /* address destination row */
6845
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
6846
pData->iRow + pData->iDestt -
6847
pData->iSourcet);
6848
/* adjust destination row starting-point */
6849
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
6850
pDataline = pData->pRGBArow; /* address source row */
6851
6852
/* adjust source row starting-point */
6853
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
6854
6855
if (pData->bIsOpaque) /* forget about transparency ? */
6856
{
6857
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6858
iX += pData->iColinc)
6859
{ /* scale down by dropping the LSB */
6860
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) |
6861
( (*(pDataline+iBps)>>5) ) );
6862
*pScanline = (mng_uint8)( ( (*(pDataline+2*iBps)) >>3) |
6863
( (*(pDataline+iBps)&0xFC) << 3) );
6864
*(pScanline+2) = *(pDataline+3*iBps);
6865
6866
pScanline += (pData->iColinc * 3);
6867
pDataline += 4*iBps;
6868
}
6869
}
6870
else
6871
{
6872
if (pData->bIsRGBA16) /* 16-bit input row ? */
6873
{
6874
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6875
iX += pData->iColinc)
6876
{ /* get alpha values */
6877
iFGa16 = mng_get_uint16 (pDataline+6);
6878
iBGa16 = (mng_uint16)(*(pScanline+2));
6879
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
6880
6881
if (iFGa16) /* any opacity at all ? */
6882
{ /* fully opaque or background fully transparent ? */
6883
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
6884
{ /* plain copy it */
6885
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
6886
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
6887
*(pScanline+2) = *(pDataline+6);
6888
}
6889
else
6890
{
6891
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
6892
{ /* get the proper values */
6893
iFGr16 = mng_get_uint16 (pDataline );
6894
iFGg16 = mng_get_uint16 (pDataline+2);
6895
iFGb16 = mng_get_uint16 (pDataline+4);
6896
/* scale background up */
6897
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
6898
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
6899
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
6900
6901
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6902
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6903
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6904
6905
/* now compose */
6906
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
6907
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
6908
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
6909
/* and return the composed values */
6910
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
6911
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
6912
}
6913
else
6914
{ /* scale background up */
6915
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
6916
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
6917
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
6918
6919
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
6920
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
6921
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
6922
/* let's blend */
6923
MNG_BLEND16 (mng_get_uint16 (pDataline ),
6924
mng_get_uint16 (pDataline+2),
6925
mng_get_uint16 (pDataline+4), iFGa16,
6926
iBGr16, iBGg16, iBGb16, iBGa16,
6927
iCr16, iCg16, iCb16, iCa16);
6928
/* and return the composed values */
6929
*(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8) & 0xF8 ) | ( (mng_uint8)(iCg16 >> 8) >> 5 ) );
6930
*pScanline = (mng_uint8) ( ( (iCb16 >> 11) ) | (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
6931
*(pScanline+2) = (mng_uint8)(iCa16 >> 8);
6932
}
6933
}
6934
}
6935
6936
pScanline += (pData->iColinc * 3);
6937
pDataline += 8;
6938
}
6939
}
6940
else
6941
{
6942
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6943
iX += pData->iColinc)
6944
{
6945
iFGa8 = *(pDataline+3); /* get alpha values */
6946
iBGa8 = *(pScanline+2);
6947
6948
if (iFGa8) /* any opacity at all ? */
6949
{ /* fully opaque or background fully transparent ? */
6950
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
6951
{ /* then simply copy the values */
6952
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
6953
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
6954
*(pScanline+2) = *(pDataline+3);
6955
}
6956
else
6957
{
6958
mng_uint8 iRed, iGreen, iBlue;
6959
6960
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6961
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6962
iBlue = (mng_uint8) ( (*pScanline << 3) );
6963
6964
if (iBGa8 == 0xFF) /* background fully opaque ? */
6965
{ /* do alpha composing */
6966
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
6967
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
6968
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
6969
/* alpha remains fully opaque !!! */
6970
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6971
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6972
}
6973
else
6974
{ /* now blend */
6975
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
6976
iRed , iGreen , iBlue , iBGa8,
6977
iCr8, iCg8, iCb8, iCa8);
6978
/* and return the composed values */
6979
6980
6981
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
6982
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
6983
*(pScanline+2) = (mng_uint8) iCa8;
6984
}
6985
}
6986
}
6987
6988
pScanline += (pData->iColinc *3);
6989
pDataline += 4;
6990
}
6991
}
6992
}
6993
}
6994
6995
check_update_region (pData);
6996
6997
#ifdef MNG_SUPPORT_TRACE
6998
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
6999
#endif
7000
7001
return MNG_NOERROR;
7002
}
7003
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7004
#else /* MNG_NO_16BIT_SUPPORT */
7005
mng_retcode mng_display_bgra565 (mng_datap pData)
7006
{
7007
mng_uint8p pScanline;
7008
mng_uint8p pDataline;
7009
mng_int32 iX;
7010
mng_uint8 iFGa8, iBGa8, iCa8;
7011
mng_uint8 iCr8, iCg8, iCb8;
7012
7013
#ifdef MNG_SUPPORT_TRACE
7014
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
7015
#endif
7016
/* viewable row ? */
7017
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
7018
{ /* address destination row */
7019
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
7020
pData->iRow + pData->iDestt -
7021
pData->iSourcet);
7022
/* adjust destination row starting-point */
7023
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
7024
pDataline = pData->pRGBArow; /* address source row */
7025
7026
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
7027
7028
if (pData->bIsOpaque) /* forget about transparency ? */
7029
{
7030
{
7031
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7032
iX += pData->iColinc)
7033
{ /* copy the values */
7034
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
7035
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
7036
*(pScanline+2) = *(pDataline+3);
7037
7038
pScanline += (pData->iColinc * 3);
7039
pDataline += 4;
7040
}
7041
}
7042
}
7043
else
7044
{
7045
{
7046
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7047
iX += pData->iColinc)
7048
{
7049
iFGa8 = *(pDataline+3); /* get alpha values */
7050
iBGa8 = *(pScanline+2);
7051
7052
if (iFGa8) /* any opacity at all ? */
7053
{ /* fully opaque or background fully transparent ? */
7054
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
7055
{ /* then simply copy the values */
7056
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
7057
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
7058
*(pScanline+2) = *(pDataline+3);
7059
}
7060
else
7061
{
7062
mng_uint8 iRed, iGreen, iBlue;
7063
7064
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7065
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7066
iBlue = (mng_uint8) ( (*pScanline << 3) );
7067
7068
if (iBGa8 == 0xFF) /* background fully opaque ? */
7069
{ /* do alpha composing */
7070
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
7071
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
7072
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
7073
/* alpha remains fully opaque !!! */
7074
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
7075
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
7076
}
7077
else
7078
{ /* now blend */
7079
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
7080
iRed , iGreen , iBlue , iBGa8,
7081
iCr8, iCg8, iCb8, iCa8);
7082
/* and return the composed values */
7083
7084
7085
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7086
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
7087
*(pScanline+2) = (mng_uint8) iCa8;
7088
}
7089
}
7090
}
7091
7092
pScanline += (pData->iColinc *3);
7093
pDataline += 4;
7094
}
7095
}
7096
}
7097
}
7098
7099
check_update_region (pData);
7100
7101
#ifdef MNG_SUPPORT_TRACE
7102
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
7103
#endif
7104
7105
return MNG_NOERROR;
7106
}
7107
#endif /* MNG_NO_16BIT_SUPPORT */
3350
7108
#endif /* MNG_SKIPCANVAS_BGRA565 */
3351
7109
3352
7110
/* ************************************************************************** */
3353
7111
3354
7112
#ifndef MNG_SKIPCANVAS_RGBA565
7113
#ifndef MNG_NO_16BIT_SUPPORT
7114
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3355
7115
mng_retcode mng_display_rgba565 (mng_datap pData)
3356
7116
{
3357
7117
mng_uint8p pScanline;
3358
7118
mng_uint8p pDataline;
3359
7119
mng_int32 iX;
3360
7120
mng_uint8 iFGa8, iBGa8, iCa8;
3361
#ifndef MNG_NO_16BIT_SUPPORT
3362
7121
mng_uint16 iFGa16, iBGa16, iCa16;
3363
7122
mng_uint16 iFGr16, iFGg16, iFGb16;
3364
7123
mng_uint16 iBGr16, iBGg16, iBGb16;
3365
7124
mng_uint16 iCr16, iCg16, iCb16;
3366
#endif
3367
7125
mng_uint8 iCr8, iCg8, iCb8;
3368
7126
3369
7127
#ifdef MNG_SUPPORT_TRACE
3379
7137
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
3380
7138
pDataline = pData->pRGBArow; /* address source row */
3381
7139
3382
#ifndef MNG_NO_16BIT_SUPPORT
3383
7140
if (pData->bIsRGBA16) /* adjust source row starting-point */
3384
7141
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
3385
7142
else
3386
#endif
3387
7143
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
3388
7144
3389
7145
if (pData->bIsOpaque) /* forget about transparency ? */
3390
7146
{
3391
#ifndef MNG_NO_16BIT_SUPPORT
3392
7147
if (pData->bIsRGBA16) /* 16-bit input row ? */
3393
7148
{
3394
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
7149
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7150
iX += pData->iColinc)
3395
7151
{ /* scale down by dropping the LSB */
3396
7152
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+4))&0xF8 ) | ( (*(pDataline+2)>>5) ) );
3397
7153
*pScanline = (mng_uint8)( ( (*(pDataline)) >>3) | ( (*(pDataline+2)&0xFC) << 3) );
3402
7158
}
3403
7159
}
3404
7160
else
3405
#endif
3406
{
3407
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3408
{ /* copy the values */
3409
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
3410
*pScanline = (mng_uint8)( ( *(pDataline) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
3411
*(pScanline+2) = *(pDataline+3);
3412
3413
pScanline += (pData->iColinc * 3);
3414
pDataline += 4;
3415
}
3416
}
3417
}
3418
else
3419
{
3420
#ifndef MNG_NO_16BIT_SUPPORT
3421
if (pData->bIsRGBA16) /* 16-bit input row ? */
3422
{
3423
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3424
{ /* get alpha values */
3425
iFGa16 = mng_get_uint16 (pDataline+6);
3426
iBGa16 = (mng_uint16)(*(pScanline+2));
3427
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
3428
3429
if (iFGa16) /* any opacity at all ? */
3430
{ /* fully opaque or background fully transparent ? */
3431
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
3432
{ /* plain copy it */
3433
*(pScanline+1) = (mng_uint8)( (*(pDataline+4))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
3434
*pScanline = (mng_uint8)( (*(pDataline)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
3435
*(pScanline+2) = *(pDataline+6);
3436
}
3437
else
3438
{
3439
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
3440
{ /* get the proper values */
3441
iFGr16 = mng_get_uint16 (pDataline );
3442
iFGg16 = mng_get_uint16 (pDataline+2);
3443
iFGb16 = mng_get_uint16 (pDataline+4);
3444
/* scale background up */
3445
iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3446
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3447
iBGb16 = (mng_uint16)( (*(pScanline )) << 3 );
3448
3449
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3450
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3451
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3452
3453
/* now compose */
3454
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
3455
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
3456
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
3457
/* and return the composed values */
3458
*(pScanline+1) = (mng_uint8) ( ( (iFGb16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
3459
*pScanline = (mng_uint8) ( ( (iFGr16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
3460
}
3461
else
3462
{ /* scale background up */
3463
iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3464
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3465
iBGb16 = (mng_uint16)( (*(pScanline )) << 3 );
3466
3467
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3468
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3469
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3470
/* let's blend */
3471
MNG_BLEND16 (mng_get_uint16 (pDataline ),
3472
mng_get_uint16 (pDataline+2),
3473
mng_get_uint16 (pDataline+4), iFGa16,
3474
iBGr16, iBGg16, iBGb16, iBGa16,
3475
iCr16, iCg16, iCb16, iCa16);
3476
/* and return the composed values */
3477
*(pScanline+1) = (mng_uint8) ( ( (iCb16 >> 8) & 0xF8 ) | ( (mng_uint8)(iCg16 >> 8) >> 5 ) );
3478
*pScanline = (mng_uint8) ( ( (iCr16 >> 11) ) | (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
3479
*(pScanline+2) = (mng_uint8)(iCa16 >> 8);
3480
}
3481
}
3482
}
3483
3484
pScanline += (pData->iColinc * 3);
3485
pDataline += 8;
3486
}
3487
}
3488
else
3489
#endif
3490
{
3491
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3492
{
3493
iFGa8 = *(pDataline+3); /* get alpha values */
3494
iBGa8 = *(pScanline+2);
3495
3496
if (iFGa8) /* any opacity at all ? */
3497
{ /* fully opaque or background fully transparent ? */
3498
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
3499
{ /* then simply copy the values */
3500
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) &0xF8 ) | (*(pDataline+1) >>5 ) );
3501
*pScanline = (mng_uint8)( ( ((*(pDataline))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
3502
*(pScanline+2) = *(pDataline+3);
3503
}
3504
else
3505
{
3506
mng_uint8 iRed, iGreen, iBlue;
3507
3508
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
3509
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
3510
iRed = (mng_uint8) ( (*pScanline << 3) );
3511
3512
if (iBGa8 == 0xFF) /* background fully opaque ? */
3513
{ /* do alpha composing */
3514
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
3515
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
3516
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
3517
/* alpha remains fully opaque !!! */
3518
*(pScanline+1) = (mng_uint8) ( ( iBlue & 0xF8 ) | (iGreen>>5) );
3519
*pScanline = (mng_uint8) ( ( iRed >> 3 ) | ( (iGreen & 0xFC) << 3) );
3520
}
3521
else
3522
{ /* now blend */
3523
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
3524
iRed , iGreen , iBlue , iBGa8,
3525
iCr8, iCg8, iCb8, iCa8);
3526
/* and return the composed values */
3527
3528
3529
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
3530
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
3531
*(pScanline+2) = (mng_uint8) iCa8;
3532
}
3533
}
3534
}
3535
3536
pScanline += (pData->iColinc *3);
3537
pDataline += 4;
3538
}
3539
}
3540
}
3541
}
3542
3543
check_update_region (pData);
3544
3545
#ifdef MNG_SUPPORT_TRACE
3546
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
3547
#endif
3548
3549
return MNG_NOERROR;
3550
}
7161
{
7162
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7163
iX += pData->iColinc)
7164
{ /* copy the values */
7165
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
7166
*pScanline = (mng_uint8)( ( *(pDataline) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
7167
*(pScanline+2) = *(pDataline+3);
7168
7169
pScanline += (pData->iColinc * 3);
7170
pDataline += 4;
7171
}
7172
}
7173
}
7174
else
7175
{
7176
if (pData->bIsRGBA16) /* 16-bit input row ? */
7177
{
7178
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7179
iX += pData->iColinc)
7180
{ /* get alpha values */
7181
iFGa16 = mng_get_uint16 (pDataline+6);
7182
iBGa16 = (mng_uint16)(*(pScanline+2));
7183
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
7184
7185
if (iFGa16) /* any opacity at all ? */
7186
{ /* fully opaque or background fully transparent ? */
7187
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
7188
{ /* plain copy it */
7189
*(pScanline+1) = (mng_uint8)( (*(pDataline+4))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
7190
*pScanline = (mng_uint8)( (*(pDataline)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
7191
*(pScanline+2) = *(pDataline+6);
7192
}
7193
else
7194
{
7195
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
7196
{ /* get the proper values */
7197
iFGr16 = mng_get_uint16 (pDataline );
7198
iFGg16 = mng_get_uint16 (pDataline+2);
7199
iFGb16 = mng_get_uint16 (pDataline+4);
7200
/* scale background up */
7201
iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7202
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7203
iBGb16 = (mng_uint16)( (*(pScanline )) << 3 );
7204
7205
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7206
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7207
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7208
7209
/* now compose */
7210
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
7211
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
7212
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
7213
/* and return the composed values */
7214
*(pScanline+1) = (mng_uint8) ( ( (iFGb16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
7215
*pScanline = (mng_uint8) ( ( (iFGr16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
7216
}
7217
else
7218
{ /* scale background up */
7219
iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7220
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7221
iBGb16 = (mng_uint16)( (*(pScanline )) << 3 );
7222
7223
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7224
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7225
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7226
/* let's blend */
7227
MNG_BLEND16 (mng_get_uint16 (pDataline ),
7228
mng_get_uint16 (pDataline+2),
7229
mng_get_uint16 (pDataline+4), iFGa16,
7230
iBGr16, iBGg16, iBGb16, iBGa16,
7231
iCr16, iCg16, iCb16, iCa16);
7232
/* and return the composed values */
7233
*(pScanline+1) = (mng_uint8) ( ( (iCb16 >> 8) & 0xF8 ) | ( (mng_uint8)(iCg16 >> 8) >> 5 ) );
7234
*pScanline = (mng_uint8) ( ( (iCr16 >> 11) ) | (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
7235
*(pScanline+2) = (mng_uint8)(iCa16 >> 8);
7236
}
7237
}
7238
}
7239
7240
pScanline += (pData->iColinc * 3);
7241
pDataline += 8;
7242
}
7243
}
7244
else
7245
{
7246
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7247
iX += pData->iColinc)
7248
{
7249
iFGa8 = *(pDataline+3); /* get alpha values */
7250
iBGa8 = *(pScanline+2);
7251
7252
if (iFGa8) /* any opacity at all ? */
7253
{ /* fully opaque or background fully transparent ? */
7254
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
7255
{ /* then simply copy the values */
7256
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) &0xF8 ) | (*(pDataline+1) >>5 ) );
7257
*pScanline = (mng_uint8)( ( ((*(pDataline))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
7258
*(pScanline+2) = *(pDataline+3);
7259
}
7260
else
7261
{
7262
mng_uint8 iRed, iGreen, iBlue;
7263
7264
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7265
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7266
iRed = (mng_uint8) ( (*pScanline << 3) );
7267
7268
if (iBGa8 == 0xFF) /* background fully opaque ? */
7269
{ /* do alpha composing */
7270
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
7271
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
7272
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
7273
/* alpha remains fully opaque !!! */
7274
*(pScanline+1) = (mng_uint8) ( ( iBlue & 0xF8 ) | (iGreen>>5) );
7275
*pScanline = (mng_uint8) ( ( iRed >> 3 ) | ( (iGreen & 0xFC) << 3) );
7276
}
7277
else
7278
{ /* now blend */
7279
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
7280
iRed , iGreen , iBlue , iBGa8,
7281
iCr8, iCg8, iCb8, iCa8);
7282
/* and return the composed values */
7283
7284
7285
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7286
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
7287
*(pScanline+2) = (mng_uint8) iCa8;
7288
}
7289
}
7290
}
7291
7292
pScanline += (pData->iColinc *3);
7293
pDataline += 4;
7294
}
7295
}
7296
}
7297
}
7298
7299
check_update_region (pData);
7300
7301
#ifdef MNG_SUPPORT_TRACE
7302
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
7303
#endif
7304
7305
return MNG_NOERROR;
7306
}
7307
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7308
mng_retcode mng_display_rgba565 (mng_datap pData)
7309
{
7310
mng_uint8p pScanline;
7311
mng_uint8p pDataline;
7312
mng_int32 iX;
7313
mng_uint8 iFGa8, iBGa8, iCa8;
7314
mng_uint16 iFGa16, iBGa16, iCa16;
7315
mng_uint16 iFGr16, iFGg16, iFGb16;
7316
mng_uint16 iBGr16, iBGg16, iBGb16;
7317
mng_uint16 iCr16, iCg16, iCb16;
7318
mng_uint8 iCr8, iCg8, iCb8;
7319
mng_uint8 iBps;
7320
7321
#ifdef MNG_SUPPORT_TRACE
7322
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
7323
#endif
7324
7325
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
7326
/* viewable row ? */
7327
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
7328
{ /* address destination row */
7329
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
7330
pData->iRow + pData->iDestt -
7331
pData->iSourcet);
7332
/* adjust destination row starting-point */
7333
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
7334
pDataline = pData->pRGBArow; /* address source row */
7335
7336
/* adjust source row starting-point */
7337
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
7338
7339
if (pData->bIsOpaque) /* forget about transparency ? */
7340
{
7341
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7342
iX += pData->iColinc)
7343
{ /* scale down by dropping the LSB */
7344
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2*iBps))&0xF8 ) |
7345
( (*(pDataline+iBps)>>5) ) );
7346
*pScanline = (mng_uint8)( ( (*(pDataline)) >>3) |
7347
( (*(pDataline+iBps)&0xFC) << 3) );
7348
*(pScanline+2) = *(pDataline+3*iBps);
7349
7350
pScanline += (pData->iColinc * 3);
7351
pDataline += 4*iBps;
7352
}
7353
}
7354
else
7355
{
7356
if (pData->bIsRGBA16) /* 16-bit input row ? */
7357
{
7358
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7359
iX += pData->iColinc)
7360
{ /* get alpha values */
7361
iFGa16 = mng_get_uint16 (pDataline+6);
7362
iBGa16 = (mng_uint16)(*(pScanline+2));
7363
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
7364
7365
if (iFGa16) /* any opacity at all ? */
7366
{ /* fully opaque or background fully transparent ? */
7367
if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
7368
{ /* plain copy it */
7369
*(pScanline+1) = (mng_uint8)( (*(pDataline+4))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
7370
*pScanline = (mng_uint8)( (*(pDataline)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
7371
*(pScanline+2) = *(pDataline+6);
7372
}
7373
else
7374
{
7375
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
7376
{ /* get the proper values */
7377
iFGr16 = mng_get_uint16 (pDataline );
7378
iFGg16 = mng_get_uint16 (pDataline+2);
7379
iFGb16 = mng_get_uint16 (pDataline+4);
7380
/* scale background up */
7381
iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7382
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7383
iBGb16 = (mng_uint16)( (*(pScanline )) << 3 );
7384
7385
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7386
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7387
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7388
7389
/* now compose */
7390
MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
7391
MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
7392
MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
7393
/* and return the composed values */
7394
*(pScanline+1) = (mng_uint8) ( ( (iFGb16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
7395
*pScanline = (mng_uint8) ( ( (iFGr16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
7396
}
7397
else
7398
{ /* scale background up */
7399
iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7400
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7401
iBGb16 = (mng_uint16)( (*(pScanline )) << 3 );
7402
7403
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7404
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7405
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7406
/* let's blend */
7407
MNG_BLEND16 (mng_get_uint16 (pDataline ),
7408
mng_get_uint16 (pDataline+2),
7409
mng_get_uint16 (pDataline+4), iFGa16,
7410
iBGr16, iBGg16, iBGb16, iBGa16,
7411
iCr16, iCg16, iCb16, iCa16);
7412
/* and return the composed values */
7413
*(pScanline+1) = (mng_uint8) ( ( (iCb16 >> 8) & 0xF8 ) | ( (mng_uint8)(iCg16 >> 8) >> 5 ) );
7414
*pScanline = (mng_uint8) ( ( (iCr16 >> 11) ) | (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
7415
*(pScanline+2) = (mng_uint8)(iCa16 >> 8);
7416
}
7417
}
7418
}
7419
7420
pScanline += (pData->iColinc * 3);
7421
pDataline += 8;
7422
}
7423
}
7424
else
7425
{
7426
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7427
iX += pData->iColinc)
7428
{
7429
iFGa8 = *(pDataline+3); /* get alpha values */
7430
iBGa8 = *(pScanline+2);
7431
7432
if (iFGa8) /* any opacity at all ? */
7433
{ /* fully opaque or background fully transparent ? */
7434
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
7435
{ /* then simply copy the values */
7436
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) &0xF8 ) | (*(pDataline+1) >>5 ) );
7437
*pScanline = (mng_uint8)( ( ((*(pDataline))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
7438
*(pScanline+2) = *(pDataline+3);
7439
}
7440
else
7441
{
7442
mng_uint8 iRed, iGreen, iBlue;
7443
7444
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7445
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7446
iRed = (mng_uint8) ( (*pScanline << 3) );
7447
7448
if (iBGa8 == 0xFF) /* background fully opaque ? */
7449
{ /* do alpha composing */
7450
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
7451
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
7452
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
7453
/* alpha remains fully opaque !!! */
7454
*(pScanline+1) = (mng_uint8) ( ( iBlue & 0xF8 ) | (iGreen>>5) );
7455
*pScanline = (mng_uint8) ( ( iRed >> 3 ) | ( (iGreen & 0xFC) << 3) );
7456
}
7457
else
7458
{ /* now blend */
7459
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
7460
iRed , iGreen , iBlue , iBGa8,
7461
iCr8, iCg8, iCb8, iCa8);
7462
/* and return the composed values */
7463
7464
7465
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7466
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
7467
*(pScanline+2) = (mng_uint8) iCa8;
7468
}
7469
}
7470
}
7471
7472
pScanline += (pData->iColinc *3);
7473
pDataline += 4;
7474
}
7475
}
7476
}
7477
}
7478
7479
check_update_region (pData);
7480
7481
#ifdef MNG_SUPPORT_TRACE
7482
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
7483
#endif
7484
7485
return MNG_NOERROR;
7486
}
7487
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7488
#else /* MNG_NO_16BIT_SUPPORT */
7489
mng_retcode mng_display_rgba565 (mng_datap pData)
7490
{
7491
mng_uint8p pScanline;
7492
mng_uint8p pDataline;
7493
mng_int32 iX;
7494
mng_uint8 iFGa8, iBGa8, iCa8;
7495
mng_uint8 iCr8, iCg8, iCb8;
7496
7497
#ifdef MNG_SUPPORT_TRACE
7498
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
7499
#endif
7500
/* viewable row ? */
7501
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
7502
{ /* address destination row */
7503
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
7504
pData->iRow + pData->iDestt -
7505
pData->iSourcet);
7506
/* adjust destination row starting-point */
7507
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
7508
pDataline = pData->pRGBArow; /* address source row */
7509
7510
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
7511
7512
if (pData->bIsOpaque) /* forget about transparency ? */
7513
{
7514
{
7515
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7516
iX += pData->iColinc)
7517
{ /* copy the values */
7518
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2))&0xF8 ) | ( (*(pDataline+1)>>5 ) ) );
7519
*pScanline = (mng_uint8)( ( *(pDataline) >>3 ) | ( (*(pDataline+1)&0xFC ) << 3) );
7520
*(pScanline+2) = *(pDataline+3);
7521
7522
pScanline += (pData->iColinc * 3);
7523
pDataline += 4;
7524
}
7525
}
7526
}
7527
else
7528
{
7529
{
7530
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7531
iX += pData->iColinc)
7532
{
7533
iFGa8 = *(pDataline+3); /* get alpha values */
7534
iBGa8 = *(pScanline+2);
7535
7536
if (iFGa8) /* any opacity at all ? */
7537
{ /* fully opaque or background fully transparent ? */
7538
if ((iFGa8 == 0xFF) || (iBGa8 == 0))
7539
{ /* then simply copy the values */
7540
*(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) &0xF8 ) | (*(pDataline+1) >>5 ) );
7541
*pScanline = (mng_uint8)( ( ((*(pDataline))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
7542
*(pScanline+2) = *(pDataline+3);
7543
}
7544
else
7545
{
7546
mng_uint8 iRed, iGreen, iBlue;
7547
7548
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7549
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7550
iRed = (mng_uint8) ( (*pScanline << 3) );
7551
7552
if (iBGa8 == 0xFF) /* background fully opaque ? */
7553
{ /* do alpha composing */
7554
MNG_COMPOSE8 (iRed, *pDataline, iFGa8, iRed );
7555
MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
7556
MNG_COMPOSE8 (iBlue, *(pDataline+2), iFGa8, iBlue );
7557
/* alpha remains fully opaque !!! */
7558
*(pScanline+1) = (mng_uint8) ( ( iBlue & 0xF8 ) | (iGreen>>5) );
7559
*pScanline = (mng_uint8) ( ( iRed >> 3 ) | ( (iGreen & 0xFC) << 3) );
7560
}
7561
else
7562
{ /* now blend */
7563
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
7564
iRed , iGreen , iBlue , iBGa8,
7565
iCr8, iCg8, iCb8, iCa8);
7566
/* and return the composed values */
7567
7568
7569
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7570
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
7571
*(pScanline+2) = (mng_uint8) iCa8;
7572
}
7573
}
7574
}
7575
7576
pScanline += (pData->iColinc *3);
7577
pDataline += 4;
7578
}
7579
}
7580
}
7581
}
7582
7583
check_update_region (pData);
7584
7585
#ifdef MNG_SUPPORT_TRACE
7586
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
7587
#endif
7588
7589
return MNG_NOERROR;
7590
}
7591
#endif /* MNG_NO_16BIT_SUPPORT */
3551
7592
#endif /* MNG_SKIPCANVAS_RGBA565 */
3552
7593
3553
7594
/* ************************************************************************** */
3554
7595
3555
7596
#ifndef MNG_SKIPCANVAS_BGR565_A8
7597
#ifndef MNG_NO_16BIT_SUPPORT
7598
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
3556
7599
mng_retcode mng_display_bgr565_a8 (mng_datap pData)
3557
7600
{
3558
7601
mng_uint8p pScanline;
3559
7602
mng_uint8p pAlphaline;
3560
7603
mng_uint8p pDataline;
3561
7604
mng_int32 iX;
3562
#ifndef MNG_NO_16BIT_SUPPORT
3563
7605
mng_uint16 iA16;
3564
7606
mng_uint16 iFGr16, iFGg16, iFGb16;
3565
7607
mng_uint16 iBGr16, iBGg16, iBGb16, iBGa16;
3566
7608
mng_uint16 iCr16, iCg16, iCb16, iCa16;
3567
#endif
3568
7609
mng_uint8 iA8, iBGa8, iCa8;
3569
7610
mng_uint8 iCr8, iCg8, iCb8;
3570
7611
3571
3572
7612
#ifdef MNG_SUPPORT_TRACE
3573
7613
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
3574
7614
#endif
3587
7627
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
3588
7628
pDataline = pData->pRGBArow; /* address source row */
3589
7629
3590
#ifndef MNG_NO_16BIT_SUPPORT
3591
if (pData->bIsRGBA16) /* adjust source row
3592
starting-point */
7630
if (pData->bIsRGBA16) /* adjust source row starting-point */
3593
7631
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
3594
7632
else
3595
#endif
3596
7633
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
3597
7634
3598
7635
if (pData->bIsOpaque) /* forget about transparency ? */
3599
7636
{
3600
#ifndef MNG_NO_16BIT_SUPPORT
3601
7637
if (pData->bIsRGBA16) /* 16-bit input row ? */
3602
7638
{
3603
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
7639
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7640
iX += pData->iColinc)
3604
7641
{ /* scale down by dropping the LSB */
3605
7642
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ((*(pDataline+2)>>5) ) );
3606
7643
*pScanline = (mng_uint8)( ( (*(pDataline+4)) >>3) | ((*(pDataline+2)&0xFC) << 3) );
3612
7649
}
3613
7650
}
3614
7651
else
3615
#endif
3616
{
3617
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3618
{ /* copy the values */
3619
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ((*(pDataline+1)>>5 ) ) );
3620
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ((*(pDataline+1)&0xFC ) << 3) );
3621
*pAlphaline = (mng_uint8)(*(pDataline+3));
3622
3623
pScanline += (pData->iColinc * 2);
3624
pAlphaline += pData->iColinc;
3625
pDataline += 4;
3626
}
3627
}
3628
}
3629
else /* Not fully opaque */
3630
{
3631
#ifndef MNG_NO_16BIT_SUPPORT
3632
if (pData->bIsRGBA16) /* 16-bit input row ? */
3633
{
3634
3635
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3636
{
3637
iA16 = mng_get_uint16 (pDataline+6);
3638
iBGa16 = (mng_uint16)(*pAlphaline);
3639
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
3640
3641
if (iA16) /* any opacity at all ? */
3642
{
3643
if ((iA16 == 0xFFFF) || (iBGa16 == 0)) /* fully opaque or background fully transparent ? */
3644
{ /* scale down by dropping the LSB */
3645
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
3646
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
3647
*pAlphaline = *(pDataline+6);
3648
}
3649
else
3650
{
3651
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
3652
{
3653
/* get the proper values */
3654
iFGr16 = mng_get_uint16 (pDataline );
3655
iFGg16 = mng_get_uint16 (pDataline+2);
3656
iFGb16 = mng_get_uint16 (pDataline+4);
3657
/* scale background up */
3658
3659
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3660
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3661
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
3662
3663
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3664
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3665
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3666
/* now compose */
3667
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
3668
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
3669
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
3670
/* and return the composed values */
3671
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
3672
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
3673
*pAlphaline = (mng_uint8)(iA16>>8);
3674
}
3675
else /* background is not fully opaque */
3676
{ /* scale background up */
3677
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3678
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3679
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
3680
3681
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
3682
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
3683
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
3684
/* let's blend */
3685
MNG_BLEND16 (mng_get_uint16 (pDataline ),
3686
mng_get_uint16 (pDataline+2),
3687
mng_get_uint16 (pDataline+4), iA16,
3688
iBGr16, iBGg16, iBGb16, iBGa16,
3689
iCr16, iCg16, iCb16, iCa16);
3690
/* and return the composed values */
3691
*(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8)&0xF8 ) | ( (mng_uint8)(iCg16>>8) >> 5) );
3692
*pScanline = (mng_uint8) ( ( (iCb16>>11) ) | (((mng_uint8)(iCg16>>8)&0xFC) << 3) );
3693
*pAlphaline = (mng_uint8)(iCa16 >> 8);
3694
}
3695
}
3696
}
3697
3698
pScanline += (pData->iColinc * 2);
3699
pAlphaline += pData->iColinc;
3700
pDataline += 8;
3701
}
3702
}
3703
else
3704
#endif
3705
{
3706
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3707
iX += pData->iColinc)
3708
{
3709
iA8 = *(pDataline+3); /* get alpha value */
3710
iBGa8 = *pAlphaline;
3711
3712
if (iA8) /* any opacity at all ? */
3713
{ /* fully opaque or background fully transparent ? */
3714
if ((iA8 == 0xFF) || (iBGa8 == 0))
3715
{ /* then simply copy the values */
3716
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
3717
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
3718
*pAlphaline = *(pDataline+3);
3719
}
3720
else
3721
{
3722
if (iBGa8 == 0xFF) /* background fully opaque ? */
3723
{
3724
/* do alpha composing */
3725
mng_uint8 iRed, iGreen, iBlue;
3726
3727
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
3728
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
3729
iBlue = (mng_uint8) ( (*pScanline << 3) );
3730
3731
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
3732
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
3733
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
3734
3735
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
3736
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
3737
*pAlphaline = iA8;
3738
}
3739
else /* background not fully opaque */
3740
{
3741
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
3742
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
3743
iCr8, iCg8, iCb8, iCa8);
3744
/* and return the composed values */
3745
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
3746
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ((iCg8 & 0xFC) << 3) );
3747
*pAlphaline = iCa8;
3748
}
3749
}
3750
}
3751
3752
pScanline += (pData->iColinc * 2);
3753
pAlphaline += pData->iColinc;
3754
pDataline += 4;
3755
}
3756
}
3757
}
3758
}
3759
3760
check_update_region (pData);
3761
3762
#ifdef MNG_SUPPORT_TRACE
3763
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
3764
#endif
3765
3766
return MNG_NOERROR;
3767
}
7652
{
7653
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7654
iX += pData->iColinc)
7655
{ /* copy the values */
7656
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ((*(pDataline+1)>>5 ) ) );
7657
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ((*(pDataline+1)&0xFC ) << 3) );
7658
*pAlphaline = (mng_uint8)(*(pDataline+3));
7659
7660
pScanline += (pData->iColinc * 2);
7661
pAlphaline += pData->iColinc;
7662
pDataline += 4;
7663
}
7664
}
7665
}
7666
else /* Not fully opaque */
7667
{
7668
if (pData->bIsRGBA16) /* 16-bit input row ? */
7669
{
7670
7671
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7672
iX += pData->iColinc)
7673
{
7674
iA16 = mng_get_uint16 (pDataline+6);
7675
iBGa16 = (mng_uint16)(*pAlphaline);
7676
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
7677
7678
if (iA16) /* any opacity at all ? */
7679
{
7680
if ((iA16 == 0xFFFF) || (iBGa16 == 0)) /* fully opaque or background fully transparent ? */
7681
{ /* scale down by dropping the LSB */
7682
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
7683
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
7684
*pAlphaline = *(pDataline+6);
7685
}
7686
else
7687
{
7688
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
7689
{
7690
/* get the proper values */
7691
iFGr16 = mng_get_uint16 (pDataline );
7692
iFGg16 = mng_get_uint16 (pDataline+2);
7693
iFGb16 = mng_get_uint16 (pDataline+4);
7694
/* scale background up */
7695
7696
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7697
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7698
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
7699
7700
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7701
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7702
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7703
/* now compose */
7704
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
7705
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
7706
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
7707
/* and return the composed values */
7708
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
7709
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
7710
*pAlphaline = (mng_uint8)(iA16>>8);
7711
}
7712
else /* background is not fully opaque */
7713
{ /* scale background up */
7714
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7715
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7716
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
7717
7718
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7719
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7720
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7721
/* let's blend */
7722
MNG_BLEND16 (mng_get_uint16 (pDataline ),
7723
mng_get_uint16 (pDataline+2),
7724
mng_get_uint16 (pDataline+4), iA16,
7725
iBGr16, iBGg16, iBGb16, iBGa16,
7726
iCr16, iCg16, iCb16, iCa16);
7727
/* and return the composed values */
7728
*(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8)&0xF8 ) | ( (mng_uint8)(iCg16>>8) >> 5) );
7729
*pScanline = (mng_uint8) ( ( (iCb16>>11) ) | (((mng_uint8)(iCg16>>8)&0xFC) << 3) );
7730
*pAlphaline = (mng_uint8)(iCa16 >> 8);
7731
}
7732
}
7733
}
7734
7735
pScanline += (pData->iColinc * 2);
7736
pAlphaline += pData->iColinc;
7737
pDataline += 8;
7738
}
7739
}
7740
else
7741
{
7742
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7743
iX += pData->iColinc)
7744
{
7745
iA8 = *(pDataline+3); /* get alpha value */
7746
iBGa8 = *pAlphaline;
7747
7748
if (iA8) /* any opacity at all ? */
7749
{ /* fully opaque or background fully transparent ? */
7750
if ((iA8 == 0xFF) || (iBGa8 == 0))
7751
{ /* then simply copy the values */
7752
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
7753
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
7754
*pAlphaline = *(pDataline+3);
7755
}
7756
else
7757
{
7758
if (iBGa8 == 0xFF) /* background fully opaque ? */
7759
{
7760
/* do alpha composing */
7761
mng_uint8 iRed, iGreen, iBlue;
7762
7763
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7764
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
7765
iBlue = (mng_uint8) ( (*pScanline << 3) );
7766
7767
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
7768
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
7769
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
7770
7771
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
7772
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
7773
*pAlphaline = iA8;
7774
}
7775
else /* background not fully opaque */
7776
{
7777
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
7778
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
7779
iCr8, iCg8, iCb8, iCa8);
7780
/* and return the composed values */
7781
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
7782
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ((iCg8 & 0xFC) << 3) );
7783
*pAlphaline = iCa8;
7784
}
7785
}
7786
}
7787
7788
pScanline += (pData->iColinc * 2);
7789
pAlphaline += pData->iColinc;
7790
pDataline += 4;
7791
}
7792
}
7793
}
7794
}
7795
7796
check_update_region (pData);
7797
7798
#ifdef MNG_SUPPORT_TRACE
7799
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
7800
#endif
7801
7802
return MNG_NOERROR;
7803
}
7804
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7805
mng_retcode mng_display_bgr565_a8 (mng_datap pData)
7806
{
7807
mng_uint8p pScanline;
7808
mng_uint8p pAlphaline;
7809
mng_uint8p pDataline;
7810
mng_int32 iX;
7811
mng_uint16 iA16;
7812
mng_uint16 iFGr16, iFGg16, iFGb16;
7813
mng_uint16 iBGr16, iBGg16, iBGb16, iBGa16;
7814
mng_uint16 iCr16, iCg16, iCb16, iCa16;
7815
mng_uint8 iA8, iBGa8, iCa8;
7816
mng_uint8 iCr8, iCg8, iCb8;
7817
mng_uint8 iBps;
7818
7819
7820
#ifdef MNG_SUPPORT_TRACE
7821
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
7822
#endif
7823
7824
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
7825
/* viewable row ? */
7826
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
7827
{ /* address destination row */
7828
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
7829
pData->iRow + pData->iDestt -
7830
pData->iSourcet);
7831
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
7832
pData->iRow + pData->iDestt -
7833
pData->iSourcet);
7834
/* adjust destination row
7835
starting-point */
7836
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
7837
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
7838
pDataline = pData->pRGBArow; /* address source row */
7839
7840
/* adjust source row starting-point */
7841
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
7842
7843
if (pData->bIsOpaque) /* forget about transparency ? */
7844
{
7845
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7846
iX += pData->iColinc)
7847
{ /* scale down by dropping the LSB */
7848
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) |
7849
((*(pDataline+iBps)>>5) ) );
7850
*pScanline = (mng_uint8)( ( (*(pDataline+2*iBps)) >>3) |
7851
((*(pDataline+iBps)&0xFC) << 3) );
7852
*pAlphaline = (mng_uint8)(*(pDataline+6));
7853
7854
pScanline += (pData->iColinc * 2);
7855
pAlphaline += pData->iColinc;
7856
pDataline += 8;
7857
}
7858
}
7859
else /* Not fully opaque */
7860
{
7861
if (pData->bIsRGBA16) /* 16-bit input row ? */
7862
{
7863
7864
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7865
iX += pData->iColinc)
7866
{
7867
iA16 = mng_get_uint16 (pDataline+6);
7868
iBGa16 = (mng_uint16)(*pAlphaline);
7869
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
7870
7871
if (iA16) /* any opacity at all ? */
7872
{
7873
if ((iA16 == 0xFFFF) || (iBGa16 == 0)) /* fully opaque or background fully transparent ? */
7874
{ /* scale down by dropping the LSB */
7875
*(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 ) | (mng_uint8)( (*(pDataline+2)>>5 ) );
7876
*pScanline = (mng_uint8)( (*(pDataline+4)) >>3) | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
7877
*pAlphaline = *(pDataline+6);
7878
}
7879
else
7880
{
7881
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
7882
{
7883
/* get the proper values */
7884
iFGr16 = mng_get_uint16 (pDataline );
7885
iFGg16 = mng_get_uint16 (pDataline+2);
7886
iFGb16 = mng_get_uint16 (pDataline+4);
7887
/* scale background up */
7888
7889
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7890
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7891
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
7892
7893
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7894
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7895
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7896
/* now compose */
7897
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
7898
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
7899
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
7900
/* and return the composed values */
7901
*(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 ) | ( (mng_uint8)(iFGg16>>8) >> 5) );
7902
*pScanline = (mng_uint8) ( ( (iFGb16>>11) ) | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
7903
*pAlphaline = (mng_uint8)(iA16>>8);
7904
}
7905
else /* background is not fully opaque */
7906
{ /* scale background up */
7907
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7908
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7909
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
7910
7911
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
7912
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
7913
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
7914
/* let's blend */
7915
MNG_BLEND16 (mng_get_uint16 (pDataline ),
7916
mng_get_uint16 (pDataline+2),
7917
mng_get_uint16 (pDataline+4), iA16,
7918
iBGr16, iBGg16, iBGb16, iBGa16,
7919
iCr16, iCg16, iCb16, iCa16);
7920
/* and return the composed values */
7921
*(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8)&0xF8 ) | ( (mng_uint8)(iCg16>>8) >> 5) );
7922
*pScanline = (mng_uint8) ( ( (iCb16>>11) ) | (((mng_uint8)(iCg16>>8)&0xFC) << 3) );
7923
*pAlphaline = (mng_uint8)(iCa16 >> 8);
7924
}
7925
}
7926
}
7927
7928
pScanline += (pData->iColinc * 2);
7929
pAlphaline += pData->iColinc;
7930
pDataline += 8;
7931
}
7932
}
7933
else
7934
{
7935
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7936
iX += pData->iColinc)
7937
{
7938
iA8 = *(pDataline+3); /* get alpha value */
7939
iBGa8 = *pAlphaline;
7940
7941
if (iA8) /* any opacity at all ? */
7942
{ /* fully opaque or background fully transparent ? */
7943
if ((iA8 == 0xFF) || (iBGa8 == 0))
7944
{ /* then simply copy the values */
7945
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
7946
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
7947
*pAlphaline = *(pDataline+3);
7948
}
7949
else
7950
{
7951
if (iBGa8 == 0xFF) /* background fully opaque ? */
7952
{
7953
/* do alpha composing */
7954
mng_uint8 iRed, iGreen, iBlue;
7955
7956
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7957
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
7958
iBlue = (mng_uint8) ( (*pScanline << 3) );
7959
7960
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
7961
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
7962
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
7963
7964
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
7965
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
7966
*pAlphaline = iA8;
7967
}
7968
else /* background not fully opaque */
7969
{
7970
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
7971
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
7972
iCr8, iCg8, iCb8, iCa8);
7973
/* and return the composed values */
7974
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
7975
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ((iCg8 & 0xFC) << 3) );
7976
*pAlphaline = iCa8;
7977
}
7978
}
7979
}
7980
7981
pScanline += (pData->iColinc * 2);
7982
pAlphaline += pData->iColinc;
7983
pDataline += 4;
7984
}
7985
}
7986
}
7987
}
7988
7989
check_update_region (pData);
7990
7991
#ifdef MNG_SUPPORT_TRACE
7992
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
7993
#endif
7994
7995
return MNG_NOERROR;
7996
}
7997
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7998
#else /* MNG_NO_16BIT_SUPPORT */
7999
mng_retcode mng_display_bgr565_a8 (mng_datap pData)
8000
{
8001
mng_uint8p pScanline;
8002
mng_uint8p pAlphaline;
8003
mng_uint8p pDataline;
8004
mng_int32 iX;
8005
mng_uint8 iA8, iBGa8, iCa8;
8006
mng_uint8 iCr8, iCg8, iCb8;
8007
8008
8009
#ifdef MNG_SUPPORT_TRACE
8010
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
8011
#endif
8012
/* viewable row ? */
8013
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8014
{ /* address destination row */
8015
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8016
pData->iRow + pData->iDestt -
8017
pData->iSourcet);
8018
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
8019
pData->iRow + pData->iDestt -
8020
pData->iSourcet);
8021
/* adjust destination row
8022
starting-point */
8023
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8024
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
8025
pDataline = pData->pRGBArow; /* address source row */
8026
8027
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8028
8029
if (pData->bIsOpaque) /* forget about transparency ? */
8030
{
8031
{
8032
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8033
iX += pData->iColinc)
8034
{ /* copy the values */
8035
*(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ((*(pDataline+1)>>5 ) ) );
8036
*pScanline = (mng_uint8)( ( *(pDataline+2) >>3 ) | ((*(pDataline+1)&0xFC ) << 3) );
8037
*pAlphaline = (mng_uint8)(*(pDataline+3));
8038
8039
pScanline += (pData->iColinc * 2);
8040
pAlphaline += pData->iColinc;
8041
pDataline += 4;
8042
}
8043
}
8044
}
8045
else /* Not fully opaque */
8046
{
8047
{
8048
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8049
iX += pData->iColinc)
8050
{
8051
iA8 = *(pDataline+3); /* get alpha value */
8052
iBGa8 = *pAlphaline;
8053
8054
if (iA8) /* any opacity at all ? */
8055
{ /* fully opaque or background fully transparent ? */
8056
if ((iA8 == 0xFF) || (iBGa8 == 0))
8057
{ /* then simply copy the values */
8058
*(pScanline+1) = (mng_uint8)( ( (*(pDataline)) &0xF8 ) | (*(pDataline+1) >>5 ) );
8059
*pScanline = (mng_uint8)( ( ((*(pDataline+2))>>3) ) | ((*(pDataline+1)&0xFC) << 3) );
8060
*pAlphaline = *(pDataline+3);
8061
}
8062
else
8063
{
8064
if (iBGa8 == 0xFF) /* background fully opaque ? */
8065
{
8066
/* do alpha composing */
8067
mng_uint8 iRed, iGreen, iBlue;
8068
8069
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
8070
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
8071
iBlue = (mng_uint8) ( (*pScanline << 3) );
8072
8073
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
8074
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8075
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8076
8077
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
8078
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
8079
*pAlphaline = iA8;
8080
}
8081
else /* background not fully opaque */
8082
{
8083
MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
8084
*pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
8085
iCr8, iCg8, iCb8, iCa8);
8086
/* and return the composed values */
8087
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
8088
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ((iCg8 & 0xFC) << 3) );
8089
*pAlphaline = iCa8;
8090
}
8091
}
8092
}
8093
8094
pScanline += (pData->iColinc * 2);
8095
pAlphaline += pData->iColinc;
8096
pDataline += 4;
8097
}
8098
}
8099
}
8100
}
8101
8102
check_update_region (pData);
8103
8104
#ifdef MNG_SUPPORT_TRACE
8105
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
8106
#endif
8107
8108
return MNG_NOERROR;
8109
}
8110
#endif /* MNG_NO_16BIT_SUPPORT */
3768
8111
#endif /* MNG_SKIPCANVAS_BGR565_A8 */
3769
8112
3770
8113
/* ************************************************************************** */
8114
8115
#ifndef MNG_SKIPCANVAS_RGB555
8116
#ifndef MNG_NO_16BIT_SUPPORT
8117
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
8118
mng_retcode mng_display_rgb555 (mng_datap pData)
8119
{
8120
mng_uint8p pScanline;
8121
mng_uint8p pDataline;
8122
mng_int32 iX;
8123
mng_uint16 iA16;
8124
mng_uint16 iFGr16, iFGg16, iFGb16;
8125
mng_uint16 iBGr16, iBGg16, iBGb16;
8126
mng_uint8 iA8;
8127
8128
#ifdef MNG_SUPPORT_TRACE
8129
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
8130
#endif
8131
/* viewable row ? */
8132
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8133
{ /* address destination row */
8134
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8135
pData->iRow + pData->iDestt -
8136
pData->iSourcet);
8137
/* adjust destination row starting-point */
8138
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8139
pDataline = pData->pRGBArow; /* address source row */
8140
8141
if (pData->bIsRGBA16) /* adjust source row starting-point */
8142
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
8143
else
8144
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8145
8146
if (pData->bIsOpaque) /* forget about transparency ? */
8147
{
8148
if (pData->bIsRGBA16) /* 16-bit input row ? */
8149
{
8150
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8151
iX += pData->iColinc)
8152
{ /* scale down by dropping the LSB */
8153
*(pScanline+1) = (mng_uint8)( ((*(pDataline+4) & 0xF8) >> 1 ) | (*(pDataline+2) >> 6 ) );
8154
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
8155
8156
pScanline += (pData->iColinc * 2);
8157
pDataline += 8;
8158
}
8159
}
8160
else
8161
{
8162
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8163
iX += pData->iColinc)
8164
{ /* copy the values */
8165
*(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8166
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8167
8168
pScanline += (pData->iColinc * 2);
8169
pDataline += 4;
8170
}
8171
}
8172
}
8173
else
8174
{
8175
if (pData->bIsRGBA16) /* 16-bit input row ? */
8176
{
8177
8178
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8179
iX += pData->iColinc)
8180
{
8181
iA16 = mng_get_uint16 (pDataline+6);
8182
8183
if (iA16) /* any opacity at all ? */
8184
{
8185
if (iA16 == 0xFFFF) /* fully opaque ? */
8186
{ /* scale down by dropping the LSB */
8187
*(pScanline+1) = (mng_uint8)( ((*(pDataline+4) & 0xF8) >> 1 ) | (*(pDataline+2) >> 6 ) );
8188
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
8189
}
8190
else
8191
{ /* get the proper values */
8192
iFGr16 = mng_get_uint16 (pDataline );
8193
iFGg16 = mng_get_uint16 (pDataline+2);
8194
iFGb16 = mng_get_uint16 (pDataline+4);
8195
8196
/* scale background up */
8197
iBGr16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8198
iBGg16 = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8199
iBGb16 = (mng_uint8)( *(pScanline ) << 3 );
8200
8201
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
8202
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
8203
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
8204
/* now compose */
8205
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
8206
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
8207
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
8208
/* and return the composed values */
8209
*(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGb16 >> 8) & 0xF8) >> 1 ) | ( (mng_uint8)(iFGg16 >> 8) >> 6 ) );
8210
*pScanline = (mng_uint8)( (mng_uint8) ((iFGr16 >>11) >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
8211
}
8212
}
8213
8214
pScanline += (pData->iColinc * 2);
8215
pDataline += 8;
8216
}
8217
}
8218
else
8219
{
8220
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8221
iX += pData->iColinc)
8222
{
8223
iA8 = *(pDataline+3); /* get alpha value */
8224
8225
if (iA8) /* any opacity at all ? */
8226
{
8227
if (iA8 == 0xFF) /* fully opaque ? */
8228
{ /* then simply copy the values */
8229
*(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8230
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8231
}
8232
else
8233
{ /* do alpha composing */
8234
mng_uint8 iRed, iGreen, iBlue;
8235
8236
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8237
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8238
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8239
8240
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
8241
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8242
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
8243
8244
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8245
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8246
}
8247
}
8248
8249
pScanline += (pData->iColinc * 2);
8250
pDataline += 4;
8251
}
8252
}
8253
}
8254
}
8255
8256
check_update_region (pData);
8257
8258
#ifdef MNG_SUPPORT_TRACE
8259
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
8260
#endif
8261
8262
return MNG_NOERROR;
8263
}
8264
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8265
mng_retcode mng_display_rgb555 (mng_datap pData)
8266
{
8267
mng_uint8p pScanline;
8268
mng_uint8p pDataline;
8269
mng_int32 iX;
8270
mng_uint16 iA16;
8271
mng_uint16 iFGr16, iFGg16, iFGb16;
8272
mng_uint16 iBGr16, iBGg16, iBGb16;
8273
mng_uint8 iA8;
8274
mng_uint8 iBps;
8275
8276
#ifdef MNG_SUPPORT_TRACE
8277
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
8278
#endif
8279
8280
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
8281
/* viewable row ? */
8282
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8283
{ /* address destination row */
8284
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8285
pData->iRow + pData->iDestt -
8286
pData->iSourcet);
8287
/* adjust destination row starting-point */
8288
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8289
pDataline = pData->pRGBArow; /* address source row */
8290
8291
/* adjust source row starting-point */
8292
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
8293
8294
if (pData->bIsOpaque) /* forget about transparency ? */
8295
{
8296
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8297
iX += pData->iColinc)
8298
{ /* scale down by dropping the LSB */
8299
*(pScanline+1) = (mng_uint8)( ((*(pDataline+2*iBps) & 0xF8) >> 1 ) | (*(pDataline+iBps) >> 6 ) );
8300
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+iBps) & 0xF8) << 2 ) );
8301
8302
pScanline += (pData->iColinc * 2);
8303
pDataline += 4*iBps;
8304
}
8305
}
8306
else
8307
{
8308
if (pData->bIsRGBA16) /* 16-bit input row ? */
8309
{
8310
8311
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8312
iX += pData->iColinc)
8313
{
8314
iA16 = mng_get_uint16 (pDataline+6);
8315
8316
if (iA16) /* any opacity at all ? */
8317
{
8318
if (iA16 == 0xFFFF) /* fully opaque ? */
8319
{ /* scale down by dropping the LSB */
8320
*(pScanline+1) = (mng_uint8)( ((*(pDataline+4) & 0xF8) >> 1 ) | (*(pDataline+2) >> 6 ) );
8321
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
8322
}
8323
else
8324
{ /* get the proper values */
8325
iFGr16 = mng_get_uint16 (pDataline );
8326
iFGg16 = mng_get_uint16 (pDataline+2);
8327
iFGb16 = mng_get_uint16 (pDataline+4);
8328
8329
/* scale background up */
8330
iBGr16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8331
iBGg16 = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8332
iBGb16 = (mng_uint8)( *(pScanline ) << 3 );
8333
8334
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
8335
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
8336
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
8337
/* now compose */
8338
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
8339
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
8340
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
8341
/* and return the composed values */
8342
*(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGb16 >> 8) & 0xF8) >> 1 ) | ( (mng_uint8)(iFGg16 >> 8) >> 6 ) );
8343
*pScanline = (mng_uint8)( (mng_uint8) ((iFGr16 >>11) >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
8344
}
8345
}
8346
8347
pScanline += (pData->iColinc * 2);
8348
pDataline += 8;
8349
}
8350
}
8351
else
8352
{
8353
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8354
iX += pData->iColinc)
8355
{
8356
iA8 = *(pDataline+3); /* get alpha value */
8357
8358
if (iA8) /* any opacity at all ? */
8359
{
8360
if (iA8 == 0xFF) /* fully opaque ? */
8361
{ /* then simply copy the values */
8362
*(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8363
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8364
}
8365
else
8366
{ /* do alpha composing */
8367
mng_uint8 iRed, iGreen, iBlue;
8368
8369
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8370
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8371
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8372
8373
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
8374
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8375
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
8376
8377
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8378
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8379
}
8380
}
8381
8382
pScanline += (pData->iColinc * 2);
8383
pDataline += 4;
8384
}
8385
}
8386
}
8387
}
8388
8389
check_update_region (pData);
8390
8391
#ifdef MNG_SUPPORT_TRACE
8392
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
8393
#endif
8394
8395
return MNG_NOERROR;
8396
}
8397
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8398
#else /* MNG_NO_16BIT_SUPPORT */
8399
mng_retcode mng_display_rgb555 (mng_datap pData)
8400
{
8401
mng_uint8p pScanline;
8402
mng_uint8p pDataline;
8403
mng_int32 iX;
8404
mng_uint8 iA8;
8405
8406
#ifdef MNG_SUPPORT_TRACE
8407
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
8408
#endif
8409
/* viewable row ? */
8410
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8411
{ /* address destination row */
8412
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8413
pData->iRow + pData->iDestt -
8414
pData->iSourcet);
8415
/* adjust destination row starting-point */
8416
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8417
pDataline = pData->pRGBArow; /* address source row */
8418
8419
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8420
8421
if (pData->bIsOpaque) /* forget about transparency ? */
8422
{
8423
{
8424
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8425
iX += pData->iColinc)
8426
{ /* copy the values */
8427
*(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8428
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8429
8430
pScanline += (pData->iColinc * 2);
8431
pDataline += 4;
8432
}
8433
}
8434
}
8435
else
8436
{
8437
{
8438
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8439
iX += pData->iColinc)
8440
{
8441
iA8 = *(pDataline+3); /* get alpha value */
8442
8443
if (iA8) /* any opacity at all ? */
8444
{
8445
if (iA8 == 0xFF) /* fully opaque ? */
8446
{ /* then simply copy the values */
8447
*(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8448
*pScanline = (mng_uint8)( ( *(pDataline ) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8449
}
8450
else
8451
{ /* do alpha composing */
8452
mng_uint8 iRed, iGreen, iBlue;
8453
8454
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8455
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8456
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8457
8458
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
8459
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8460
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
8461
8462
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8463
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8464
}
8465
}
8466
8467
pScanline += (pData->iColinc * 2);
8468
pDataline += 4;
8469
}
8470
}
8471
}
8472
}
8473
8474
check_update_region (pData);
8475
8476
#ifdef MNG_SUPPORT_TRACE
8477
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
8478
#endif
8479
8480
return MNG_NOERROR;
8481
}
8482
#endif /* MNG_NO_16BIT_SUPPORT */
8483
#endif /* MNG_SKIPCANVAS_RGB555 */
8484
8485
/* ************************************************************************** */
8486
8487
#ifndef MNG_SKIPCANVAS_BGR555
8488
#ifndef MNG_NO_16BIT_SUPPORT
8489
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
8490
mng_retcode mng_display_bgr555 (mng_datap pData)
8491
{
8492
mng_uint8p pScanline;
8493
mng_uint8p pDataline;
8494
mng_int32 iX;
8495
mng_uint16 iA16;
8496
mng_uint16 iFGr16, iFGg16, iFGb16;
8497
mng_uint16 iBGr16, iBGg16, iBGb16;
8498
mng_uint8 iA8;
8499
8500
#ifdef MNG_SUPPORT_TRACE
8501
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
8502
#endif
8503
/* viewable row ? */
8504
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8505
{ /* address destination row */
8506
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8507
pData->iRow + pData->iDestt -
8508
pData->iSourcet);
8509
/* adjust destination row starting-point */
8510
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8511
pDataline = pData->pRGBArow; /* address source row */
8512
8513
if (pData->bIsRGBA16) /* adjust source row starting-point */
8514
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
8515
else
8516
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8517
8518
if (pData->bIsOpaque) /* forget about transparency ? */
8519
{
8520
if (pData->bIsRGBA16) /* 16-bit input row ? */
8521
{
8522
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8523
iX += pData->iColinc)
8524
{ /* scale down by dropping the LSB */
8525
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+2) >> 6 ) );
8526
*pScanline = (mng_uint8)( ( *(pDataline+4) >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
8527
8528
pScanline += (pData->iColinc * 2);
8529
pDataline += 8;
8530
}
8531
}
8532
else
8533
{
8534
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8535
iX += pData->iColinc)
8536
{ /* copy the values */
8537
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8538
*pScanline = (mng_uint8)( ( *(pDataline+2) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8539
8540
pScanline += (pData->iColinc * 2);
8541
pDataline += 4;
8542
}
8543
}
8544
}
8545
else
8546
{
8547
if (pData->bIsRGBA16) /* 16-bit input row ? */
8548
{
8549
8550
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8551
iX += pData->iColinc)
8552
{
8553
iA16 = mng_get_uint16 (pDataline+6);
8554
8555
if (iA16) /* any opacity at all ? */
8556
{
8557
if (iA16 == 0xFFFF) /* fully opaque ? */
8558
{ /* scale down by dropping the LSB */
8559
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+2) >> 6 ) );
8560
*pScanline = (mng_uint8)( ( *(pDataline+4) >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
8561
}
8562
else
8563
{ /* get the proper values */
8564
iFGr16 = mng_get_uint16 (pDataline );
8565
iFGg16 = mng_get_uint16 (pDataline+2);
8566
iFGb16 = mng_get_uint16 (pDataline+4);
8567
8568
/* scale background up */
8569
iBGb16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8570
iBGg16 = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8571
iBGr16 = (mng_uint8)( *(pScanline ) << 3 );
8572
8573
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
8574
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
8575
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
8576
/* now compose */
8577
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
8578
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
8579
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
8580
/* and return the composed values */
8581
*(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGr16 >> 8) & 0xF8) >> 1 ) | ( (mng_uint8)(iFGg16 >> 8) >> 6 ) );
8582
*pScanline = (mng_uint8)( (mng_uint8) ((iFGb16 >>11) >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
8583
}
8584
}
8585
8586
pScanline += (pData->iColinc * 2);
8587
pDataline += 8;
8588
}
8589
}
8590
else
8591
{
8592
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8593
iX += pData->iColinc)
8594
{
8595
iA8 = *(pDataline+3); /* get alpha value */
8596
8597
if (iA8) /* any opacity at all ? */
8598
{
8599
if (iA8 == 0xFF) /* fully opaque ? */
8600
{ /* then simply copy the values */
8601
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8602
*pScanline = (mng_uint8)( ( *(pDataline+2) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8603
}
8604
else
8605
{ /* do alpha composing */
8606
mng_uint8 iRed, iGreen, iBlue;
8607
8608
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8609
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8610
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8611
8612
MNG_COMPOSE8 (iRed, *(pDataline+0), iA8, iRed );
8613
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8614
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8615
8616
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8617
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8618
}
8619
}
8620
8621
pScanline += (pData->iColinc * 2);
8622
pDataline += 4;
8623
}
8624
}
8625
}
8626
}
8627
8628
check_update_region (pData);
8629
8630
#ifdef MNG_SUPPORT_TRACE
8631
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
8632
#endif
8633
8634
return MNG_NOERROR;
8635
}
8636
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8637
mng_retcode mng_display_bgr555 (mng_datap pData)
8638
{
8639
mng_uint8p pScanline;
8640
mng_uint8p pDataline;
8641
mng_int32 iX;
8642
mng_uint16 iA16;
8643
mng_uint16 iFGr16, iFGg16, iFGb16;
8644
mng_uint16 iBGr16, iBGg16, iBGb16;
8645
mng_uint8 iA8;
8646
mng_uint8 iBps;
8647
8648
#ifdef MNG_SUPPORT_TRACE
8649
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
8650
#endif
8651
8652
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
8653
/* viewable row ? */
8654
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8655
{ /* address destination row */
8656
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8657
pData->iRow + pData->iDestt -
8658
pData->iSourcet);
8659
/* adjust destination row starting-point */
8660
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8661
pDataline = pData->pRGBArow; /* address source row */
8662
8663
/* adjust source row starting-point */
8664
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
8665
8666
if (pData->bIsOpaque) /* forget about transparency ? */
8667
{
8668
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8669
iX += pData->iColinc)
8670
{ /* scale down by dropping the LSB */
8671
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+iBps) >> 6 ) );
8672
*pScanline = (mng_uint8)( ( *(pDataline+2*iBps) >> 3 ) | ((*(pDataline+iBps) & 0xF8) << 2 ) );
8673
8674
pScanline += (pData->iColinc * 2);
8675
pDataline += 4*iBps;
8676
}
8677
}
8678
else
8679
{
8680
if (pData->bIsRGBA16) /* 16-bit input row ? */
8681
{
8682
8683
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8684
iX += pData->iColinc)
8685
{
8686
iA16 = mng_get_uint16 (pDataline+6);
8687
8688
if (iA16) /* any opacity at all ? */
8689
{
8690
if (iA16 == 0xFFFF) /* fully opaque ? */
8691
{ /* scale down by dropping the LSB */
8692
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+2) >> 6 ) );
8693
*pScanline = (mng_uint8)( ( *(pDataline+4) >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
8694
}
8695
else
8696
{ /* get the proper values */
8697
iFGr16 = mng_get_uint16 (pDataline );
8698
iFGg16 = mng_get_uint16 (pDataline+2);
8699
iFGb16 = mng_get_uint16 (pDataline+4);
8700
8701
/* scale background up */
8702
iBGb16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8703
iBGg16 = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8704
iBGr16 = (mng_uint8)( *(pScanline ) << 3 );
8705
8706
iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
8707
iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
8708
iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
8709
/* now compose */
8710
MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
8711
MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
8712
MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
8713
/* and return the composed values */
8714
*(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGr16 >> 8) & 0xF8) >> 1 ) | ( (mng_uint8)(iFGg16 >> 8) >> 6 ) );
8715
*pScanline = (mng_uint8)( (mng_uint8) ((iFGb16 >>11) >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
8716
}
8717
}
8718
8719
pScanline += (pData->iColinc * 2);
8720
pDataline += 8;
8721
}
8722
}
8723
else
8724
{
8725
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8726
iX += pData->iColinc)
8727
{
8728
iA8 = *(pDataline+3); /* get alpha value */
8729
8730
if (iA8) /* any opacity at all ? */
8731
{
8732
if (iA8 == 0xFF) /* fully opaque ? */
8733
{ /* then simply copy the values */
8734
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8735
*pScanline = (mng_uint8)( ( *(pDataline+2) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8736
}
8737
else
8738
{ /* do alpha composing */
8739
mng_uint8 iRed, iGreen, iBlue;
8740
8741
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8742
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8743
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8744
8745
MNG_COMPOSE8 (iRed, *(pDataline+0), iA8, iRed );
8746
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8747
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8748
8749
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8750
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8751
}
8752
}
8753
8754
pScanline += (pData->iColinc * 2);
8755
pDataline += 4;
8756
}
8757
}
8758
}
8759
}
8760
8761
check_update_region (pData);
8762
8763
#ifdef MNG_SUPPORT_TRACE
8764
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
8765
#endif
8766
8767
return MNG_NOERROR;
8768
}
8769
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8770
#else /* MNG_NO_16BIT_SUPPORT */
8771
mng_retcode mng_display_bgr555 (mng_datap pData)
8772
{
8773
mng_uint8p pScanline;
8774
mng_uint8p pDataline;
8775
mng_int32 iX;
8776
mng_uint8 iA8;
8777
8778
#ifdef MNG_SUPPORT_TRACE
8779
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
8780
#endif
8781
/* viewable row ? */
8782
if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
8783
{ /* address destination row */
8784
pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
8785
pData->iRow + pData->iDestt -
8786
pData->iSourcet);
8787
/* adjust destination row starting-point */
8788
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8789
pDataline = pData->pRGBArow; /* address source row */
8790
8791
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8792
8793
if (pData->bIsOpaque) /* forget about transparency ? */
8794
{
8795
{
8796
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8797
iX += pData->iColinc)
8798
{ /* copy the values */
8799
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8800
*pScanline = (mng_uint8)( ( *(pDataline+2) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8801
8802
pScanline += (pData->iColinc * 2);
8803
pDataline += 4;
8804
}
8805
}
8806
}
8807
else
8808
{
8809
{
8810
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8811
iX += pData->iColinc)
8812
{
8813
iA8 = *(pDataline+3); /* get alpha value */
8814
8815
if (iA8) /* any opacity at all ? */
8816
{
8817
if (iA8 == 0xFF) /* fully opaque ? */
8818
{ /* then simply copy the values */
8819
*(pScanline+1) = (mng_uint8)( ((*(pDataline ) & 0xF8) >> 1 ) | (*(pDataline+1) >> 6 ) );
8820
*pScanline = (mng_uint8)( ( *(pDataline+2) >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
8821
}
8822
else
8823
{ /* do alpha composing */
8824
mng_uint8 iRed, iGreen, iBlue;
8825
8826
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8827
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8828
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8829
8830
MNG_COMPOSE8 (iRed, *(pDataline+0), iA8, iRed );
8831
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8832
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8833
8834
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8835
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8836
}
8837
}
8838
8839
pScanline += (pData->iColinc * 2);
8840
pDataline += 4;
8841
}
8842
}
8843
}
8844
}
8845
8846
check_update_region (pData);
8847
8848
#ifdef MNG_SUPPORT_TRACE
8849
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
8850
#endif
8851
8852
return MNG_NOERROR;
8853
}
8854
#endif /* MNG_NO_16BIT_SUPPORT */
8855
#endif /* MNG_SKIPCANVAS_BGR555 */
8856
8857
8858
#ifndef MNG_SKIPCHUNK_BACK
3771
8859
/* ************************************************************************** */
3772
8860
/* * * */
3773
8861
/* * Background restore routines - restore the background with info from * */
3863
8951
3864
8952
return MNG_NOERROR;
3865
8953
}
8954
#endif
3866
8955
3867
8956
/* ************************************************************************** */
3868
8957
3958
9047
3959
9048
break;
3960
9049
}
3961
9050
3962
9051
case 3 : { /* indexed type */
3963
9052
iRed = pBuf->aPLTEentries [pBuf->iBKGDindex].iRed;
3964
9053
iGreen = pBuf->aPLTEentries [pBuf->iBKGDindex].iGreen;
4237
9326
#ifdef MNG_SUPPORT_TRACE
4238
9327
MNG_TRACE (pData, MNG_FN_RESTORE_RGB565, MNG_LC_START);
4239
9328
#endif
4240
9329
4241
9330
if (pData->fGetbkgdline) /* can we access the background ? */
4242
9331
{ /* point to the right pixel then */
4243
9332
pBkgd = (mng_uint8p)pData->fGetbkgdline ((mng_handle)pData,
4250
9339
*(pWork+1) = (mng_uint8)( (*(pBkgd+1) << 5) | ( ((*pBkgd)&0xE0)>>3 ) );
4251
9340
*(pWork+2) = (mng_uint8)( *(pBkgd+1) << 3);
4252
9341
*(pWork+3) = 0x00; /* transparant for alpha-canvasses */
4253
9342
4254
9343
pWork += 4;
4255
9344
pBkgd += 2;
4256
9345
}
4804
9893
/* * * */
4805
9894
/* ************************************************************************** */
4806
9895
9896
#ifndef MNG_NO_1_2_4BIT_SUPPORT
4807
9897
mng_retcode mng_store_g1 (mng_datap pData)
4808
9898
{
4809
9899
mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
4957
10047
4958
10048
return MNG_NOERROR;
4959
10049
}
10050
#endif
4960
10051
4961
10052
/* ************************************************************************** */
4962
10053
5110
10201
5111
10202
/* ************************************************************************** */
5112
10203
10204
#ifndef MNG_NO_1_2_4BIT_SUPPORT
5113
10205
mng_retcode mng_store_idx1 (mng_datap pData)
5114
10206
{
5115
10207
mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
5259
10351
5260
10352
return MNG_NOERROR;
5261
10353
}
10354
#endif
5262
10355
5263
10356
/* ************************************************************************** */
5264
10357
5669
10762
5670
10763
/* ************************************************************************** */
5671
10764
10765
#ifndef MNG_NO_1_2_4BIT_SUPPORT
5672
10766
mng_retcode mng_store_jpeg_g8_a1 (mng_datap pData)
5673
10767
{
5674
10768
mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
5835
10929
/* we've got one more row of alpha-samples */
5836
10930
return mng_next_jpeg_alpharow (pData);
5837
10931
}
10932
#endif
5838
10933
5839
10934
/* ************************************************************************** */
5840
10935
5912
11007
5913
11008
/* ************************************************************************** */
5914
11009
11010
#ifndef MNG_NO_1_2_4BIT_SUPPORT
5915
11011
mng_retcode mng_store_jpeg_rgb8_a1 (mng_datap pData)
5916
11012
{
5917
11013
mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
6078
11174
/* we've got one more row of alpha-samples */
6079
11175
return mng_next_jpeg_alpharow (pData);
6080
11176
}
11177
#endif
6081
11178
6082
11179
/* ************************************************************************** */
6083
11180
6932
12029
6933
12030
/* ************************************************************************** */
6934
12031
12032
#ifndef MNG_NO_1_2_4BIT_SUPPORT
6935
12033
mng_retcode mng_delta_idx1 (mng_datap pData)
6936
12034
{
6937
12035
mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
7164
12262
7165
12263
return mng_store_idx4 (pData);
7166
12264
}
12265
#endif
7167
12266
7168
12267
/* ************************************************************************** */
7169
12268
7471
12570
/* * * */
7472
12571
/* ************************************************************************** */
7473
12572
12573
#ifndef MNG_NO_1_2_4BIT_SUPPORT
7474
12574
mng_retcode mng_delta_g1_g1 (mng_datap pData)
7475
12575
{
7476
12576
mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
7606
12706
7607
12707
return MNG_NOERROR;
7608
12708
}
12709
#endif
7609
12710
7610
12711
/* ************************************************************************** */
7611
12712
9333
14434
/* * * */
9334
14435
/* ************************************************************************** */
9335
14436
14437
#ifndef MNG_NO_1_2_4BIT_SUPPORT
9336
14438
mng_uint8 mng_promote_replicate_1_2 (mng_uint8 iB)
9337
14439
{
9338
14440
return (mng_uint8)((iB << 1) | iB);
9409
14511
return (mng_uint16)(((mng_uint16)iB << 8) + (mng_uint16)iB);
9410
14512
}
9411
14513
#endif
14514
#endif /* NO_1_2_4BIT_SUPPORT */
9412
14515
9413
14516
/* ************************************************************************** */
9414
14517
9422
14525
/* ************************************************************************** */
9423
14526
9424
14527
#if !defined(MNG_NO_DELTA_PNG)
14528
#ifndef MNG_NO_1_2_4BIT_SUPPORT
9425
14529
mng_uint8 mng_promote_zerofill_1_2 (mng_uint8 iB)
9426
14530
{
9427
14531
return (mng_uint8)(iB << 1);
9488
14592
return (mng_uint16)((mng_uint16)iB << 12);
9489
14593
}
9490
14594
#endif
14595
#endif /* MNG_NO_1_2_4BIT_SUPPORT */
9491
14596
9492
14597
/* ************************************************************************** */
9493
14598
13997
19102
without alpha!!! */
13998
19103
if (pData->iRowmax)
13999
19104
{
19105
#if defined(MNG_NO_16BIT_SUPPORT) || defined (MNG_NO_1_2_4BIT_SUPPORT)
19106
mng_uint8 iRowadd = 0;
19107
#ifdef MNG_NO_1_2_4BIT_SUPPORT
19108
if (pData->iPNGdepth < 8)
19109
iRowadd=(pData->iPNGdepth*pData->iRowmax+7)/8;
19110
#endif
14000
19111
#ifdef MNG_NO_16BIT_SUPPORT
14001
MNG_ALLOC (pData, pData->pWorkrow, pData->iPNGmult*pData->iRowmax);
14002
MNG_ALLOC (pData, pData->pPrevrow, pData->iPNGmult*pData->iRowmax);
19112
if (pData->iPNGdepth > 8)
19113
iRowadd=pData->iRowmax;
19114
#endif
19115
MNG_ALLOC (pData, pData->pWorkrow, pData->iRowmax+iRowadd);
19116
MNG_ALLOC (pData, pData->pPrevrow, pData->iRowmax+iRowadd);
14003
19117
#else
14004
MNG_ALLOC (pData, pData->pWorkrow, pData->iRowmax);
14005
MNG_ALLOC (pData, pData->pPrevrow, pData->iRowmax);
19118
MNG_ALLOC (pData, pData->pWorkrow, pData->iRowmax);
19119
MNG_ALLOC (pData, pData->pPrevrow, pData->iRowmax);
14006
19120
#endif
14007
19121
}
14008
19122
14114
19228
#ifdef MNG_INCLUDE_LCMS /* cleanup cms profile/transform */
14115
19229
{
14116
19230
mng_retcode iRetcode = mng_clear_cms (pData);
14117
14118
19231
if (iRetcode) /* on error bail out */
14119
19232
return iRetcode;
14120
19233
}
14121
19234
#endif /* MNG_INCLUDE_LCMS */
14122
19235
19236
if (pData->pRGBArow) /* cleanup buffer for intermediate row */
19237
MNG_FREEX (pData, pData->pRGBArow, (pData->iDatawidth << 3));
19238
if (pData->pPrevrow) /* cleanup buffer for previous row */
19239
MNG_FREEX (pData, pData->pPrevrow, pData->iRowmax);
14123
19240
if (pData->pWorkrow) /* cleanup buffer for working row */
14124
MNG_FREE (pData, pData->pWorkrow, pData->iRowmax);
14125
14126
if (pData->pPrevrow) /* cleanup buffer for previous row */
14127
MNG_FREE (pData, pData->pPrevrow, pData->iRowmax);
14128
14129
if (pData->pRGBArow) /* cleanup buffer for intermediate row */
14130
MNG_FREE (pData, pData->pRGBArow, (pData->iDatawidth << 3));
14131
14132
pData->pWorkrow = 0; /* propogate uninitialized buffers */
14133
pData->pPrevrow = 0;
14134
pData->pRGBArow = 0;
19241
MNG_FREEX (pData, pData->pWorkrow, pData->iRowmax);
19242
19243
pData->pWorkrow = MNG_NULL; /* propogate uninitialized buffers */
19244
pData->pPrevrow = MNG_NULL;
19245
pData->pRGBArow = MNG_NULL;
14135
19246
14136
19247
#ifdef MNG_SUPPORT_TRACE
14137
19248
MNG_TRACE (pData, MNG_FN_CLEANUP_ROWPROC, MNG_LC_END);
14225
19336
MNG_TRACE (pData, MNG_FN_NEXT_JPEG_ALPHAROW, MNG_LC_END);
14226
19337
#endif
14227
19338
14228
return MNG_NOERROR;
19339
return MNG_NOERROR;
14229
19340
}
14230
19341
14231
19342
/* ************************************************************************** */
14239
19350
#endif
14240
19351
14241
19352
pData->iJPEGrow++; /* increase the row-counter */
14242
19353
14243
19354
if (pData->fDisplayrow) /* display "on-the-fly" ? */
14244
19355
{ /* has alpha channel ? */
14245
19356
if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
14288
19399
14289
19400
#ifndef MNG_SKIPCHUNK_MAGN
14290
19401
#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
19402
#ifndef MNG_NO_GRAY_SUPPORT
14291
19403
mng_retcode mng_magnify_g8_x1 (mng_datap pData,
14292
19404
mng_uint16 iMX,
14293
19405
mng_uint16 iML,
14513
19625
14514
19626
return MNG_NOERROR;
14515
19627
}
19628
#endif /* MNG_NO_GRAY_SUPPORT */
14516
19629
14517
19630
/* ************************************************************************** */
14518
19631
14728
19841
{
14729
19842
if (pTempsrc2) /* do we have the second pixel ? */
14730
19843
{
14731
iH = (iM+1) / 2; /* calculate halfway point */
19844
iH = (iM+1) / 2; /* calculate halfway point */
14732
19845
14733
19846
for (iS = 1; iS < iH; iS++) /* replicate first half */
14734
19847
{
14774
19887
14775
19888
/* ************************************************************************** */
14776
19889
19890
#ifndef MNG_NO_GRAY_SUPPORT
14777
19891
mng_retcode mng_magnify_ga8_x1 (mng_datap pData,
14778
19892
mng_uint16 iMX,
14779
19893
mng_uint16 iML,
15216
20330
15217
20331
return MNG_NOERROR;
15218
20332
}
20333
#endif /* MNG_NO_GRAY_SUPPORT */
15219
20334
#endif /* MNG_OPTIMIZE_FOOTPRINT_MAGN */
15220
20335
15221
20336
/* ************************************************************************** */
15764
20879
/* ************************************************************************** */
15765
20880
15766
20881
#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
20882
#ifndef MNG_NO_GRAY_SUPPORT
15767
20883
mng_retcode mng_magnify_g8_y1 (mng_datap pData,
15768
20884
mng_int32 iS,
15769
20885
mng_int32 iM,
15867
20983
15868
20984
return MNG_NOERROR;
15869
20985
}
20986
#endif /* MNG_NO_GRAY_SUPPORT */
15870
20987
15871
20988
/* ************************************************************************** */
15872
20989
15999
21116
16000
21117
/* ************************************************************************** */
16001
21118
21119
#ifndef MNG_NO_GRAY_SUPPORT
16002
21120
mng_retcode mng_magnify_ga8_y1 (mng_datap pData,
16003
21121
mng_int32 iS,
16004
21122
mng_int32 iM,
16270
21388
16271
21389
return MNG_NOERROR;
16272
21390
}
21391
#endif /* MNG_NO_GRAY_SUPPORT */
16273
21392
#endif /* MNG_OPTIMIZE_FOOTPRINT_MAGN */
16274
21393
16275
21394
/* ************************************************************************** */
16616
21735
16617
21736
#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
16618
21737
#ifndef MNG_NO_16BIT_SUPPORT
21738
#ifndef MNG_NO_GRAY_SUPPORT
16619
21739
mng_retcode mng_magnify_g16_x1 (mng_datap pData,
16620
21740
mng_uint16 iMX,
16621
21741
mng_uint16 iML,
16842
21962
16843
21963
return MNG_NOERROR;
16844
21964
}
21965
#endif /* MNG_NO_GRAY_SUPPORT */
16845
21966
16846
21967
/* ************************************************************************** */
16847
21968
17060
22181
{
17061
22182
if (pTempsrc2) /* do we have the second pixel ? */
17062
22183
{
17063
iH = (iM+1) / 2; /* calculate halfway point */
22184
iH = (iM+1) / 2; /* calculate halfway point */
17064
22185
17065
22186
for (iS = 1; iS < iH; iS++) /* replicate first half */
17066
22187
{
17106
22227
17107
22228
/* ************************************************************************** */
17108
22229
22230
#ifndef MNG_NO_GRAY_SUPPORT
17109
22231
mng_retcode mng_magnify_ga16_x1 (mng_datap pData,
17110
22232
mng_uint16 iMX,
17111
22233
mng_uint16 iML,
17554
22676
17555
22677
return MNG_NOERROR;
17556
22678
}
22679
#endif /* MNG_NO_GRAY_SUPPORT */
17557
22680
17558
22681
/* ************************************************************************** */
17559
22682
18112
23235
18113
23236
/* ************************************************************************** */
18114
23237
23238
#ifndef MNG_NO_GRAY_SUPPORT
18115
23239
mng_retcode mng_magnify_g16_y1 (mng_datap pData,
18116
23240
mng_int32 iS,
18117
23241
mng_int32 iM,
18217
23341
18218
23342
return MNG_NOERROR;
18219
23343
}
23344
#endif /* MNG_NO_GRAY_SUPPORT */
18220
23345
18221
23346
/* ************************************************************************** */
18222
23347
18352
23477
18353
23478
/* ************************************************************************** */
18354
23479
23480
#ifndef MNG_NO_GRAY_SUPPORT
18355
23481
mng_retcode mng_magnify_ga16_y1 (mng_datap pData,
18356
23482
mng_int32 iS,
18357
23483
mng_int32 iM,
18629
23755
18630
23756
return MNG_NOERROR;
18631
23757
}
23758
#endif /* MNG_NO_GRAY_SUPPORT */
18632
23759
18633
23760
/* ************************************************************************** */
18634
23761
19481
24608
/* ************************************************************************** */
19482
24609
/* * end of file * */
19483
24610
/* ************************************************************************** */
19484
Loggerhead is a web-based interface for Breezy
Version: 2.0.1