666
834
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
667
835
*(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
668
836
/* alpha remains fully opaque !!! */
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;
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);
694
pScanline += (pData->iColinc << 2);
701
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
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;
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);
861
pScanline += (pData->iColinc << 2);
867
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
868
iX += pData->iColinc)
870
iFGa8 = *(pDataline+3); /* get alpha values */
871
iBGa8 = *(pScanline+3);
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);
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 !!! */
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 */
898
*(pScanline+1) = iCg8;
899
*(pScanline+2) = iCb8;
900
*(pScanline+3) = iCa8;
905
pScanline += (pData->iColinc << 2);
912
check_update_region (pData);
914
#ifdef MNG_SUPPORT_TRACE
915
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
920
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
921
mng_retcode mng_display_rgba8 (mng_datap pData)
923
mng_uint8p pScanline;
924
mng_uint8p pDataline;
926
mng_uint8 iFGa8, iBGa8, iCa8;
927
mng_uint16 iFGa16, iBGa16, iCa16;
929
mng_uint16 iBGr16, iBGg16, iBGb16;
930
mng_uint16 iCr16, iCg16, iCb16;
931
mng_uint8 iCr8, iCg8, iCb8;
934
#ifdef MNG_SUPPORT_TRACE
935
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
938
iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
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 -
945
/* adjust destination row starting-point */
946
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
947
pDataline = pData->pRGBArow; /* address source row */
949
/* adjust source row starting-point */
950
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
952
if (pData->bIsOpaque) /* forget about transparency ? */
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);
962
pScanline += (pData->iColinc << 2);
968
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
988
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
989
{ /* get the proper values */
991
for (i=2; i >= 0; i--)
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;
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 !!! */
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;
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);
1027
pScanline += (pData->iColinc << 2);
1033
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1034
iX += pData->iColinc)
1036
iFGa8 = *(pDataline+3); /* get alpha values */
1037
iBGa8 = *(pScanline+3);
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);
1050
if (iBGa8 == 0xFF) /* background fully opaque ? */
1051
{ /* do alpha composing */
1053
for (i=2; i >= 0; i--)
1055
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
1057
/* alpha remains fully opaque !!! */
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 */
1066
*(pScanline+1) = iCg8;
1067
*(pScanline+2) = iCb8;
1068
*(pScanline+3) = iCa8;
1073
pScanline += (pData->iColinc << 2);
1080
check_update_region (pData);
1082
#ifdef MNG_SUPPORT_TRACE
1083
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
1088
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1089
#else /* MNG_NO_16BIT_SUPPORT */
1090
mng_retcode mng_display_rgba8 (mng_datap pData)
1092
mng_uint8p pScanline;
1093
mng_uint8p pDataline;
1095
mng_uint8 iFGa8, iBGa8, iCa8;
1096
mng_uint8 iCr8, iCg8, iCb8;
1098
#ifdef MNG_SUPPORT_TRACE
1099
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
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 -
1107
/* adjust destination row starting-point */
1108
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1109
pDataline = pData->pRGBArow; /* address source row */
1111
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1113
if (pData->bIsOpaque) /* forget about transparency ? */
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);
1124
pScanline += (pData->iColinc << 2);
1132
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1133
iX += pData->iColinc)
703
1135
iFGa8 = *(pDataline+3); /* get alpha values */
704
1136
iBGa8 = *(pScanline+3);
783
1218
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
784
1219
pDataline = pData->pRGBArow; /* address source row */
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);
791
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
793
if (pData->bIsOpaque) /* forget about transparency ? */
795
#ifndef MNG_NO_16BIT_SUPPORT
796
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
806
pScanline[0] = pDataline[0];
807
pScanline[1] = pDataline[2];
808
pScanline[2] = pDataline[4];
813
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
815
for (i=2; i >= 0; i--)
817
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
820
pScanline[0] = DIV255B8(s * pDataline[0]);
821
pScanline[1] = DIV255B8(s * pDataline[2]);
822
pScanline[2] = DIV255B8(s * pDataline[4]);
824
pScanline[3] = (mng_uint8)s;
827
pScanline += (pData->iColinc << 2);
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 */
842
#ifdef MNG_BIGENDIAN_SUPPORTED
843
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
845
pScanline[0] = pDataline[0];
846
pScanline[1] = pDataline[1];
847
pScanline[2] = pDataline[2];
853
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
855
for (i=2; i >= 0; i--)
857
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
860
pScanline[0] = DIV255B8(s * pDataline[0]);
861
pScanline[1] = DIV255B8(s * pDataline[1]);
862
pScanline[2] = DIV255B8(s * pDataline[2]);
864
pScanline[3] = (mng_uint8)s;
868
pScanline += (pData->iColinc << 2);
875
#ifndef MNG_NO_16BIT_SUPPORT
876
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
883
{ /* plain copy it */
884
pScanline[0] = pDataline[0];
885
pScanline[1] = pDataline[2];
886
pScanline[2] = pDataline[4];
890
{ /* now blend (premultiplied) */
892
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
895
for (i=2; i >= 0; i--)
897
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
906
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
910
pScanline += (pData->iColinc << 2);
917
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
919
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
920
{ /* fully opaque ? */
922
{ /* then simply copy the values */
923
#ifdef MNG_BIGENDIAN_SUPPORTED
924
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
926
pScanline[0] = pDataline[0];
927
pScanline[1] = pDataline[1];
928
pScanline[2] = pDataline[2];
933
{ /* now blend (premultiplied) */
935
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
938
for (i=2; i >= 0; i--)
940
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
949
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
953
pScanline += (pData->iColinc << 2);
960
check_update_region (pData);
962
#ifdef MNG_SUPPORT_TRACE
963
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1224
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1226
if (pData->bIsOpaque) /* forget about transparency ? */
1228
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
1239
pScanline[0] = pDataline[0];
1240
pScanline[1] = pDataline[2];
1241
pScanline[2] = pDataline[4];
1246
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1248
for (i=2; i >= 0; i--)
1250
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
1253
pScanline[0] = DIV255B8(s * pDataline[0]);
1254
pScanline[1] = DIV255B8(s * pDataline[2]);
1255
pScanline[2] = DIV255B8(s * pDataline[4]);
1257
pScanline[3] = (mng_uint8)s;
1260
pScanline += (pData->iColinc << 2);
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 */
1275
#ifdef MNG_BIGENDIAN_SUPPORTED
1276
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1278
pScanline[0] = pDataline[0];
1279
pScanline[1] = pDataline[1];
1280
pScanline[2] = pDataline[2];
1286
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1288
for (i=2; i >= 0; i--)
1290
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
1293
pScanline[0] = DIV255B8(s * pDataline[0]);
1294
pScanline[1] = DIV255B8(s * pDataline[1]);
1295
pScanline[2] = DIV255B8(s * pDataline[2]);
1297
pScanline[3] = (mng_uint8)s;
1301
pScanline += (pData->iColinc << 2);
1308
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
1316
{ /* plain copy it */
1317
pScanline[0] = pDataline[0];
1318
pScanline[1] = pDataline[2];
1319
pScanline[2] = pDataline[4];
1323
{ /* now blend (premultiplied) */
1325
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1328
for (i=2; i >= 0; i--)
1330
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
1339
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1343
pScanline += (pData->iColinc << 2);
1349
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1350
iX += pData->iColinc)
1352
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1353
{ /* fully opaque ? */
1355
{ /* then simply copy the values */
1356
#ifdef MNG_BIGENDIAN_SUPPORTED
1357
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1359
pScanline[0] = pDataline[0];
1360
pScanline[1] = pDataline[1];
1361
pScanline[2] = pDataline[2];
1366
{ /* now blend (premultiplied) */
1368
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1371
for (i=2; i >= 0; i--)
1373
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
1382
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1386
pScanline += (pData->iColinc << 2);
1393
check_update_region (pData);
1395
#ifdef MNG_SUPPORT_TRACE
1396
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1401
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1402
mng_retcode mng_display_rgba8_pm (mng_datap pData)
1404
mng_uint8p pScanline;
1405
mng_uint8p pDataline;
1410
#ifdef MNG_SUPPORT_TRACE
1411
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
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 -
1421
/* adjust destination row starting-point */
1422
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1423
pDataline = pData->pRGBArow; /* address source row */
1425
/* adjust source row starting-point */
1426
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
1428
if (pData->bIsOpaque) /* forget about transparency ? */
1430
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
1441
pScanline[0] = pDataline[0];
1442
pScanline[1] = pDataline[2];
1443
pScanline[2] = pDataline[4];
1448
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1450
for (i=2; i >= 0; i--)
1452
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
1455
pScanline[0] = DIV255B8(s * pDataline[0]);
1456
pScanline[1] = DIV255B8(s * pDataline[2]);
1457
pScanline[2] = DIV255B8(s * pDataline[4]);
1459
pScanline[3] = (mng_uint8)s;
1462
pScanline += (pData->iColinc << 2);
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 */
1477
#ifdef MNG_BIGENDIAN_SUPPORTED
1478
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1480
pScanline[0] = pDataline[0];
1481
pScanline[1] = pDataline[1];
1482
pScanline[2] = pDataline[2];
1488
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1490
for (i=2; i >= 0; i--)
1492
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
1495
pScanline[0] = DIV255B8(s * pDataline[0]);
1496
pScanline[1] = DIV255B8(s * pDataline[1]);
1497
pScanline[2] = DIV255B8(s * pDataline[2]);
1499
pScanline[3] = (mng_uint8)s;
1503
pScanline += (pData->iColinc << 2);
1510
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
1518
{ /* plain copy it */
1519
pScanline[0] = pDataline[0];
1520
pScanline[1] = pDataline[2];
1521
pScanline[2] = pDataline[4];
1525
{ /* now blend (premultiplied) */
1527
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1530
for (i=2; i >= 0; i--)
1532
pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
1541
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1545
pScanline += (pData->iColinc << 2);
1551
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1552
iX += pData->iColinc)
1554
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1555
{ /* fully opaque ? */
1557
{ /* then simply copy the values */
1558
#ifdef MNG_BIGENDIAN_SUPPORTED
1559
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1561
pScanline[0] = pDataline[0];
1562
pScanline[1] = pDataline[1];
1563
pScanline[2] = pDataline[2];
1568
{ /* now blend (premultiplied) */
1570
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1573
for (i=2; i >= 0; i--)
1575
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
1584
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1588
pScanline += (pData->iColinc << 2);
1595
check_update_region (pData);
1597
#ifdef MNG_SUPPORT_TRACE
1598
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1603
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
1604
#else /* MNG_NO_16BIT_SUPPORT */
1605
mng_retcode mng_display_rgba8_pm (mng_datap pData)
1607
mng_uint8p pScanline;
1608
mng_uint8p pDataline;
1612
#ifdef MNG_SUPPORT_TRACE
1613
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
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 -
1621
/* adjust destination row starting-point */
1622
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1623
pDataline = pData->pRGBArow; /* address source row */
1625
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1627
if (pData->bIsOpaque) /* forget about transparency ? */
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 */
1639
#ifdef MNG_BIGENDIAN_SUPPORTED
1640
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1642
pScanline[0] = pDataline[0];
1643
pScanline[1] = pDataline[1];
1644
pScanline[2] = pDataline[2];
1650
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1652
for (i=2; i >= 0; i--)
1654
pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
1657
pScanline[0] = DIV255B8(s * pDataline[0]);
1658
pScanline[1] = DIV255B8(s * pDataline[1]);
1659
pScanline[2] = DIV255B8(s * pDataline[2]);
1661
pScanline[3] = (mng_uint8)s;
1665
pScanline += (pData->iColinc << 2);
1673
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
1674
iX += pData->iColinc)
1676
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1677
{ /* fully opaque ? */
1679
{ /* then simply copy the values */
1680
#ifdef MNG_BIGENDIAN_SUPPORTED
1681
*(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
1683
pScanline[0] = pDataline[0];
1684
pScanline[1] = pDataline[1];
1685
pScanline[2] = pDataline[2];
1690
{ /* now blend (premultiplied) */
1692
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1695
for (i=2; i >= 0; i--)
1697
pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
1706
pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
1710
pScanline += (pData->iColinc << 2);
1717
check_update_region (pData);
1719
#ifdef MNG_SUPPORT_TRACE
1720
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
1725
#endif /* MNG_NO_16BIT_SUPPORT */
968
1726
#endif /* MNG_SKIPCANVAS_RGBA8_PM */
970
1728
/* ************************************************************************** */
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)
975
1735
mng_uint8p pScanline;
976
1736
mng_uint8p pDataline;
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;
986
1741
mng_uint16 iBGr16, iBGg16, iBGb16;
987
1742
mng_uint16 iCr16, iCg16, iCb16;
989
1743
mng_uint8 iCr8, iCg8, iCb8;
991
1745
#ifdef MNG_SUPPORT_TRACE
1215
2217
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
1216
2218
pDataline = pData->pRGBArow; /* address source row */
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);
1223
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
1225
if (pData->bIsOpaque) /* forget about transparency ? */
1227
#ifndef MNG_NO_16BIT_SUPPORT
1228
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
1239
pScanline[1] = pDataline[0];
1240
pScanline[2] = pDataline[2];
1241
pScanline[3] = pDataline[4];
1245
pScanline[0] = (mng_uint8)s;
1246
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1249
for (i=2; i >= 0; i--)
1251
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
1255
pScanline[1] = DIV255B8(s * pDataline[0]);
1256
pScanline[2] = DIV255B8(s * pDataline[2]);
1257
pScanline[3] = DIV255B8(s * pDataline[4]);
1261
pScanline += (pData->iColinc << 2);
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 */
1277
pScanline[1] = pDataline[0];
1278
pScanline[2] = pDataline[1];
1279
pScanline[3] = pDataline[2];
1283
pScanline[0] = (mng_uint8)s;
1284
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1287
for (i=2; i >= 0; i--)
1289
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
1293
pScanline[1] = DIV255B8(s * pDataline[0]);
1294
pScanline[2] = DIV255B8(s * pDataline[1]);
1295
pScanline[3] = DIV255B8(s * pDataline[2]);
1300
pScanline += (pData->iColinc << 2);
1307
#ifndef MNG_NO_16BIT_SUPPORT
1308
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
1315
{ /* plain copy it */
1317
pScanline[1] = pDataline[0];
1318
pScanline[2] = pDataline[2];
1319
pScanline[3] = pDataline[4];
1322
{ /* now blend (premultiplied) */
1324
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
1325
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1328
for (i=2; i >= 0; i--)
1330
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
1342
pScanline += (pData->iColinc << 2);
1349
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
1351
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
1352
{ /* fully opaque ? */
1354
{ /* then simply copy the values */
1356
pScanline[1] = pDataline[0];
1357
pScanline[2] = pDataline[1];
1358
pScanline[3] = pDataline[2];
1361
{ /* now blend (premultiplied) */
1363
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
1364
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
1367
for (i=2; i >= 0; i--)
1369
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
1381
pScanline += (pData->iColinc << 2);
1388
check_update_region (pData);
1390
#ifdef MNG_SUPPORT_TRACE
1391
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2223
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2225
if (pData->bIsOpaque) /* forget about transparency ? */
2227
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
2239
pScanline[1] = pDataline[0];
2240
pScanline[2] = pDataline[2];
2241
pScanline[3] = pDataline[4];
2245
pScanline[0] = (mng_uint8)s;
2246
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2249
for (i=2; i >= 0; i--)
2251
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
2255
pScanline[1] = DIV255B8(s * pDataline[0]);
2256
pScanline[2] = DIV255B8(s * pDataline[2]);
2257
pScanline[3] = DIV255B8(s * pDataline[4]);
2261
pScanline += (pData->iColinc << 2);
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 */
2277
pScanline[1] = pDataline[0];
2278
pScanline[2] = pDataline[1];
2279
pScanline[3] = pDataline[2];
2283
pScanline[0] = (mng_uint8)s;
2284
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2287
for (i=2; i >= 0; i--)
2289
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
2293
pScanline[1] = DIV255B8(s * pDataline[0]);
2294
pScanline[2] = DIV255B8(s * pDataline[1]);
2295
pScanline[3] = DIV255B8(s * pDataline[2]);
2300
pScanline += (pData->iColinc << 2);
2307
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
2315
{ /* plain copy it */
2317
pScanline[1] = pDataline[0];
2318
pScanline[2] = pDataline[2];
2319
pScanline[3] = pDataline[4];
2322
{ /* now blend (premultiplied) */
2324
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2325
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2328
for (i=2; i >= 0; i--)
2330
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
2342
pScanline += (pData->iColinc << 2);
2348
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2349
iX += pData->iColinc)
2351
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2352
{ /* fully opaque ? */
2354
{ /* then simply copy the values */
2356
pScanline[1] = pDataline[0];
2357
pScanline[2] = pDataline[1];
2358
pScanline[3] = pDataline[2];
2361
{ /* now blend (premultiplied) */
2363
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2364
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2367
for (i=2; i >= 0; i--)
2369
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
2381
pScanline += (pData->iColinc << 2);
2388
check_update_region (pData);
2390
#ifdef MNG_SUPPORT_TRACE
2391
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2396
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2397
mng_retcode mng_display_argb8_pm (mng_datap pData)
2399
mng_uint8p pScanline;
2400
mng_uint8p pDataline;
2405
#ifdef MNG_SUPPORT_TRACE
2406
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
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 -
2416
/* adjust destination row starting-point */
2417
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2418
pDataline = pData->pRGBArow; /* address source row */
2420
/* adjust source row starting-point */
2421
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
2423
if (pData->bIsOpaque) /* forget about transparency ? */
2425
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
2437
pScanline[1] = pDataline[0];
2438
pScanline[2] = pDataline[2];
2439
pScanline[3] = pDataline[4];
2443
pScanline[0] = (mng_uint8)s;
2444
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2447
for (i=2; i >= 0; i--)
2449
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
2453
pScanline[1] = DIV255B8(s * pDataline[0]);
2454
pScanline[2] = DIV255B8(s * pDataline[2]);
2455
pScanline[3] = DIV255B8(s * pDataline[4]);
2459
pScanline += (pData->iColinc << 2);
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 */
2475
pScanline[1] = pDataline[0];
2476
pScanline[2] = pDataline[1];
2477
pScanline[3] = pDataline[2];
2481
pScanline[0] = (mng_uint8)s;
2482
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2485
for (i=2; i >= 0; i--)
2487
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
2491
pScanline[1] = DIV255B8(s * pDataline[0]);
2492
pScanline[2] = DIV255B8(s * pDataline[1]);
2493
pScanline[3] = DIV255B8(s * pDataline[2]);
2498
pScanline += (pData->iColinc << 2);
2505
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
2513
{ /* plain copy it */
2515
pScanline[1] = pDataline[0];
2516
pScanline[2] = pDataline[2];
2517
pScanline[3] = pDataline[4];
2520
{ /* now blend (premultiplied) */
2522
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2523
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2526
for (i=2; i >= 0; i--)
2528
pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
2540
pScanline += (pData->iColinc << 2);
2546
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2547
iX += pData->iColinc)
2549
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2550
{ /* fully opaque ? */
2552
{ /* then simply copy the values */
2554
pScanline[1] = pDataline[0];
2555
pScanline[2] = pDataline[1];
2556
pScanline[3] = pDataline[2];
2559
{ /* now blend (premultiplied) */
2561
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2562
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2565
for (i=2; i >= 0; i--)
2567
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
2579
pScanline += (pData->iColinc << 2);
2586
check_update_region (pData);
2588
#ifdef MNG_SUPPORT_TRACE
2589
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2594
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2595
#else /* MNG_NO_16BIT_SUPPORT */
2596
mng_retcode mng_display_argb8_pm (mng_datap pData)
2598
mng_uint8p pScanline;
2599
mng_uint8p pDataline;
2603
#ifdef MNG_SUPPORT_TRACE
2604
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
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 -
2612
/* adjust destination row starting-point */
2613
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2614
pDataline = pData->pRGBArow; /* address source row */
2616
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2618
if (pData->bIsOpaque) /* forget about transparency ? */
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 */
2631
pScanline[1] = pDataline[0];
2632
pScanline[2] = pDataline[1];
2633
pScanline[3] = pDataline[2];
2637
pScanline[0] = (mng_uint8)s;
2638
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2641
for (i=2; i >= 0; i--)
2643
pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
2647
pScanline[1] = DIV255B8(s * pDataline[0]);
2648
pScanline[2] = DIV255B8(s * pDataline[1]);
2649
pScanline[3] = DIV255B8(s * pDataline[2]);
2654
pScanline += (pData->iColinc << 2);
2662
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2663
iX += pData->iColinc)
2665
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2666
{ /* fully opaque ? */
2668
{ /* then simply copy the values */
2670
pScanline[1] = pDataline[0];
2671
pScanline[2] = pDataline[1];
2672
pScanline[3] = pDataline[2];
2675
{ /* now blend (premultiplied) */
2677
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2678
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2681
for (i=2; i >= 0; i--)
2683
pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
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]);
2695
pScanline += (pData->iColinc << 2);
2702
check_update_region (pData);
2704
#ifdef MNG_SUPPORT_TRACE
2705
MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
2710
#endif /* MNG_NO_16BIT_SUPPORT */
1396
2711
#endif /* MNG_SKIPCANVAS_ARGB8_PM */
1398
2713
/* ************************************************************************** */
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)
1403
2720
mng_uint8p pScanline;
1533
2827
*(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
1534
2828
*(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
1535
2829
/* alpha remains fully opaque !!! */
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;
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);
1561
pScanline += (pData->iColinc * 3);
1562
pAlphaline += pData->iColinc;
1569
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
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;
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);
2854
pScanline += (pData->iColinc * 3);
2855
pAlphaline += pData->iColinc;
2861
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
2862
iX += pData->iColinc)
2864
iFGa8 = *(pDataline+3); /* get alpha values */
2865
iBGa8 = *pAlphaline;
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);
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 !!! */
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 */
2892
*(pScanline+1) = iCg8;
2893
*(pScanline+2) = iCb8;
2899
pScanline += (pData->iColinc * 3);
2900
pAlphaline += pData->iColinc;
2907
check_update_region (pData);
2909
#ifdef MNG_SUPPORT_TRACE
2910
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
2915
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
2916
mng_retcode mng_display_rgb8_a8 (mng_datap pData)
2918
mng_uint8p pScanline;
2919
mng_uint8p pAlphaline;
2920
mng_uint8p pDataline;
2922
mng_uint8 iFGa8, iBGa8, iCa8;
2923
mng_uint16 iFGa16, iBGa16, iCa16;
2925
mng_uint16 iBGr16, iBGg16, iBGb16;
2926
mng_uint16 iCr16, iCg16, iCb16;
2927
mng_uint8 iCr8, iCg8, iCb8;
2930
#ifdef MNG_SUPPORT_TRACE
2931
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
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 -
2941
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
2942
pData->iRow + pData->iDestt -
2944
/* adjust destination rows starting-point */
2945
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
2946
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
2948
pDataline = pData->pRGBArow; /* address source row */
2950
/* adjust source row starting-point */
2951
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
2953
if (pData->bIsOpaque) /* forget about transparency ? */
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);
2963
pScanline += (pData->iColinc * 3);
2964
pAlphaline += pData->iColinc;
2965
pDataline += 4*iBps;
2970
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
2990
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
2991
{ /* get the proper values */
2993
for (i=2; i >= 0; i--)
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;
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 !!! */
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;
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);
3029
pScanline += (pData->iColinc * 3);
3030
pAlphaline += pData->iColinc;
3036
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3037
iX += pData->iColinc)
3039
iFGa8 = *(pDataline+3); /* get alpha values */
3040
iBGa8 = *pAlphaline;
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);
3053
if (iBGa8 == 0xFF) /* background fully opaque ? */
3054
{ /* do alpha composing */
3056
for (i=2; i >= 0; i--)
3058
MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
3060
/* alpha remains fully opaque !!! */
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 */
3069
*(pScanline+1) = iCg8;
3070
*(pScanline+2) = iCb8;
3076
pScanline += (pData->iColinc * 3);
3077
pAlphaline += pData->iColinc;
3084
check_update_region (pData);
3086
#ifdef MNG_SUPPORT_TRACE
3087
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
3092
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
3093
#else /* MNG_NO_16BIT_SUPPORT */
3094
mng_retcode mng_display_rgb8_a8 (mng_datap pData)
3096
mng_uint8p pScanline;
3097
mng_uint8p pAlphaline;
3098
mng_uint8p pDataline;
3100
mng_uint8 iFGa8, iBGa8, iCa8;
3101
mng_uint8 iCr8, iCg8, iCb8;
3103
#ifdef MNG_SUPPORT_TRACE
3104
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
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 -
3112
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
3113
pData->iRow + pData->iDestt -
3115
/* adjust destination rows starting-point */
3116
pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
3117
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
3119
pDataline = pData->pRGBArow; /* address source row */
3121
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
3123
if (pData->bIsOpaque) /* forget about transparency ? */
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);
3134
pScanline += (pData->iColinc * 3);
3135
pAlphaline += pData->iColinc;
3143
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3144
iX += pData->iColinc)
1571
3146
iFGa8 = *(pDataline+3); /* get alpha values */
1572
3147
iBGa8 = *pAlphaline;
2657
5380
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
2658
5381
pDataline = pData->pRGBArow; /* address source row */
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);
2665
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
2667
if (pData->bIsOpaque) /* forget about transparency ? */
2669
#ifndef MNG_NO_16BIT_SUPPORT
2670
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
2681
pScanline[1] = pDataline[4];
2682
pScanline[2] = pDataline[2];
2683
pScanline[3] = pDataline[0];
2687
pScanline[0] = (mng_uint8)s;
2688
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2691
for (i=2; i >= 0; i--)
2693
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
2697
pScanline[1] = DIV255B8(s * pDataline[4]);
2698
pScanline[2] = DIV255B8(s * pDataline[2]);
2699
pScanline[3] = DIV255B8(s * pDataline[0]);
2703
pScanline += (pData->iColinc << 2);
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 */
2719
pScanline[1] = pDataline[2];
2720
pScanline[2] = pDataline[1];
2721
pScanline[3] = pDataline[0];
2725
pScanline[0] = (mng_uint8)s;
2726
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2729
for (i=2; i >= 0; i--)
2731
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
2735
pScanline[1] = DIV255B8(s * pDataline[2]);
2736
pScanline[2] = DIV255B8(s * pDataline[1]);
2737
pScanline[3] = DIV255B8(s * pDataline[0]);
2742
pScanline += (pData->iColinc << 2);
2749
#ifndef MNG_NO_16BIT_SUPPORT
2750
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
2757
{ /* plain copy it */
2759
pScanline[1] = pDataline[4];
2760
pScanline[2] = pDataline[2];
2761
pScanline[3] = pDataline[0];
2764
{ /* now blend (premultiplied) */
2766
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2767
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2770
for (i=2; i >= 0; i--)
2772
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
2784
pScanline += (pData->iColinc << 2);
2791
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2793
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
2794
{ /* fully opaque ? */
2796
{ /* then simply copy the values */
2798
pScanline[1] = pDataline[2];
2799
pScanline[2] = pDataline[1];
2800
pScanline[3] = pDataline[0];
2803
{ /* now blend (premultiplied) */
2805
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
2806
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
2809
for (i=2; i >= 0; i--)
2811
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
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]);
2823
pScanline += (pData->iColinc << 2);
2830
check_update_region (pData);
2832
#ifdef MNG_SUPPORT_TRACE
2833
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5386
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
5388
if (pData->bIsOpaque) /* forget about transparency ? */
5390
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
5402
pScanline[1] = pDataline[4];
5403
pScanline[2] = pDataline[2];
5404
pScanline[3] = pDataline[0];
5408
pScanline[0] = (mng_uint8)s;
5409
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5412
for (i=2; i >= 0; i--)
5414
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
5418
pScanline[1] = DIV255B8(s * pDataline[4]);
5419
pScanline[2] = DIV255B8(s * pDataline[2]);
5420
pScanline[3] = DIV255B8(s * pDataline[0]);
5424
pScanline += (pData->iColinc << 2);
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 */
5440
pScanline[1] = pDataline[2];
5441
pScanline[2] = pDataline[1];
5442
pScanline[3] = pDataline[0];
5446
pScanline[0] = (mng_uint8)s;
5447
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5450
for (i=2; i >= 0; i--)
5452
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
5456
pScanline[1] = DIV255B8(s * pDataline[2]);
5457
pScanline[2] = DIV255B8(s * pDataline[1]);
5458
pScanline[3] = DIV255B8(s * pDataline[0]);
5463
pScanline += (pData->iColinc << 2);
5470
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
5478
{ /* plain copy it */
5480
pScanline[1] = pDataline[4];
5481
pScanline[2] = pDataline[2];
5482
pScanline[3] = pDataline[0];
5485
{ /* now blend (premultiplied) */
5487
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5488
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5491
for (i=2; i >= 0; i--)
5493
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
5505
pScanline += (pData->iColinc << 2);
5511
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5512
iX += pData->iColinc)
5514
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
5515
{ /* fully opaque ? */
5517
{ /* then simply copy the values */
5519
pScanline[1] = pDataline[2];
5520
pScanline[2] = pDataline[1];
5521
pScanline[3] = pDataline[0];
5524
{ /* now blend (premultiplied) */
5526
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5527
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5530
for (i=2; i >= 0; i--)
5532
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
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]);
5544
pScanline += (pData->iColinc << 2);
5551
check_update_region (pData);
5553
#ifdef MNG_SUPPORT_TRACE
5554
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5559
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
5560
mng_retcode mng_display_abgr8_pm (mng_datap pData)
5562
mng_uint8p pScanline;
5563
mng_uint8p pDataline;
5568
#ifdef MNG_SUPPORT_TRACE
5569
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
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 -
5579
/* adjust destination row starting-point */
5580
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
5581
pDataline = pData->pRGBArow; /* address source row */
5583
/* adjust source row starting-point */
5584
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
5586
if (pData->bIsOpaque) /* forget about transparency ? */
5588
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 */
5600
pScanline[1] = pDataline[4];
5601
pScanline[2] = pDataline[2];
5602
pScanline[3] = pDataline[0];
5606
pScanline[0] = (mng_uint8)s;
5607
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5610
for (i=2; i >= 0; i--)
5612
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
5616
pScanline[1] = DIV255B8(s * pDataline[4]);
5617
pScanline[2] = DIV255B8(s * pDataline[2]);
5618
pScanline[3] = DIV255B8(s * pDataline[0]);
5622
pScanline += (pData->iColinc << 2);
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 */
5638
pScanline[1] = pDataline[2];
5639
pScanline[2] = pDataline[1];
5640
pScanline[3] = pDataline[0];
5644
pScanline[0] = (mng_uint8)s;
5645
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5648
for (i=2; i >= 0; i--)
5650
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
5654
pScanline[1] = DIV255B8(s * pDataline[2]);
5655
pScanline[2] = DIV255B8(s * pDataline[1]);
5656
pScanline[3] = DIV255B8(s * pDataline[0]);
5661
pScanline += (pData->iColinc << 2);
5668
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ? */
5676
{ /* plain copy it */
5678
pScanline[1] = pDataline[4];
5679
pScanline[2] = pDataline[2];
5680
pScanline[3] = pDataline[0];
5683
{ /* now blend (premultiplied) */
5685
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5686
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5689
for (i=2; i >= 0; i--)
5691
pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
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]);
5703
pScanline += (pData->iColinc << 2);
5709
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5710
iX += pData->iColinc)
5712
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
5713
{ /* fully opaque ? */
5715
{ /* then simply copy the values */
5717
pScanline[1] = pDataline[2];
5718
pScanline[2] = pDataline[1];
5719
pScanline[3] = pDataline[0];
5722
{ /* now blend (premultiplied) */
5724
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5725
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5728
for (i=2; i >= 0; i--)
5730
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
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]);
5742
pScanline += (pData->iColinc << 2);
5749
check_update_region (pData);
5751
#ifdef MNG_SUPPORT_TRACE
5752
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5757
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
5758
#else /* MNG_NO_16BIT_SUPPORT */
5759
mng_retcode mng_display_abgr8_pm (mng_datap pData)
5761
mng_uint8p pScanline;
5762
mng_uint8p pDataline;
5766
#ifdef MNG_SUPPORT_TRACE
5767
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
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 -
5775
/* adjust destination row starting-point */
5776
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
5777
pDataline = pData->pRGBArow; /* address source row */
5779
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
5781
if (pData->bIsOpaque) /* forget about transparency ? */
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 */
5794
pScanline[1] = pDataline[2];
5795
pScanline[2] = pDataline[1];
5796
pScanline[3] = pDataline[0];
5800
pScanline[0] = (mng_uint8)s;
5801
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5804
for (i=2; i >= 0; i--)
5806
pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
5810
pScanline[1] = DIV255B8(s * pDataline[2]);
5811
pScanline[2] = DIV255B8(s * pDataline[1]);
5812
pScanline[3] = DIV255B8(s * pDataline[0]);
5817
pScanline += (pData->iColinc << 2);
5825
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5826
iX += pData->iColinc)
5828
if ((s = pDataline[3]) != 0) /* any opacity at all ? */
5829
{ /* fully opaque ? */
5831
{ /* then simply copy the values */
5833
pScanline[1] = pDataline[2];
5834
pScanline[2] = pDataline[1];
5835
pScanline[3] = pDataline[0];
5838
{ /* now blend (premultiplied) */
5840
pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
5841
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
5844
for (i=2; i >= 0; i--)
5846
pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
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]);
5858
pScanline += (pData->iColinc << 2);
5865
check_update_region (pData);
5867
#ifdef MNG_SUPPORT_TRACE
5868
MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
5873
#endif /* MNG_NO_16BIT_SUPPORT */
2838
5874
#endif /* MNG_SKIPCANVAS_ABGR8_PM */
2840
5876
/* ************************************************************************** */
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)
2845
5883
mng_uint8p pScanline;
2846
5884
mng_uint8p pDataline;
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;
2855
5891
#ifdef MNG_SUPPORT_TRACE
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) );
2898
pScanline += (pData->iColinc * 2);
2905
#ifndef MNG_NO_16BIT_SUPPORT
2906
if (pData->bIsRGBA16) /* 16-bit input row ? */
2909
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2911
iA16 = mng_get_uint16 (pDataline+6);
2913
if (iA16) /* any opacity at all ? */
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);
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 */
2927
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
2928
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
2929
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
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;
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) );
2944
pScanline += (pData->iColinc * 2);
2951
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
2953
iA8 = *(pDataline+3); /* get alpha value */
2955
if (iA8) /* any opacity at all ? */
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) );
2963
{ /* do alpha composing */
2964
mng_uint8 iRed, iGreen, iBlue;
2966
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
2967
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
2968
iBlue = (mng_uint8) ( (*pScanline << 3) );
2970
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
2971
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
2972
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
2974
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
2975
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
2979
pScanline += (pData->iColinc * 2);
2986
check_update_region (pData);
2988
#ifdef MNG_SUPPORT_TRACE
2989
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
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) );
5932
pScanline += (pData->iColinc * 2);
5939
if (pData->bIsRGBA16) /* 16-bit input row ? */
5942
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5943
iX += pData->iColinc)
5945
iA16 = mng_get_uint16 (pDataline+6);
5947
if (iA16) /* any opacity at all ? */
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);
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 */
5961
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
5962
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
5963
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
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;
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) );
5978
pScanline += (pData->iColinc * 2);
5984
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
5985
iX += pData->iColinc)
5987
iA8 = *(pDataline+3); /* get alpha value */
5989
if (iA8) /* any opacity at all ? */
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) );
5997
{ /* do alpha composing */
5998
mng_uint8 iRed, iGreen, iBlue;
6000
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6001
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6002
iBlue = (mng_uint8) ( (*pScanline << 3) );
6004
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
6005
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6006
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
6008
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6009
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6013
pScanline += (pData->iColinc * 2);
6020
check_update_region (pData);
6022
#ifdef MNG_SUPPORT_TRACE
6023
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
6028
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6029
mng_retcode mng_display_bgr565 (mng_datap pData)
6031
mng_uint8p pScanline;
6032
mng_uint8p pDataline;
6035
mng_uint16 iFGr16, iFGg16, iFGb16;
6036
mng_uint16 iBGr16, iBGg16, iBGb16;
6040
#ifdef MNG_SUPPORT_TRACE
6041
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
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 -
6051
/* adjust destination row starting-point */
6052
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6053
pDataline = pData->pRGBArow; /* address source row */
6055
/* adjust source row starting-point */
6056
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
6058
if (pData->bIsOpaque) /* forget about transparency ? */
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) );
6068
pScanline += (pData->iColinc * 2);
6069
pDataline += 4*iBps;
6074
if (pData->bIsRGBA16) /* 16-bit input row ? */
6077
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6078
iX += pData->iColinc)
6080
iA16 = mng_get_uint16 (pDataline+6);
6082
if (iA16) /* any opacity at all ? */
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);
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 */
6096
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
6097
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
6098
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
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;
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) );
6113
pScanline += (pData->iColinc * 2);
6119
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6120
iX += pData->iColinc)
6122
iA8 = *(pDataline+3); /* get alpha value */
6124
if (iA8) /* any opacity at all ? */
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) );
6132
{ /* do alpha composing */
6133
mng_uint8 iRed, iGreen, iBlue;
6135
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6136
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6137
iBlue = (mng_uint8) ( (*pScanline << 3) );
6139
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
6140
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6141
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
6143
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6144
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6148
pScanline += (pData->iColinc * 2);
6155
check_update_region (pData);
6157
#ifdef MNG_SUPPORT_TRACE
6158
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
6163
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6164
#else /* MNG_NO_16BIT_SUPPORT */
6165
mng_retcode mng_display_bgr565 (mng_datap pData)
6167
mng_uint8p pScanline;
6168
mng_uint8p pDataline;
6172
#ifdef MNG_SUPPORT_TRACE
6173
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
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 -
6181
/* adjust destination row starting-point */
6182
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6183
pDataline = pData->pRGBArow; /* address source row */
6185
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
6187
if (pData->bIsOpaque) /* forget about transparency ? */
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) );
6197
pScanline += (pData->iColinc * 2);
6205
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6206
iX += pData->iColinc)
6208
iA8 = *(pDataline+3); /* get alpha value */
6210
if (iA8) /* any opacity at all ? */
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) );
6218
{ /* do alpha composing */
6219
mng_uint8 iRed, iGreen, iBlue;
6221
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6222
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6223
iBlue = (mng_uint8) ( (*pScanline << 3) );
6225
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
6226
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6227
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
6229
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
6230
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6234
pScanline += (pData->iColinc * 2);
6241
check_update_region (pData);
6243
#ifdef MNG_SUPPORT_TRACE
6244
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
6249
#endif /* MNG_NO_16BIT_SUPPORT */
2994
6250
#endif /* MNG_SKIPCANVAS_BGR565 */
2996
6252
/* ************************************************************************** */
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)
3001
6259
mng_uint8p pScanline;
3002
6260
mng_uint8p pDataline;
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;
3011
6267
#ifdef MNG_SUPPORT_TRACE
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) );
3053
pScanline += (pData->iColinc * 2);
3060
#ifndef MNG_NO_16BIT_SUPPORT
3061
if (pData->bIsRGBA16) /* 16-bit input row ? */
3064
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3066
iA16 = mng_get_uint16 (pDataline+6);
3068
if (iA16) /* any opacity at all ? */
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) );
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);
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 );
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;
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) );
3099
pScanline += (pData->iColinc * 2);
3106
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3108
iA8 = *(pDataline+3); /* get alpha value */
3110
if (iA8) /* any opacity at all ? */
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 ) );
3118
{ /* do alpha composing */
3119
mng_uint8 iRed, iGreen, iBlue;
3121
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
3122
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
3123
iBlue = (mng_uint8)( *(pScanline ) << 3 );
3125
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
3126
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
3127
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
3129
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
3130
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
3134
pScanline += (pData->iColinc * 2);
3141
check_update_region (pData);
3143
#ifdef MNG_SUPPORT_TRACE
3144
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
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) );
6307
pScanline += (pData->iColinc * 2);
6314
if (pData->bIsRGBA16) /* 16-bit input row ? */
6317
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6318
iX += pData->iColinc)
6320
iA16 = mng_get_uint16 (pDataline+6);
6322
if (iA16) /* any opacity at all ? */
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) );
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);
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 );
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;
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) );
6353
pScanline += (pData->iColinc * 2);
6359
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6360
iX += pData->iColinc)
6362
iA8 = *(pDataline+3); /* get alpha value */
6364
if (iA8) /* any opacity at all ? */
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 ) );
6372
{ /* do alpha composing */
6373
mng_uint8 iRed, iGreen, iBlue;
6375
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
6376
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
6377
iBlue = (mng_uint8)( *(pScanline ) << 3 );
6379
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
6380
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6381
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
6383
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
6384
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6388
pScanline += (pData->iColinc * 2);
6395
check_update_region (pData);
6397
#ifdef MNG_SUPPORT_TRACE
6398
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
6403
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6404
mng_retcode mng_display_rgb565 (mng_datap pData)
6406
mng_uint8p pScanline;
6407
mng_uint8p pDataline;
6410
mng_uint16 iFGr16, iFGg16, iFGb16;
6411
mng_uint16 iBGr16, iBGg16, iBGb16;
6415
#ifdef MNG_SUPPORT_TRACE
6416
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
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 -
6426
/* adjust destination row starting-point */
6427
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6428
pDataline = pData->pRGBArow; /* address source row */
6430
/* adjust source row starting-point */
6431
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
6433
if (pData->bIsOpaque) /* forget about transparency ? */
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) );
6443
pScanline += (pData->iColinc * 2);
6444
pDataline += 4*iBps;
6449
if (pData->bIsRGBA16) /* 16-bit input row ? */
6452
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6453
iX += pData->iColinc)
6455
iA16 = mng_get_uint16 (pDataline+6);
6457
if (iA16) /* any opacity at all ? */
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) );
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);
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 );
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;
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) );
6488
pScanline += (pData->iColinc * 2);
6494
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6495
iX += pData->iColinc)
6497
iA8 = *(pDataline+3); /* get alpha value */
6499
if (iA8) /* any opacity at all ? */
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 ) );
6507
{ /* do alpha composing */
6508
mng_uint8 iRed, iGreen, iBlue;
6510
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
6511
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
6512
iBlue = (mng_uint8)( *(pScanline ) << 3 );
6514
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
6515
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6516
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
6518
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
6519
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6523
pScanline += (pData->iColinc * 2);
6530
check_update_region (pData);
6532
#ifdef MNG_SUPPORT_TRACE
6533
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
6538
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6539
#else /* MNG_NO_16BIT_SUPPORT */
6540
mng_retcode mng_display_rgb565 (mng_datap pData)
6542
mng_uint8p pScanline;
6543
mng_uint8p pDataline;
6547
#ifdef MNG_SUPPORT_TRACE
6548
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
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 -
6556
/* adjust destination row starting-point */
6557
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
6558
pDataline = pData->pRGBArow; /* address source row */
6560
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
6562
if (pData->bIsOpaque) /* forget about transparency ? */
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) );
6571
pScanline += (pData->iColinc * 2);
6579
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6580
iX += pData->iColinc)
6582
iA8 = *(pDataline+3); /* get alpha value */
6584
if (iA8) /* any opacity at all ? */
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 ) );
6592
{ /* do alpha composing */
6593
mng_uint8 iRed, iGreen, iBlue;
6595
iRed = (mng_uint8)( *(pScanline+1) & 0xF8);
6596
iGreen = (mng_uint8)( ( *(pScanline+1) << 5 ) | ( ( (*pScanline)&0xE0)>>3 ) );
6597
iBlue = (mng_uint8)( *(pScanline ) << 3 );
6599
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
6600
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
6601
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
6603
*(pScanline+1) = (mng_uint8)( ( iRed & 0xF8) | ( iGreen >> 5 ) );
6604
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xFC) << 3) );
6608
pScanline += (pData->iColinc * 2);
6615
check_update_region (pData);
6617
#ifdef MNG_SUPPORT_TRACE
6618
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
6623
#endif /* MNG_NO_16BIT_SUPPORT */
3149
6624
#endif /* MNG_SKIPCANVAS_RGB565 */
3151
6626
/* ************************************************************************** */
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)
3156
6633
mng_uint8p pScanline;
3157
6634
mng_uint8p pDataline;
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;
3166
6641
mng_uint8 iCr8, iCg8, iCb8;
3168
6643
#ifdef MNG_SUPPORT_TRACE
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);
3212
pScanline += (pData->iColinc * 3);
3219
#ifndef MNG_NO_16BIT_SUPPORT
3220
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
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 );
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;
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) );
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 );
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;
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);
3283
pScanline += (pData->iColinc * 3);
3290
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3292
iFGa8 = *(pDataline+3); /* get alpha values */
3293
iBGa8 = *(pScanline+2);
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);
3305
mng_uint8 iRed, iGreen, iBlue;
3307
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
3308
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
3309
iBlue = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
3328
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
3329
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
3330
*(pScanline+2) = (mng_uint8) iCa8;
3335
pScanline += (pData->iColinc *3);
3342
check_update_region (pData);
3344
#ifdef MNG_SUPPORT_TRACE
3345
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
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);
6685
pScanline += (pData->iColinc * 3);
6692
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
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 );
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;
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) );
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 );
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;
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);
6756
pScanline += (pData->iColinc * 3);
6762
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6763
iX += pData->iColinc)
6765
iFGa8 = *(pDataline+3); /* get alpha values */
6766
iBGa8 = *(pScanline+2);
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);
6778
mng_uint8 iRed, iGreen, iBlue;
6780
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6781
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6782
iBlue = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
6801
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
6802
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
6803
*(pScanline+2) = (mng_uint8) iCa8;
6808
pScanline += (pData->iColinc *3);
6815
check_update_region (pData);
6817
#ifdef MNG_SUPPORT_TRACE
6818
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
6823
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
6824
mng_retcode mng_display_bgra565 (mng_datap pData)
6826
mng_uint8p pScanline;
6827
mng_uint8p pDataline;
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;
6837
#ifdef MNG_SUPPORT_TRACE
6838
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
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 -
6848
/* adjust destination row starting-point */
6849
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
6850
pDataline = pData->pRGBArow; /* address source row */
6852
/* adjust source row starting-point */
6853
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
6855
if (pData->bIsOpaque) /* forget about transparency ? */
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);
6866
pScanline += (pData->iColinc * 3);
6867
pDataline += 4*iBps;
6872
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
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 );
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;
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) );
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 );
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;
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);
6936
pScanline += (pData->iColinc * 3);
6942
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
6943
iX += pData->iColinc)
6945
iFGa8 = *(pDataline+3); /* get alpha values */
6946
iBGa8 = *(pScanline+2);
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);
6958
mng_uint8 iRed, iGreen, iBlue;
6960
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
6961
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
6962
iBlue = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
6981
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
6982
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
6983
*(pScanline+2) = (mng_uint8) iCa8;
6988
pScanline += (pData->iColinc *3);
6995
check_update_region (pData);
6997
#ifdef MNG_SUPPORT_TRACE
6998
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
7003
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7004
#else /* MNG_NO_16BIT_SUPPORT */
7005
mng_retcode mng_display_bgra565 (mng_datap pData)
7007
mng_uint8p pScanline;
7008
mng_uint8p pDataline;
7010
mng_uint8 iFGa8, iBGa8, iCa8;
7011
mng_uint8 iCr8, iCg8, iCb8;
7013
#ifdef MNG_SUPPORT_TRACE
7014
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
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 -
7022
/* adjust destination row starting-point */
7023
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
7024
pDataline = pData->pRGBArow; /* address source row */
7026
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
7028
if (pData->bIsOpaque) /* forget about transparency ? */
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);
7038
pScanline += (pData->iColinc * 3);
7046
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7047
iX += pData->iColinc)
7049
iFGa8 = *(pDataline+3); /* get alpha values */
7050
iBGa8 = *(pScanline+2);
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);
7062
mng_uint8 iRed, iGreen, iBlue;
7064
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7065
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7066
iBlue = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
7085
*pScanline = (mng_uint8) ( ( iCb8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7086
*(pScanline+1) = (mng_uint8) ( ( iCr8 & 0xF8 ) | (iCg8>>5) );
7087
*(pScanline+2) = (mng_uint8) iCa8;
7092
pScanline += (pData->iColinc *3);
7099
check_update_region (pData);
7101
#ifdef MNG_SUPPORT_TRACE
7102
MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
7107
#endif /* MNG_NO_16BIT_SUPPORT */
3350
7108
#endif /* MNG_SKIPCANVAS_BGRA565 */
3352
7110
/* ************************************************************************** */
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)
3357
7117
mng_uint8p pScanline;
3358
7118
mng_uint8p pDataline;
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;
3367
7125
mng_uint8 iCr8, iCg8, iCb8;
3369
7127
#ifdef MNG_SUPPORT_TRACE
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);
3413
pScanline += (pData->iColinc * 3);
3420
#ifndef MNG_NO_16BIT_SUPPORT
3421
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
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 );
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;
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) );
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 );
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;
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);
3484
pScanline += (pData->iColinc * 3);
3491
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3493
iFGa8 = *(pDataline+3); /* get alpha values */
3494
iBGa8 = *(pScanline+2);
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);
3506
mng_uint8 iRed, iGreen, iBlue;
3508
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
3509
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
3510
iRed = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
3529
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
3530
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
3531
*(pScanline+2) = (mng_uint8) iCa8;
3536
pScanline += (pData->iColinc *3);
3543
check_update_region (pData);
3545
#ifdef MNG_SUPPORT_TRACE
3546
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
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);
7169
pScanline += (pData->iColinc * 3);
7176
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
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 );
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;
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) );
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 );
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;
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);
7240
pScanline += (pData->iColinc * 3);
7246
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7247
iX += pData->iColinc)
7249
iFGa8 = *(pDataline+3); /* get alpha values */
7250
iBGa8 = *(pScanline+2);
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);
7262
mng_uint8 iRed, iGreen, iBlue;
7264
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7265
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7266
iRed = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
7285
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7286
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
7287
*(pScanline+2) = (mng_uint8) iCa8;
7292
pScanline += (pData->iColinc *3);
7299
check_update_region (pData);
7301
#ifdef MNG_SUPPORT_TRACE
7302
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
7307
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7308
mng_retcode mng_display_rgba565 (mng_datap pData)
7310
mng_uint8p pScanline;
7311
mng_uint8p pDataline;
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;
7321
#ifdef MNG_SUPPORT_TRACE
7322
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
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 -
7332
/* adjust destination row starting-point */
7333
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
7334
pDataline = pData->pRGBArow; /* address source row */
7336
/* adjust source row starting-point */
7337
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
7339
if (pData->bIsOpaque) /* forget about transparency ? */
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);
7350
pScanline += (pData->iColinc * 3);
7351
pDataline += 4*iBps;
7356
if (pData->bIsRGBA16) /* 16-bit input row ? */
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;
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);
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 );
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;
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) );
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 );
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;
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);
7420
pScanline += (pData->iColinc * 3);
7426
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7427
iX += pData->iColinc)
7429
iFGa8 = *(pDataline+3); /* get alpha values */
7430
iBGa8 = *(pScanline+2);
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);
7442
mng_uint8 iRed, iGreen, iBlue;
7444
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7445
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7446
iRed = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
7465
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7466
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
7467
*(pScanline+2) = (mng_uint8) iCa8;
7472
pScanline += (pData->iColinc *3);
7479
check_update_region (pData);
7481
#ifdef MNG_SUPPORT_TRACE
7482
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
7487
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7488
#else /* MNG_NO_16BIT_SUPPORT */
7489
mng_retcode mng_display_rgba565 (mng_datap pData)
7491
mng_uint8p pScanline;
7492
mng_uint8p pDataline;
7494
mng_uint8 iFGa8, iBGa8, iCa8;
7495
mng_uint8 iCr8, iCg8, iCb8;
7497
#ifdef MNG_SUPPORT_TRACE
7498
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
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 -
7506
/* adjust destination row starting-point */
7507
pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
7508
pDataline = pData->pRGBArow; /* address source row */
7510
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
7512
if (pData->bIsOpaque) /* forget about transparency ? */
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);
7522
pScanline += (pData->iColinc * 3);
7530
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7531
iX += pData->iColinc)
7533
iFGa8 = *(pDataline+3); /* get alpha values */
7534
iBGa8 = *(pScanline+2);
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);
7546
mng_uint8 iRed, iGreen, iBlue;
7548
iBlue = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7549
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | ( ((*pScanline) & 0xE0)>>3 ) );
7550
iRed = (mng_uint8) ( (*pScanline << 3) );
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) );
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 */
7569
*pScanline = (mng_uint8) ( ( iCr8 >> 3 ) | ( (iCg8 & 0xFC) << 3) );
7570
*(pScanline+1) = (mng_uint8) ( ( iCb8 & 0xF8 ) | (iCg8>>5) );
7571
*(pScanline+2) = (mng_uint8) iCa8;
7576
pScanline += (pData->iColinc *3);
7583
check_update_region (pData);
7585
#ifdef MNG_SUPPORT_TRACE
7586
MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
7591
#endif /* MNG_NO_16BIT_SUPPORT */
3551
7592
#endif /* MNG_SKIPCANVAS_RGBA565 */
3553
7594
/* ************************************************************************** */
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)
3558
7601
mng_uint8p pScanline;
3559
7602
mng_uint8p pAlphaline;
3560
7603
mng_uint8p pDataline;
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;
3568
7609
mng_uint8 iA8, iBGa8, iCa8;
3569
7610
mng_uint8 iCr8, iCg8, iCb8;
3572
7612
#ifdef MNG_SUPPORT_TRACE
3573
7613
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
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));
3623
pScanline += (pData->iColinc * 2);
3624
pAlphaline += pData->iColinc;
3629
else /* Not fully opaque */
3631
#ifndef MNG_NO_16BIT_SUPPORT
3632
if (pData->bIsRGBA16) /* 16-bit input row ? */
3635
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
3637
iA16 = mng_get_uint16 (pDataline+6);
3638
iBGa16 = (mng_uint16)(*pAlphaline);
3639
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
3641
if (iA16) /* any opacity at all ? */
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);
3651
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
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 */
3659
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
3660
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
3661
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
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;
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);
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 );
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;
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);
3698
pScanline += (pData->iColinc * 2);
3699
pAlphaline += pData->iColinc;
3706
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
3707
iX += pData->iColinc)
3709
iA8 = *(pDataline+3); /* get alpha value */
3710
iBGa8 = *pAlphaline;
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);
3722
if (iBGa8 == 0xFF) /* background fully opaque ? */
3724
/* do alpha composing */
3725
mng_uint8 iRed, iGreen, iBlue;
3727
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
3728
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
3729
iBlue = (mng_uint8) ( (*pScanline << 3) );
3731
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
3732
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
3733
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
3735
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
3736
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
3739
else /* background not fully opaque */
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) );
3752
pScanline += (pData->iColinc * 2);
3753
pAlphaline += pData->iColinc;
3760
check_update_region (pData);
3762
#ifdef MNG_SUPPORT_TRACE
3763
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
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));
7660
pScanline += (pData->iColinc * 2);
7661
pAlphaline += pData->iColinc;
7666
else /* Not fully opaque */
7668
if (pData->bIsRGBA16) /* 16-bit input row ? */
7671
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7672
iX += pData->iColinc)
7674
iA16 = mng_get_uint16 (pDataline+6);
7675
iBGa16 = (mng_uint16)(*pAlphaline);
7676
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
7678
if (iA16) /* any opacity at all ? */
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);
7688
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
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 */
7696
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7697
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7698
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
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;
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);
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 );
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;
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);
7735
pScanline += (pData->iColinc * 2);
7736
pAlphaline += pData->iColinc;
7742
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7743
iX += pData->iColinc)
7745
iA8 = *(pDataline+3); /* get alpha value */
7746
iBGa8 = *pAlphaline;
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);
7758
if (iBGa8 == 0xFF) /* background fully opaque ? */
7760
/* do alpha composing */
7761
mng_uint8 iRed, iGreen, iBlue;
7763
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7764
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
7765
iBlue = (mng_uint8) ( (*pScanline << 3) );
7767
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
7768
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
7769
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
7771
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
7772
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
7775
else /* background not fully opaque */
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) );
7788
pScanline += (pData->iColinc * 2);
7789
pAlphaline += pData->iColinc;
7796
check_update_region (pData);
7798
#ifdef MNG_SUPPORT_TRACE
7799
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
7804
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7805
mng_retcode mng_display_bgr565_a8 (mng_datap pData)
7807
mng_uint8p pScanline;
7808
mng_uint8p pAlphaline;
7809
mng_uint8p pDataline;
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;
7820
#ifdef MNG_SUPPORT_TRACE
7821
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
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 -
7831
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
7832
pData->iRow + pData->iDestt -
7834
/* adjust destination row
7836
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
7837
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
7838
pDataline = pData->pRGBArow; /* address source row */
7840
/* adjust source row starting-point */
7841
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
7843
if (pData->bIsOpaque) /* forget about transparency ? */
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));
7854
pScanline += (pData->iColinc * 2);
7855
pAlphaline += pData->iColinc;
7859
else /* Not fully opaque */
7861
if (pData->bIsRGBA16) /* 16-bit input row ? */
7864
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7865
iX += pData->iColinc)
7867
iA16 = mng_get_uint16 (pDataline+6);
7868
iBGa16 = (mng_uint16)(*pAlphaline);
7869
iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
7871
if (iA16) /* any opacity at all ? */
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);
7881
if (iBGa16 == 0xFFFF) /* background fully opaque ? */
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 */
7889
iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
7890
iBGg16 = (mng_uint16)( (*(pScanline+1) << 5) | (((*(pScanline )) & 0xE0) >>3 ) );
7891
iBGr16 = (mng_uint16)( (*(pScanline )) << 3 );
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;
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);
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 );
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;
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);
7928
pScanline += (pData->iColinc * 2);
7929
pAlphaline += pData->iColinc;
7935
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
7936
iX += pData->iColinc)
7938
iA8 = *(pDataline+3); /* get alpha value */
7939
iBGa8 = *pAlphaline;
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);
7951
if (iBGa8 == 0xFF) /* background fully opaque ? */
7953
/* do alpha composing */
7954
mng_uint8 iRed, iGreen, iBlue;
7956
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
7957
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
7958
iBlue = (mng_uint8) ( (*pScanline << 3) );
7960
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
7961
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
7962
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
7964
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
7965
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
7968
else /* background not fully opaque */
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) );
7981
pScanline += (pData->iColinc * 2);
7982
pAlphaline += pData->iColinc;
7989
check_update_region (pData);
7991
#ifdef MNG_SUPPORT_TRACE
7992
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
7997
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
7998
#else /* MNG_NO_16BIT_SUPPORT */
7999
mng_retcode mng_display_bgr565_a8 (mng_datap pData)
8001
mng_uint8p pScanline;
8002
mng_uint8p pAlphaline;
8003
mng_uint8p pDataline;
8005
mng_uint8 iA8, iBGa8, iCa8;
8006
mng_uint8 iCr8, iCg8, iCb8;
8009
#ifdef MNG_SUPPORT_TRACE
8010
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
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 -
8018
pAlphaline = (mng_uint8p)pData->fGetalphaline (((mng_handle)pData),
8019
pData->iRow + pData->iDestt -
8021
/* adjust destination row
8023
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8024
pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
8025
pDataline = pData->pRGBArow; /* address source row */
8027
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8029
if (pData->bIsOpaque) /* forget about transparency ? */
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));
8039
pScanline += (pData->iColinc * 2);
8040
pAlphaline += pData->iColinc;
8045
else /* Not fully opaque */
8048
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8049
iX += pData->iColinc)
8051
iA8 = *(pDataline+3); /* get alpha value */
8052
iBGa8 = *pAlphaline;
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);
8064
if (iBGa8 == 0xFF) /* background fully opaque ? */
8066
/* do alpha composing */
8067
mng_uint8 iRed, iGreen, iBlue;
8069
iRed = (mng_uint8) ( *(pScanline+1) & 0xF8 );
8070
iGreen = (mng_uint8) ( (*(pScanline+1) << 5) | (((*pScanline) & 0xE0)>>3 ) );
8071
iBlue = (mng_uint8) ( (*pScanline << 3) );
8073
MNG_COMPOSE8 (iRed, *pDataline, iA8, iRed );
8074
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8075
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8077
*(pScanline+1) = (mng_uint8) ( ( iRed & 0xF8 ) | (iGreen>>5) );
8078
*pScanline = (mng_uint8) ( ( iBlue >> 3 ) | ((iGreen & 0xFC) << 3) );
8081
else /* background not fully opaque */
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) );
8094
pScanline += (pData->iColinc * 2);
8095
pAlphaline += pData->iColinc;
8102
check_update_region (pData);
8104
#ifdef MNG_SUPPORT_TRACE
8105
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
8110
#endif /* MNG_NO_16BIT_SUPPORT */
3768
8111
#endif /* MNG_SKIPCANVAS_BGR565_A8 */
8113
/* ************************************************************************** */
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)
8120
mng_uint8p pScanline;
8121
mng_uint8p pDataline;
8124
mng_uint16 iFGr16, iFGg16, iFGb16;
8125
mng_uint16 iBGr16, iBGg16, iBGb16;
8128
#ifdef MNG_SUPPORT_TRACE
8129
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
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 -
8137
/* adjust destination row starting-point */
8138
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8139
pDataline = pData->pRGBArow; /* address source row */
8141
if (pData->bIsRGBA16) /* adjust source row starting-point */
8142
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
8144
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8146
if (pData->bIsOpaque) /* forget about transparency ? */
8148
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ) );
8156
pScanline += (pData->iColinc * 2);
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 ) );
8168
pScanline += (pData->iColinc * 2);
8175
if (pData->bIsRGBA16) /* 16-bit input row ? */
8178
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8179
iX += pData->iColinc)
8181
iA16 = mng_get_uint16 (pDataline+6);
8183
if (iA16) /* any opacity at all ? */
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 ) );
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);
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 );
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;
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 ) );
8214
pScanline += (pData->iColinc * 2);
8220
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8221
iX += pData->iColinc)
8223
iA8 = *(pDataline+3); /* get alpha value */
8225
if (iA8) /* any opacity at all ? */
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 ) );
8233
{ /* do alpha composing */
8234
mng_uint8 iRed, iGreen, iBlue;
8236
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8237
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8238
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8240
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
8241
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8242
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
8244
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8245
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8249
pScanline += (pData->iColinc * 2);
8256
check_update_region (pData);
8258
#ifdef MNG_SUPPORT_TRACE
8259
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
8264
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8265
mng_retcode mng_display_rgb555 (mng_datap pData)
8267
mng_uint8p pScanline;
8268
mng_uint8p pDataline;
8271
mng_uint16 iFGr16, iFGg16, iFGb16;
8272
mng_uint16 iBGr16, iBGg16, iBGb16;
8276
#ifdef MNG_SUPPORT_TRACE
8277
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
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 -
8287
/* adjust destination row starting-point */
8288
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8289
pDataline = pData->pRGBArow; /* address source row */
8291
/* adjust source row starting-point */
8292
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
8294
if (pData->bIsOpaque) /* forget about transparency ? */
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 ) );
8302
pScanline += (pData->iColinc * 2);
8303
pDataline += 4*iBps;
8308
if (pData->bIsRGBA16) /* 16-bit input row ? */
8311
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8312
iX += pData->iColinc)
8314
iA16 = mng_get_uint16 (pDataline+6);
8316
if (iA16) /* any opacity at all ? */
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 ) );
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);
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 );
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;
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 ) );
8347
pScanline += (pData->iColinc * 2);
8353
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8354
iX += pData->iColinc)
8356
iA8 = *(pDataline+3); /* get alpha value */
8358
if (iA8) /* any opacity at all ? */
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 ) );
8366
{ /* do alpha composing */
8367
mng_uint8 iRed, iGreen, iBlue;
8369
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8370
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8371
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8373
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
8374
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8375
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
8377
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8378
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8382
pScanline += (pData->iColinc * 2);
8389
check_update_region (pData);
8391
#ifdef MNG_SUPPORT_TRACE
8392
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
8397
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8398
#else /* MNG_NO_16BIT_SUPPORT */
8399
mng_retcode mng_display_rgb555 (mng_datap pData)
8401
mng_uint8p pScanline;
8402
mng_uint8p pDataline;
8406
#ifdef MNG_SUPPORT_TRACE
8407
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
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 -
8415
/* adjust destination row starting-point */
8416
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8417
pDataline = pData->pRGBArow; /* address source row */
8419
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8421
if (pData->bIsOpaque) /* forget about transparency ? */
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 ) );
8430
pScanline += (pData->iColinc * 2);
8438
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8439
iX += pData->iColinc)
8441
iA8 = *(pDataline+3); /* get alpha value */
8443
if (iA8) /* any opacity at all ? */
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 ) );
8451
{ /* do alpha composing */
8452
mng_uint8 iRed, iGreen, iBlue;
8454
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8455
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8456
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8458
MNG_COMPOSE8 (iRed, *(pDataline+2), iA8, iRed );
8459
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8460
MNG_COMPOSE8 (iBlue, *(pDataline+0), iA8, iBlue );
8462
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8463
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8467
pScanline += (pData->iColinc * 2);
8474
check_update_region (pData);
8476
#ifdef MNG_SUPPORT_TRACE
8477
MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
8482
#endif /* MNG_NO_16BIT_SUPPORT */
8483
#endif /* MNG_SKIPCANVAS_RGB555 */
8485
/* ************************************************************************** */
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)
8492
mng_uint8p pScanline;
8493
mng_uint8p pDataline;
8496
mng_uint16 iFGr16, iFGg16, iFGb16;
8497
mng_uint16 iBGr16, iBGg16, iBGb16;
8500
#ifdef MNG_SUPPORT_TRACE
8501
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
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 -
8509
/* adjust destination row starting-point */
8510
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8511
pDataline = pData->pRGBArow; /* address source row */
8513
if (pData->bIsRGBA16) /* adjust source row starting-point */
8514
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
8516
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8518
if (pData->bIsOpaque) /* forget about transparency ? */
8520
if (pData->bIsRGBA16) /* 16-bit input row ? */
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 ) );
8528
pScanline += (pData->iColinc * 2);
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 ) );
8540
pScanline += (pData->iColinc * 2);
8547
if (pData->bIsRGBA16) /* 16-bit input row ? */
8550
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8551
iX += pData->iColinc)
8553
iA16 = mng_get_uint16 (pDataline+6);
8555
if (iA16) /* any opacity at all ? */
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 ) );
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);
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 );
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;
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 ) );
8586
pScanline += (pData->iColinc * 2);
8592
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8593
iX += pData->iColinc)
8595
iA8 = *(pDataline+3); /* get alpha value */
8597
if (iA8) /* any opacity at all ? */
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 ) );
8605
{ /* do alpha composing */
8606
mng_uint8 iRed, iGreen, iBlue;
8608
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8609
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8610
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8612
MNG_COMPOSE8 (iRed, *(pDataline+0), iA8, iRed );
8613
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8614
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8616
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8617
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8621
pScanline += (pData->iColinc * 2);
8628
check_update_region (pData);
8630
#ifdef MNG_SUPPORT_TRACE
8631
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
8636
#else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8637
mng_retcode mng_display_bgr555 (mng_datap pData)
8639
mng_uint8p pScanline;
8640
mng_uint8p pDataline;
8643
mng_uint16 iFGr16, iFGg16, iFGb16;
8644
mng_uint16 iBGr16, iBGg16, iBGb16;
8648
#ifdef MNG_SUPPORT_TRACE
8649
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
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 -
8659
/* adjust destination row starting-point */
8660
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8661
pDataline = pData->pRGBArow; /* address source row */
8663
/* adjust source row starting-point */
8664
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
8666
if (pData->bIsOpaque) /* forget about transparency ? */
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 ) );
8674
pScanline += (pData->iColinc * 2);
8675
pDataline += 4*iBps;
8680
if (pData->bIsRGBA16) /* 16-bit input row ? */
8683
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8684
iX += pData->iColinc)
8686
iA16 = mng_get_uint16 (pDataline+6);
8688
if (iA16) /* any opacity at all ? */
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 ) );
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);
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 );
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;
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 ) );
8719
pScanline += (pData->iColinc * 2);
8725
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8726
iX += pData->iColinc)
8728
iA8 = *(pDataline+3); /* get alpha value */
8730
if (iA8) /* any opacity at all ? */
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 ) );
8738
{ /* do alpha composing */
8739
mng_uint8 iRed, iGreen, iBlue;
8741
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8742
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8743
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8745
MNG_COMPOSE8 (iRed, *(pDataline+0), iA8, iRed );
8746
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8747
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8749
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8750
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8754
pScanline += (pData->iColinc * 2);
8761
check_update_region (pData);
8763
#ifdef MNG_SUPPORT_TRACE
8764
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
8769
#endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
8770
#else /* MNG_NO_16BIT_SUPPORT */
8771
mng_retcode mng_display_bgr555 (mng_datap pData)
8773
mng_uint8p pScanline;
8774
mng_uint8p pDataline;
8778
#ifdef MNG_SUPPORT_TRACE
8779
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
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 -
8787
/* adjust destination row starting-point */
8788
pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
8789
pDataline = pData->pRGBArow; /* address source row */
8791
pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
8793
if (pData->bIsOpaque) /* forget about transparency ? */
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 ) );
8802
pScanline += (pData->iColinc * 2);
8810
for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
8811
iX += pData->iColinc)
8813
iA8 = *(pDataline+3); /* get alpha value */
8815
if (iA8) /* any opacity at all ? */
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 ) );
8823
{ /* do alpha composing */
8824
mng_uint8 iRed, iGreen, iBlue;
8826
iRed = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
8827
iGreen = (mng_uint8)( (*(pScanline+1) << 6 ) | ( ((*pScanline) & 0xE0) >> 2 ) );
8828
iBlue = (mng_uint8)( *(pScanline ) << 3 );
8830
MNG_COMPOSE8 (iRed, *(pDataline+0), iA8, iRed );
8831
MNG_COMPOSE8 (iGreen, *(pDataline+1), iA8, iGreen );
8832
MNG_COMPOSE8 (iBlue, *(pDataline+2), iA8, iBlue );
8834
*(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 ) | ( iGreen >> 6 ) );
8835
*pScanline = (mng_uint8)( (iBlue >> 3 ) | ( (iGreen & 0xF8) << 2 ) );
8839
pScanline += (pData->iColinc * 2);
8846
check_update_region (pData);
8848
#ifdef MNG_SUPPORT_TRACE
8849
MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
8854
#endif /* MNG_NO_16BIT_SUPPORT */
8855
#endif /* MNG_SKIPCANVAS_BGR555 */
8858
#ifndef MNG_SKIPCHUNK_BACK
3771
8859
/* ************************************************************************** */
3773
8861
/* * Background restore routines - restore the background with info from * */