harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From apetre...@apache.org
Subject svn commit: r572378 - in /harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl: shared/SurfaceDataStructure.cpp shared/SurfaceDataStructure.h windows/GDIBlitter.cpp
Date Mon, 03 Sep 2007 16:08:14 GMT
Author: apetrenko
Date: Mon Sep  3 09:08:13 2007
New Revision: 572378

URL: http://svn.apache.org/viewvc?rev=572378&view=rev
Log:
Patch for HARMONY-4700 "[classlib][awt] unable to draw a GIF image through Windows Remote Desktop"

Modified:
    harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.cpp
    harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.h
    harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/windows/GDIBlitter.cpp

Modified: harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.cpp?rev=572378&r1=572377&r2=572378&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.cpp (original)
+++ harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.cpp Mon Sep  3 09:08:13 2007
@@ -70,9 +70,9 @@
 inline void updateCache
 (SURFACE_STRUCTURE *srcSurf, JNIEnv *env, jobject srcData, bool alphaPre){
 
-       unsigned int srcstride, dststride, offset;
-       unsigned int h = srcSurf->height;
-       unsigned int w = srcSurf->width;
+    unsigned int srcstride, dststride, offset;
+    unsigned int h = srcSurf->height;
+    unsigned int w = srcSurf->width;
 
     void *bmpDataPtr = srcSurf->bmpData;
     void *srcDataPtr = env->GetPrimitiveArrayCritical((jarray)srcData, 0);
@@ -80,525 +80,492 @@
     switch(srcSurf->ss_type){
 
         case INT_RGB:
-                       {
-                               //if(!srcSurf->invalidated) return false;
+            {
+                unsigned int *src, *s, *dst, *d;
 
-                               srcstride = srcSurf->scanline_stride;
-                               dststride = w;
-                               /*
-                               if(srcstride == dststride){
-                                       memcpy(bmpDataPtr, srcDataPtr, (w << 2) * h);
-                               }else{
-                */
-                                       unsigned int *src, *s, *dst, *d;
-
-                                       offset = w - 1;
-                                       src = (unsigned int *)srcDataPtr + offset;
-                                       dst = (unsigned int *)bmpDataPtr + offset;
-
-                                       for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       *d-- = 0xff000000 | *s--;
-                                               }
-                                       }
-                               //}
-                       }
+                srcstride = srcSurf->scanline_stride;
+                dststride = w;
+
+                offset = w - 1;
+                src = (unsigned int *)srcDataPtr + offset;
+                dst = (unsigned int *)bmpDataPtr + offset;
+
+                for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                    s = src;
+                    d = dst;
+
+                    for(int x = w; x > 0 ; x--){
+                        *d-- = 0xff000000 | *s--;
+                    }
+                }
+            }
             break;
 
         case INT_ARGB:
-                       {
-                               //if(!srcSurf->invalidated && srcSurf->isAlphaPre && alphaPre) return false;
-                               //if(!srcSurf->invalidated && !srcSurf->isAlphaPre && !alphaPre) return false;
-
-                               unsigned char *src, *s, *dst, *d, sa;
-
-                               offset = (w << 2) - 1;
-                               src = (unsigned char *)srcDataPtr + offset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride_byte;
-                               dststride = w << 2;
-
-                               if(alphaPre){
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       sa = *s--;
-                                                       *d-- = sa;
-                                                       if(sa != 255){
-                                                               *d-- = MUL(sa, *s--);
-                                                               *d-- = MUL(sa, *s--);
-                                                               *d-- = MUL(sa, *s--);
-                                                               srcSurf->hasRealAlpha = true;
-                                                       }else{
-                                                               *d-- = *s--;
-                                                               *d-- = *s--;
-                                                               *d-- = *s--;
-                                                       }
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = true;
-                               }else{
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       sa = *s--;
-                                                       if(sa == 0){
-                                                               *d-- = 0;
-                                                               *d-- = 0;
-                                                               *d-- = 0;
-                                                               *d-- = 0;
-                                                               s -= 3;
-                                                       }else{
-                                                               *d-- = sa;
-                                                               *d-- = MUL(sa, *s--);
-                                                               *d-- = MUL(sa, *s--);
-                                                               *d-- = MUL(sa, *s--);
-                                                       }
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = false;
-                               }
-                       }
+            {
+                unsigned char *src, *s, *dst, *d, sa;
+
+                offset = (w << 2) - 1;
+                src = (unsigned char *)srcDataPtr + offset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride_byte;
+                dststride = w << 2;
+
+                if(alphaPre){
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0 ; x--){
+                            sa = *s--;
+                            *d-- = sa;
+                            if(sa != 255){
+                                *d-- = MUL(sa, *s--);
+                                *d-- = MUL(sa, *s--);
+                                *d-- = MUL(sa, *s--);
+                                srcSurf->hasRealAlpha = true;
+                            }else{
+                                *d-- = *s--;
+                                *d-- = *s--;
+                                *d-- = *s--;
+                            }
+                        }
+                    }
+                    srcSurf->isAlphaPre = true;
+                }else{
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0 ; x--){
+                            sa = *s--;
+                            if(sa == 0){
+                                *d-- = 0;
+                                *d-- = 0;
+                                *d-- = 0;
+                                *d-- = 0;
+                                s -= 3;
+                            }else{
+                                *d-- = sa;
+                                *d-- = MUL(sa, *s--);
+                                *d-- = MUL(sa, *s--);
+                                *d-- = MUL(sa, *s--);
+                            }
+                        }
+                    }
+                    srcSurf->isAlphaPre = false;
+                }
+            }
             break;
 
         case INT_ARGB_PRE:
-                       {
-                               //if(!srcSurf->invalidated && srcSurf->isAlphaPre && alphaPre) return false;
-                               //if(!srcSurf->invalidated && !srcSurf->isAlphaPre && !alphaPre) return false;
-
-                               unsigned char *src, *s, *dst, *d, sa;
-
-                               offset = (w << 2) - 1;
-                               src = (unsigned char *)srcDataPtr + offset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride_byte;
-                               dststride = w << 2;
-
-                               if(alphaPre){
-                                       for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       sa = *s--;
-                                                       *d-- = sa;
-                                                       *d-- = *s--;
-                                                       *d-- = *s--;
-                                                       *d-- = *s--;
-                                                       if(sa != 255){
-                                                               srcSurf->hasRealAlpha = true;
-                                                       }
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = true;
-                               }else{
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       sa = *s--;
-                                                       *d-- = sa;
-                                                       *d-- = DIV(sa, *s--);
-                                                       *d-- = DIV(sa, *s--);
-                                                       *d-- = DIV(sa, *s--);
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = false;
-                               }
-                       }
+            {
+                unsigned char *src, *s, *dst, *d, sa;
+
+                offset = (w << 2) - 1;
+                src = (unsigned char *)srcDataPtr + offset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride_byte;
+                dststride = w << 2;
+
+                if(alphaPre){
+                    for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0 ; x--){
+                            sa = *s--;
+                            *d-- = sa;
+                            *d-- = *s--;
+                            *d-- = *s--;
+                            *d-- = *s--;
+                            if(sa != 255){
+                                srcSurf->hasRealAlpha = true;
+                            }
+                        }
+                    }
+                    srcSurf->isAlphaPre = true;
+                }else{
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0 ; x--){
+                            sa = *s--;
+                            *d-- = sa;
+                            *d-- = DIV(sa, *s--);
+                            *d-- = DIV(sa, *s--);
+                            *d-- = DIV(sa, *s--);
+                        }
+                    }
+                    srcSurf->isAlphaPre = false;
+                }
+            }
             break;
 
         case INT_BGR:
-                       {
-                               //if(!srcSurf->invalidated) return false;
-
-                               unsigned char *src, *s, *dst, *d;
+            {
+                unsigned char *src, *s, *dst, *d;
 
-                               offset = (w << 2) - 1;
-                               src = (unsigned char *)srcDataPtr + offset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride_byte;
-                               dststride = w << 2;
-
-                               for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                       s = src;
-                                       d = dst;
-
-                                       for(int x = w; x > 0 ; x--){
-                                               *d = 255;
-                                               *s--;
-                                               *(d - 3) = *s--;
-                                               *(d - 2) = *s--;
-                                               *(d - 1) = *s--;
-                                               d -= 4;
-                                       }
-                               }
-                       }
+                offset = (w << 2) - 1;
+                src = (unsigned char *)srcDataPtr + offset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride_byte;
+                dststride = w << 2;
+ 
+                for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                    s = src;
+                    d = dst;
+
+                    for(int x = w; x > 0 ; x--){
+                        *d = 255;
+                        *s--;
+                        *(d - 3) = *s--;
+                        *(d - 2) = *s--;
+                        *(d - 1) = *s--;
+                        d -= 4;
+                    }
+                }
+            }
             break;
 
         case BYTE_BGR:
-                       {
-                               //if(!srcSurf->invalidated) return false;
+            {
+                unsigned char *src, *s, *dst, *d;
 
-                               unsigned char *src, *s, *dst, *d;
-
-                               offset = (w << 2) - 1;
-                               unsigned int srcOffset = w * 3 - 1;
-                               src = (unsigned char *)srcDataPtr + srcOffset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride_byte;
-                               dststride = w << 2;
-
-                               for(int y = srcSurf->height; y > 0; y--, src += srcstride, dst += dststride){
-                                       s = src;
-                                       d = dst;
-
-                                       for(int x = w; x > 0 ; x--){
-                                               *d-- = 255;
-                                               *d-- = *s--;
-                                               *d-- = *s--;
-                                               *d-- = *s--;
-                                       }
-                               }
-                       }
+                offset = (w << 2) - 1;
+                unsigned int srcOffset = w * 3 - 1;
+                src = (unsigned char *)srcDataPtr + srcOffset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride_byte;
+                dststride = w << 2;
+
+                for(int y = srcSurf->height; y > 0; y--, src += srcstride, dst += dststride){
+                    s = src;
+                    d = dst;
+
+                    for(int x = w; x > 0 ; x--){
+                        *d-- = 255;
+                        *d-- = *s--;
+                        *d-- = *s--;
+                        *d-- = *s--;
+                    }
+                }
+            }
             break;
 
         case BYTE_ABGR:
-                       {
-                               //if(!srcSurf->invalidated && srcSurf->isAlphaPre && alphaPre) return false;
-                               //if(!srcSurf->invalidated && !srcSurf->isAlphaPre && !alphaPre) return false;
-
-                               unsigned char *src, *s, *dst, *d, a, r, g, b;
-
-                               offset = (w << 2) - 1;
-                               src = (unsigned char *)srcDataPtr + offset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride_byte;
-                               dststride = w << 2;
-
-                               if(alphaPre){
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       r = *s--;
-                                                       g = *s--;
-                                                       b = *s--;
-                                                       a = *s--;
-                                                       *d-- = a;
-                                                       if(a != 255){
-                                                               *d-- = MUL(a, r);
-                                                               *d-- = MUL(a, g);
-                                                               *d-- = MUL(a, b);
-                                                               srcSurf->hasRealAlpha = true;
-                                                       }else{
-                                                               *d-- = r;
-                                                               *d-- = g;
-                                                               *d-- = b;
-                                                       }
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = true;
-                               }else{
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       r = *s--;
-                                                       g = *s--;
-                                                       b = *s--;
-                                                       a = *s--;
-                                                       if(a == 0){
-                                                               *d-- = 0;
-                                                               *d-- = 0;
-                                                               *d-- = 0;
-                                                               *d-- = 0;
-                                                       }else{
-                                                               *d-- = a;
-                                                               *d-- = r;
-                                                               *d-- = g;
-                                                               *d-- = b;
-                                                       }
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = false;
-                               }
-                       }
+            {
+                unsigned char *src, *s, *dst, *d, a, r, g, b;
+
+                offset = (w << 2) - 1;
+                src = (unsigned char *)srcDataPtr + offset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride_byte;
+                dststride = w << 2;
+
+                if(alphaPre){
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0 ; x--){
+                            r = *s--;
+                            g = *s--;
+                            b = *s--;
+                            a = *s--;
+                            *d-- = a;
+                            if(a != 255){
+                                *d-- = MUL(a, r);
+                                *d-- = MUL(a, g);
+                                *d-- = MUL(a, b);
+                                srcSurf->hasRealAlpha = true;
+                            }else{
+                                *d-- = r;
+                                *d-- = g;
+                                *d-- = b;
+                            }
+                        }
+                    }
+                    srcSurf->isAlphaPre = true;
+                }else{
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0 ; x--){
+                            r = *s--;
+                            g = *s--;
+                            b = *s--;
+                            a = *s--;
+                            if(a == 0){
+                                *d-- = 0;
+                                *d-- = 0;
+                                *d-- = 0;
+                                *d-- = 0;
+                            }else{
+                                *d-- = a;
+                                *d-- = r;
+                                *d-- = g;
+                                *d-- = b;
+                            }
+                        }
+                    }
+                    srcSurf->isAlphaPre = false;
+                }
+            }
             break;
 
         case BYTE_ABGR_PRE:
-                       {
-                               //if(!srcSurf->invalidated && srcSurf->isAlphaPre && alphaPre) return false;
-                               //if(!srcSurf->invalidated && !srcSurf->isAlphaPre && !alphaPre) return false;
-
-                               unsigned char *src, *s, *dst, *d, a, r, g, b;
-
-                               offset = (w << 2) - 1;
-                               src = (unsigned char *)srcDataPtr + offset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride_byte;
-                               dststride = w << 2;
-
-                               if(alphaPre){
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       r = *s--;
-                                                       g = *s--;
-                                                       b = *s--;
-                                                       a = *s--;
-                                                       if(a != 255){
-                                                               srcSurf->hasRealAlpha = true;
-                                                       }
-                                                       *d-- = a;
-                                                       *d-- = r;
-                                                       *d-- = g;
-                                                       *d-- = b;
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = true;
-                               }else{
-                                       for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0 ; x--){
-                                                       r = *s--;
-                                                       g = *s--;
-                                                       b = *s--;
-                                                       a = *s--;
-                                                       *d-- = a;
-                                                       if(a != 255){
-                                                               *d-- = DIV(a, r);
-                                                               *d-- = DIV(a, g);
-                                                               *d-- = DIV(a, b);
-                                                       }else{
-                                                               *d-- = r;
-                                                               *d-- = g;
-                                                               *d-- = b;
-                                                       }
-                                               }
-                                       }
-                                       srcSurf->isAlphaPre = false;
-                               }
-                       }
+            {
+                unsigned char *src, *s, *dst, *d, a, r, g, b;
+
+                offset = (w << 2) - 1;
+                src = (unsigned char *)srcDataPtr + offset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride_byte;
+                dststride = w << 2;
+
+                if(alphaPre){
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+ 
+                        for(int x = w; x > 0 ; x--){
+                            r = *s--;
+                            g = *s--;
+                            b = *s--;
+                            a = *s--;
+                            if(a != 255){
+                                srcSurf->hasRealAlpha = true;
+                            }
+                            *d-- = a;
+                            *d-- = r;
+                            *d-- = g;
+                            *d-- = b;
+                        }
+                    }
+                    srcSurf->isAlphaPre = true;
+                }else{
+                    for(int y = h; y > 0 ; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+  
+                        for(int x = w; x > 0 ; x--){
+                            r = *s--;
+                            g = *s--;
+                            b = *s--;
+                            a = *s--;
+                            *d-- = a;
+                            if(a != 255){
+                                *d-- = DIV(a, r);
+                                *d-- = DIV(a, g);
+                                *d-- = DIV(a, b);
+                            }else{
+                                *d-- = r;
+                                *d-- = g;
+                                *d-- = b;
+                            }
+                        }
+                    }
+                    srcSurf->isAlphaPre = false;
+                }
+            }
             break;
 
         case USHORT_555:
         case USHORT_565:
-                       {
-                               //if(!srcSurf->invalidated) return false;
-
-                               unsigned char *dst, *d;
-                               unsigned short *src, *s, pixel;
-
-                               offset = (w << 2) - 1;
-                               unsigned int srcOffset = w - 1;
-                               src = (unsigned short *)srcDataPtr + srcOffset;
-                               dst = (unsigned char *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride;
-                               dststride = w << 2;
-
-                               unsigned int mr = srcSurf->max_red;
-                               unsigned int mg = srcSurf->max_green;
-                               unsigned int mb = srcSurf->max_red;
-                               unsigned int rm = srcSurf->red_mask;
-                               unsigned int gm = srcSurf->green_mask;
-                               unsigned int bm = srcSurf->blue_mask;
-                               unsigned int rs = srcSurf->red_sht;
-                               unsigned int gs = srcSurf->green_sht;
-                               unsigned int bs = srcSurf->blue_sht;
-
-                               for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                       d = dst;
-                                       s = src;
-                                       for(int x = w; x > 0; x--){
-                                               pixel = *s--;
-                                               *d-- = 255;
-                                               *d-- = DIV(mb, ((pixel & rm) >> rs));
-                                               *d-- = DIV(mg, ((pixel & gm) >> gs));
-                                               *d-- = DIV(mr, ((pixel & bm) >> bs));
-                                       }
-                               }
-                       }
+            {
+                unsigned char *dst, *d;
+                unsigned short *src, *s, pixel;
+
+                offset = (w << 2) - 1;
+                unsigned int srcOffset = w - 1;
+                src = (unsigned short *)srcDataPtr + srcOffset;
+                dst = (unsigned char *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride;
+                dststride = w << 2;
+
+                unsigned int mr = srcSurf->max_red;
+                unsigned int mg = srcSurf->max_green;
+                unsigned int mb = srcSurf->max_red;
+                unsigned int rm = srcSurf->red_mask;
+                unsigned int gm = srcSurf->green_mask;
+                unsigned int bm = srcSurf->blue_mask;
+                unsigned int rs = srcSurf->red_sht;
+                unsigned int gs = srcSurf->green_sht;
+                unsigned int bs = srcSurf->blue_sht;
+
+                for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                    d = dst;
+                    s = src;
+                    for(int x = w; x > 0; x--){
+                        pixel = *s--;
+                        *d-- = 255;
+                        *d-- = DIV(mb, ((pixel & rm) >> rs));
+                        *d-- = DIV(mg, ((pixel & gm) >> gs));
+                        *d-- = DIV(mr, ((pixel & bm) >> bs));
+                    }
+                }
+            }
             break;
 
         case USHORT_GRAY:
-                       {
-                               //if(!srcSurf->invalidated) return false;
-
-                               unsigned char *dst, *d, pixel;
-                               unsigned short *src, *s;
-                               src = (unsigned short *)srcDataPtr;
-                               dst = (unsigned char *)bmpDataPtr;
-
-                               srcstride = srcSurf->scanline_stride;
-                               dststride = w << 2;
-
-                               for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                       s = src;
-                                       d = dst;
-                                       for(int x = w; x > 0; x--){
-                                               pixel = (unsigned char)(*s++ / 257);
-                                               *d++ = pixel;
-                                               *d++ = pixel;
-                                               *d++ = pixel;
-                                               *d++ = 255;
-                                       }
-                               }
-                       }
+            {
+                unsigned char *dst, *d, pixel;
+                unsigned short *src, *s;
+
+                src = (unsigned short *)srcDataPtr;
+                dst = (unsigned char *)bmpDataPtr;
+
+                srcstride = srcSurf->scanline_stride;
+                dststride = w << 2;
+
+                for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                    s = src;
+                    d = dst;
+                    for(int x = w; x > 0; x--){
+                        pixel = (unsigned char)(*s++ / 257);
+                        *d++ = pixel;
+                        *d++ = pixel;
+                        *d++ = pixel;
+                        *d++ = 255;
+                    }
+                }
+            }
             break;
 
         case BYTE_BINARY:
-                       {
-                               //if(!srcSurf->invalidated) return false;
-
-                               unsigned char *src, *s;
-                               unsigned int *dst, *d, pixel, bitnum, elem, shift, bitMask;
-                               src = (unsigned char *)srcDataPtr;
-                               dst = (unsigned int *)bmpDataPtr;
-
-                               srcstride = srcSurf->scanline_stride;
-                               dststride = w;
-                               unsigned int pixelBits = srcSurf->pixel_stride;
-                               int *cm = srcSurf->colormap;
-
-                               for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                       d = dst;
-
-                                       for(unsigned int x = 0; x < w; x++){
-                                               bitnum = x * pixelBits;
-                                               s = src + bitnum / 8;
-                                               elem = *s;
-                                               shift = 8 - (bitnum & 7) - pixelBits;
-                                               bitMask = (1 << pixelBits) - 1;
-                                               pixel = (elem >> shift) & bitMask;
-                                               *d++ = 0xff000000 | *(cm + pixel);
-                                       }
-                               }
-                       }
+            {
+                unsigned char *src, *s;
+                unsigned int *dst, *d, pixel, bitnum, elem, shift, bitMask;
+
+                src = (unsigned char *)srcDataPtr;
+                dst = (unsigned int *)bmpDataPtr;
+
+                srcstride = srcSurf->scanline_stride;
+                dststride = w;
+
+                unsigned int pixelBits = srcSurf->pixel_stride;
+                int *cm = srcSurf->colormap;
+
+                for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                    d = dst;
+
+                    for(unsigned int x = 0; x < w; x++){
+                        bitnum = x * pixelBits;
+                        s = src + bitnum / 8;
+                        elem = *s;
+                        shift = 8 - (bitnum & 7) - pixelBits;
+                        bitMask = (1 << pixelBits) - 1;
+                        pixel = (elem >> shift) & bitMask;
+                        *d++ = 0xff000000 | *(cm + pixel);
+                    }
+                }
+            }
             break;
 
         case BYTE_INDEXED:
-                       {
-                               int transparency = srcSurf->transparency;
-
-                               //if(!srcSurf->invalidated && transparency != GL_TRANSLUCENT) return false;
-                               //if(!srcSurf->invalidated && transparency == GL_TRANSLUCENT &&
-                               //      srcSurf->isAlphaPre && alphaPre) return false;
-                               //if(!srcSurf->invalidated && transparency == GL_TRANSLUCENT &&
-                               //      !srcSurf->isAlphaPre && !alphaPre) return false;
-
-                               unsigned char *src, *s;
-                               unsigned int *dst, *d, pixel, r, g, b, a;
-
-                               unsigned int offset = w - 1;
-                               src = (unsigned char *)srcDataPtr + offset;
-                               dst = (unsigned int *)bmpDataPtr + offset;
-
-                               srcstride = srcSurf->scanline_stride;
-                               dststride = w;
-                               int *cm = srcSurf->colormap;
-                               int tp = srcSurf->transparent_pixel;
-                               if(transparency == GL_OPAQUE){
-                                       for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0; x--){
-                                                       *d-- = 0xff000000 | *(cm + *s--);
-                                               }
-                                       }
-                               }else if(transparency == GL_BITMASK){
-                                       for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0; x--){
-                                                       pixel = *s--;
-                                                       if(pixel != tp){
-                                                               *d-- = 0xff000000 | *(cm + pixel);
-                                                       }else{
-                                                               srcSurf->hasRealAlpha = true;
-                                                               *d-- = 0;
-                                                       }
-                                               }
-                                       }
-                               }else{
-                                       for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                               s = src;
-                                               d = dst;
-
-                                               for(int x = w; x > 0; x--){
-                                                       pixel = *(cm + *s--);
-                                                       a = (pixel >> 24) & 0xff;
-                                                       if(alphaPre){
-                                                               if(a == 255){
-                                                                       *d-- = pixel;
-                                                               }else{
-                                                                       r = (pixel >> 16) & 0xff;
-                                                                       g = (pixel >> 8) & 0xff;
-                                                                       b = pixel & 0xff;
-                                                                       r = MUL(a, r);
-                                                                       g = MUL(a, g);
-                                                                       b = MUL(a, b);
-                                                                       *d-- = (a << 24) | (r << 16) | (g << 8) | b;
-                                                                       srcSurf->hasRealAlpha = true;
-                                                               }
-                                                               srcSurf->isAlphaPre = true;
-                                                       }else{
-                                                               if(a == 0) *d-- = 0;
-                                                               else *d-- = pixel;
-                                                               srcSurf->isAlphaPre = false;
-                                                       }
-                                               }
-                                       }
-                               }
-                       }
+            {
+                int transparency = srcSurf->transparency;
+                unsigned char *src, *s;
+                unsigned int *dst, *d, pixel, r, g, b, a;
+
+                unsigned int offset = w - 1;
+                src = (unsigned char *)srcDataPtr + offset;
+                dst = (unsigned int *)bmpDataPtr + offset;
+
+                srcstride = srcSurf->scanline_stride;
+                dststride = w;
+                int *cm = srcSurf->colormap;
+                int tp = srcSurf->transparent_pixel;
+
+                if(transparency == GL_OPAQUE){
+                    for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0; x--){
+                            *d-- = 0xff000000 | *(cm + *s--);
+                        }
+                    }
+                }else if(transparency == GL_BITMASK){
+                    for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0; x--){
+                            pixel = *s--;
+                            if(pixel != tp){
+                                *d-- = 0xff000000 | *(cm + pixel);
+                            }else{
+                                srcSurf->hasRealAlpha = true;
+                                *d-- = 0;
+                            }
+                        }
+                    }
+                }else{
+                    for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                        s = src;
+                        d = dst;
+
+                        for(int x = w; x > 0; x--){
+                            pixel = *(cm + *s--);
+                            a = (pixel >> 24) & 0xff;
+                            if(alphaPre){
+                                if(a == 255){
+                                    *d-- = pixel;
+                                }else{
+                                    r = (pixel >> 16) & 0xff;
+                                    g = (pixel >> 8) & 0xff;
+                                    b = pixel & 0xff;
+                                    r = MUL(a, r);
+                                    g = MUL(a, g);
+                                    b = MUL(a, b);
+                                    *d-- = (a << 24) | (r << 16) | (g << 8) | b;
+                                }
+                                srcSurf->isAlphaPre = true;
+                            }else{
+                                if(a == 0) *d-- = 0;
+                                else *d-- = pixel;
+                                srcSurf->isAlphaPre = false;
+                            }
+                        }
+                    }
+                }
+            }
             break;
 
         case BYTE_GRAY:
-                       {
-                               //if(!srcSurf->invalidated) return false;
-                               unsigned char *src, *s, *dst, *d, pixel;
-                               src = (unsigned char *)srcDataPtr;
-                               dst = (unsigned char *)bmpDataPtr;
-
-                               srcstride = srcSurf->scanline_stride;
-                               dststride = w << 2;
-
-                               for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
-                                       s = src;
-                                       d = dst;
-
-                                       for(int x = srcSurf->width; x > 0; x--){
-                                               pixel = *s++;
-                                               *d++ = pixel;
-                                               *d++ = pixel;
-                                               *d++ = pixel;
-                                               *d++ = 255;
-                                       }
-                               }
-                       }
+            {
+                unsigned char *src, *s, *dst, *d, pixel;
+
+                src = (unsigned char *)srcDataPtr;
+                dst = (unsigned char *)bmpDataPtr;
+
+                srcstride = srcSurf->scanline_stride;
+                dststride = w << 2;
+
+                for(int y = h; y > 0; y--, src += srcstride, dst += dststride){
+                    s = src;
+                    d = dst;
+
+                    for(int x = srcSurf->width; x > 0; x--){
+                        pixel = *s++;
+                        *d++ = pixel;
+                        *d++ = pixel;
+                        *d++ = pixel;
+                        *d++ = 255;
+                    }
+                }
+            }
             break;
     }
     env->ReleasePrimitiveArrayCritical((jarray)srcData, srcDataPtr, 0);
@@ -610,359 +577,153 @@
  * Signature: (IIIIIIIIII[I[II[IIZ[I[IIZZI)J
  */
 JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_createSurfStruct
-  (JNIEnv * env, jobject obj, jint surfType, jint width, jint height, jint cmType, 
-  jint csType, jint smType, jint dataType, jint numComponents, jint pixelStride, 
-  jint scanlineStride, jintArray bits, jintArray masks, jint colorMapSize, 
-  jintArray colorMap, jint transpPixel, jboolean isGrayPalette, jintArray bankIndeces, 
-  jintArray bandOffsets, jint offset, jboolean hasAlpha, jboolean isAlphaPre, 
-  jint transparency){
-
-      SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)calloc(sizeof(SURFACE_STRUCTURE), 1);
-      if(surf != NULL){
-          surf->ss_type = surfType;
-          surf->width = width;
-          surf->height = height;
-          surf->cm_type = cmType;
-          surf->cs_type = csType;
-          surf->data_type = dataType;
-          surf->num_components = numComponents;
-          surf->pixel_stride = pixelStride;
-          surf->scanline_stride = scanlineStride;
-                 surf->offset = offset;
-                 surf->has_alpha = hasAlpha;
-                 surf->isAlphaPre = isAlphaPre != 0;
-                 surf->transparency = transparency;
-                 if(dataType == TYPE_BYTE){
-                         surf->scanline_stride_byte = scanlineStride;
-                 }else if(dataType == TYPE_USHORT){
-                         surf->scanline_stride_byte = scanlineStride << 1;
-                 }else if(dataType == TYPE_INT){
-                         surf->scanline_stride_byte = scanlineStride << 2;
-                 }
-
-                 void *p;
-                 int *s, *d;
-                 switch(cmType){
-                         case DIRECT_CM:
-                                 surf->bits = (int *)malloc(surf->num_components * sizeof(int));
-                                 p = env->GetPrimitiveArrayCritical(bits, 0);
-                                 d = surf->bits;
-                                 s = (int *)p;
-                                 for(int i = 0; i < numComponents; i++){
-                                         *d++ = *s++;
-                                 }
-                                 env->ReleasePrimitiveArrayCritical(bits, p, 0);
-                                 p = env->GetPrimitiveArrayCritical(masks, 0);
-                                 s = (int *)p;
+(JNIEnv * env, jobject obj, jint surfType, jint width, jint height, jint cmType, 
+    jint csType, jint smType, jint dataType, jint numComponents, jint pixelStride, 
+    jint scanlineStride, jintArray bits, jintArray masks, jint colorMapSize, 
+    jintArray colorMap, jint transpPixel, jboolean isGrayPalette, jintArray bankIndeces, 
+    jintArray bandOffsets, jint offset, jboolean hasAlpha, jboolean isAlphaPre, 
+    jint transparency){
+
+        SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)calloc(sizeof(SURFACE_STRUCTURE), 1);
+
+        if(surf != NULL){
+            surf->ss_type = surfType;
+            surf->width = width;
+            surf->height = height;
+            surf->cm_type = cmType;
+            surf->cs_type = csType;
+            surf->data_type = dataType;
+            surf->num_components = numComponents;
+            surf->pixel_stride = pixelStride;
+            surf->scanline_stride = scanlineStride;
+            surf->offset = offset;
+            surf->has_alpha = hasAlpha;
+            surf->isAlphaPre = isAlphaPre != 0;
+            surf->transparency = transparency;
+
+            if(dataType == TYPE_BYTE){
+                surf->scanline_stride_byte = scanlineStride;
+            }else if(dataType == TYPE_USHORT){
+                surf->scanline_stride_byte = scanlineStride << 1;
+            }else if(dataType == TYPE_INT){
+                surf->scanline_stride_byte = scanlineStride << 2;
+            }
+
+            void *p;
+            int *s, *d;
+
+            switch(cmType){
+                case DIRECT_CM:
+                    surf->bits = (int *)malloc(surf->num_components * sizeof(int));
+                    p = env->GetPrimitiveArrayCritical(bits, 0);
+                    d = surf->bits;
+                    s = (int *)p;
+
+                    for(int i = 0; i < numComponents; i++){
+                        *d++ = *s++;
+                    }
+
+                    env->ReleasePrimitiveArrayCritical(bits, p, 0);
+
+                    p = env->GetPrimitiveArrayCritical(masks, 0);
+                    s = (int *)p;
                                  
-                                 surf->red_mask = *s++;
-                                 surf->green_mask = *s++;
-                                 surf->blue_mask = *s++;
-                                 if(hasAlpha){
-                                         surf->alpha_mask = *s;
-                                 }
-                                 env->ReleasePrimitiveArrayCritical(masks, p, 0);
-
-                                 surf->red_sht = getShift(surf->red_mask);
-                                 surf->max_red = (1 << surf->bits[0]) - 1;
-                                 surf->green_sht = getShift(surf->green_mask);
-                                 surf->max_green = (1 << surf->bits[1]) - 1;
-                                 surf->blue_sht = getShift(surf->blue_mask);
-                                 surf->max_blue = (1 << surf->bits[2]) - 1;
-                                 if(hasAlpha){
-                                         surf->alpha_sht = getShift(surf->alpha_mask);
-                                         surf->max_alpha = ( 1 << surf->bits[3]) - 1;
-                                 }
-                                 break;
-
-                         case INDEX_CM:
-                                 surf->colormap_size = colorMapSize;
-                                 surf->transparent_pixel = transpPixel;
-                                 surf->isGrayPallete = isGrayPalette;
-                                 surf->colormap = (int *)malloc(colorMapSize * sizeof(int));
-                                 p = env->GetPrimitiveArrayCritical(colorMap, 0);
-                                 memcpy(surf->colormap, p, colorMapSize * sizeof(int));
-                                 env->ReleasePrimitiveArrayCritical(colorMap, p, 0);
-                                 break;
-
-                         case COMPONENT_CM:
-                                 surf->bank_indexes = (int *)malloc(numComponents * sizeof(int));
-                                 surf->band_offsets = (int *)malloc(numComponents * sizeof(int));
-
-                                 p = env->GetPrimitiveArrayCritical(bankIndeces, 0);
-                                 memcpy((void *)surf->bank_indexes, p, numComponents * sizeof(int));
-                                 env->ReleasePrimitiveArrayCritical(bankIndeces, p, 0);
-
-                                 p = env->GetPrimitiveArrayCritical(bandOffsets, 0);
-                                 memcpy((void *)surf->band_offsets, p, numComponents * sizeof(int));
-                                 env->ReleasePrimitiveArrayCritical(bandOffsets, p, 0);
-                                 break;
-                 }
-                 surf->bmp_byte_stride = surf->width << 2;
-                 surf->bmpData = malloc(surf->bmp_byte_stride  * surf->height);
-          surf->invalidated = true;
+                    surf->red_mask = *s++;
+                    surf->green_mask = *s++;
+                    surf->blue_mask = *s++;
+                    if(hasAlpha){
+                        surf->alpha_mask = *s;
+                    }
+                    env->ReleasePrimitiveArrayCritical(masks, p, 0);
+
+                    surf->red_sht = getShift(surf->red_mask);
+                    surf->max_red = (1 << surf->bits[0]) - 1;
+                    surf->green_sht = getShift(surf->green_mask);
+                    surf->max_green = (1 << surf->bits[1]) - 1;
+                    surf->blue_sht = getShift(surf->blue_mask);
+                    surf->max_blue = (1 << surf->bits[2]) - 1;
+                    if(hasAlpha){
+                        surf->alpha_sht = getShift(surf->alpha_mask);
+                        surf->max_alpha = ( 1 << surf->bits[3]) - 1;
+                    }
+                    break;
+
+                case INDEX_CM:
+                    surf->colormap_size = colorMapSize;
+                    surf->transparent_pixel = transpPixel;
+                    surf->isGrayPallete = isGrayPalette;
+                    surf->colormap = (int *)malloc(colorMapSize * sizeof(int));
+
+                    p = env->GetPrimitiveArrayCritical(colorMap, 0);
+                    memcpy(surf->colormap, p, colorMapSize * sizeof(int));
+                    env->ReleasePrimitiveArrayCritical(colorMap, p, 0);
+                    break;
+
+                case COMPONENT_CM:
+                    surf->bank_indexes = (int *)malloc(numComponents * sizeof(int));
+                    surf->band_offsets = (int *)malloc(numComponents * sizeof(int));
+
+                    p = env->GetPrimitiveArrayCritical(bankIndeces, 0);
+                    memcpy((void *)surf->bank_indexes, p, numComponents * sizeof(int));
+                    env->ReleasePrimitiveArrayCritical(bankIndeces, p, 0);
+
+                    p = env->GetPrimitiveArrayCritical(bandOffsets, 0);
+                    memcpy((void *)surf->band_offsets, p, numComponents * sizeof(int));
+                    env->ReleasePrimitiveArrayCritical(bandOffsets, p, 0);
+                    break;
+            }
+            surf->bmp_byte_stride = surf->width << 2;
+            surf->invalidated = true;
 
 #ifdef _WIN32
-                 surf->bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-          surf->bmpInfo.bmiHeader.biWidth = surf->width;
-          surf->bmpInfo.bmiHeader.biHeight = -surf->height;
-          surf->bmpInfo.bmiHeader.biPlanes = 1;
-          surf->bmpInfo.bmiHeader.biBitCount = 32;
-          surf->bmpInfo.bmiHeader.biSizeImage = surf->bmp_byte_stride * surf->height;
-          surf->bmpInfo.bmiHeader.biCompression = BI_BITFIELDS;
-          DWORD *colors = (DWORD *)surf->bmpInfo.bmiColors;
-          colors[0] = 0xff0000;
-          colors[1] = 0xff00;
-          colors[2] = 0xff;
-
-          HDC dc = GetDC(NULL);
-          surf->srcDC = CreateCompatibleDC(dc);
-                 surf->bitmap = CreateCompatibleBitmap(dc, surf->width, surf->height);
-                 ReleaseDC(NULL, dc);
-          if(surf->srcDC != NULL && surf->bitmap != NULL){
-              SelectObject(surf->srcDC, surf->bitmap);
-          }
-          surf->isAlphaPre = true;
-                 //surf->bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-    //      surf->bmpInfo.bmiHeader.biWidth = surf->width;
-    //      surf->bmpInfo.bmiHeader.biHeight = -surf->height;
-    //      surf->bmpInfo.bmiHeader.biPlanes = 1;
-    //      surf->bmpInfo.bmiHeader.biBitCount = 16;
-                 //surf->bmp_byte_stride = surf->width << 1;
-    //      surf->bmpInfo.bmiHeader.biCompression = BI_BITFIELDS;
-    //      DWORD *colors = (DWORD *)surf->bmpInfo.bmiColors;
-                 //colors[0] = redMask;
-                 //colors[1] = greenMask;
-    //      colors[2] = blueMask;
-    //      surf->bitmap = CreateDIBSection(NULL, (BITMAPINFO *)&surf->bmpInfo, DIB_RGB_COLORS, &surf->bmpData, NULL, 0);
-
-    //      surf->invalidated = true;
-    //      surf->isAlphaPre = true;
+            surf->bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+            surf->bmpInfo.bmiHeader.biWidth = surf->width;
+            surf->bmpInfo.bmiHeader.biHeight = -surf->height;
+            surf->bmpInfo.bmiHeader.biPlanes = 1;
+            surf->bmpInfo.bmiHeader.biBitCount = 32;
+            surf->bmpInfo.bmiHeader.biSizeImage = surf->bmp_byte_stride * surf->height;
+            surf->bmpInfo.bmiHeader.biCompression = BI_BITFIELDS;
+            DWORD *colors = (DWORD *)surf->bmpInfo.bmiColors;
+            colors[0] = 0xff0000;
+            colors[1] = 0xff00;
+            colors[2] = 0xff;
+
+            HDC dc = GetDC(NULL);
+            surf->srcDC = CreateCompatibleDC(NULL);
+            if(GetDeviceCaps(dc, BITSPIXEL) != 32) {
+                surf->bitmap = CreateDIBSection(NULL, (BITMAPINFO *)&surf->bmpInfo, DIB_RGB_COLORS, &surf->bmpData, NULL, 0);
+            } else {
+                surf->bitmap = CreateCompatibleBitmap(dc, surf->width, surf->height);
+                surf->bmpData = malloc(surf->bmp_byte_stride  * surf->height);
+                surf->isTrueColor = TRUE;
+            }
+            ReleaseDC(NULL, dc);
+            if(surf->srcDC != NULL && surf->bitmap != NULL){
+                SelectObject(surf->srcDC, surf->bitmap);
+            }
+            surf->isAlphaPre = true;
+#else
+            surf->bmpData = malloc(surf->bmp_byte_stride  * surf->height);
 #endif
-      }
-      return (jlong)surf;
+        }
+        return (jlong)surf;
   
-  }
-
-//JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_createStructDCM
-//  (JNIEnv * env, jobject obj, jint surfDataType, jint dataType, jint csType, 
-//  jint redMask, jint greenMask, jint blueMask, jint alphaMask, jint pixelStride, 
-//  jint scanlineStride, jint width, jint height, jint transparancy, jboolean isAlphaPre){
-//
-//      SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)calloc(sizeof(SURFACE_STRUCTURE), 1);
-//      if(surf != NULL){
-//          surf->ss_type = surfDataType;
-//          surf->cm_type = DIRECT_CM;
-//          surf->cs_type = csType;
-//          surf->data_type = dataType;
-//          surf->red_mask = redMask;
-//          surf->green_mask = greenMask;
-//          surf->blue_mask = blueMask;
-//          surf->alpha_mask = alphaMask;
-//          surf->scanline_stride = scanlineStride;
-//          switch(surf->ss_type){
-//              case INT_RGB:
-//              case INT_ARGB:
-//              case INT_ARGB_PRE:
-//              case INT_BGR:
-//                  surf->scanline_stride_byte = scanlineStride << 2;
-//                  break;
-//              case USHORT_555:
-//              case USHORT_565:
-//                  surf->scanline_stride_byte = scanlineStride << 1;
-//                  break;
-//              //default:
-//                  // TODO
-//          }
-//          surf->pixel_stride = pixelStride;
-//          surf->width = width;
-//          surf->height = height;
-//          surf->transparency = transparancy;
-//          surf->alpha_pre = isAlphaPre;
-//          surf->num_components = (alphaMask == 0 ? 3 : 4);
-//
-//          surf->bits = (int *)malloc(surf->num_components * sizeof(int));
-//          surf->bits[0] = parseMask(redMask, &surf->red_sht, &surf->max_red);
-//          surf->bits[1] = parseMask(greenMask, &surf->green_sht, &surf->max_green);
-//          surf->bits[2] = parseMask(blueMask, &surf->blue_sht, &surf->max_blue);
-//          if(alphaMask != 0){
-//            surf->bits[3] = parseMask(alphaMask, &(surf->alpha_sht), &(surf->max_alpha));
-//            surf->has_alpha = 1;
-//          }
-//
-//#ifdef _WIN32
-//          GLBITMAPINFO glbmpInfo;
-//          memset(&glbmpInfo, 0, sizeof(GLBITMAPINFO));
-//          UINT stride;
-//          glbmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-//          glbmpInfo.bmiHeader.biWidth = surf->width;
-//          glbmpInfo.bmiHeader.biHeight = -surf->height;
-//          glbmpInfo.bmiHeader.biPlanes = 1;
-//          glbmpInfo.bmiHeader.biBitCount = 32;
-//          stride = surf->width << 2;
-//          glbmpInfo.bmiHeader.biSizeImage = stride * surf->height;
-//          glbmpInfo.bmiHeader.biCompression = BI_BITFIELDS;
-//          DWORD *colors = (DWORD *)glbmpInfo.bmiColors;
-//          colors[0] = 0xff0000;
-//          colors[1] = 0xff00;
-//          colors[2] = 0xff;
-//          surf->srcDC = CreateCompatibleDC(NULL);
-//          surf->bitmap = CreateDIBSection(NULL, (BITMAPINFO *)&glbmpInfo, DIB_RGB_COLORS, &surf->bmpData, NULL, 0);
-//          if(surf->srcDC != NULL && surf->bitmap != NULL){
-//              SelectObject(surf->srcDC, surf->bitmap);
-//          }
-//          surf->invalidated = true;
-//          surf->isAlphaPre = true;
-//#endif
-//      }
-//      return (jlong)surf;
-//  }
-//
-//JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_createStructICM
-//  (JNIEnv *env, jobject obj, jint surfDataType, jint dataType, jint pixelStride, 
-//  jint scanlineStride, jint width, jint height, jint mapSize, jintArray colorMap, 
-//  jboolean isGrayPallete, jint transparency, jint trans, jint smType){
-//
-//      SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)calloc(sizeof(SURFACE_STRUCTURE), 1);
-//      if(surf != NULL){
-//          surf->ss_type = surfDataType;
-//          surf->cm_type = INDEX_CM;
-//          surf->cs_type = sRGB_CS;
-//          surf->pixel_stride = pixelStride;
-//          surf->scanline_stride = scanlineStride;
-//          surf->scanline_stride_byte = scanlineStride;
-//          surf->width = width;
-//          surf->height = height;
-//          surf->colormap_size = mapSize;
-//          surf->transparency = transparency;
-//          surf->transparent_pixel = trans;
-//          surf->sm_type = smType;
-//          surf->has_alpha = (transparency == GL_OPAQUE ? 0 : 1);
-//          surf->isGrayPallete = isGrayPallete;
-//          surf->colormap = (int *)malloc(mapSize * sizeof(int));
-//          void *p = env->GetPrimitiveArrayCritical(colorMap, 0);
-//          memcpy((void *)surf->colormap, p, mapSize << 2);
-//          env->ReleasePrimitiveArrayCritical(colorMap, p, 0);
-//#ifdef _WIN32
-//          GLBITMAPINFO glbmpInfo;
-//          memset(&glbmpInfo, 0, sizeof(GLBITMAPINFO));
-//          UINT stride;
-//          glbmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-//          glbmpInfo.bmiHeader.biWidth = surf->width;
-//          glbmpInfo.bmiHeader.biHeight = -surf->height;
-//          glbmpInfo.bmiHeader.biPlanes = 1;
-//          glbmpInfo.bmiHeader.biBitCount = 32;
-//          stride = surf->width << 2;
-//          glbmpInfo.bmiHeader.biSizeImage = stride * surf->height;
-//          glbmpInfo.bmiHeader.biCompression = BI_BITFIELDS;
-//          DWORD *colors = (DWORD *)glbmpInfo.bmiColors;
-//          colors[0] = 0xff0000;
-//          colors[1] = 0xff00;
-//          colors[2] = 0xff;
-//
-//          surf->srcDC = CreateCompatibleDC(NULL);
-//          surf->bitmap = CreateDIBSection(NULL, (BITMAPINFO *)&glbmpInfo, DIB_RGB_COLORS, &surf->bmpData, NULL, 0);
-//          if(surf->srcDC != NULL && surf->bitmap != NULL){
-//              SelectObject(surf->srcDC, surf->bitmap);
-//          }
-//          surf->invalidated = true;
-//          surf->isAlphaPre = true;
-//#endif
-//      }
-//
-//      return (jlong)surf;
-//  }
-//
-//JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_createStructCCM
-//  (JNIEnv *env, jobject obj, jint surfDataType, jint dataType, jint csType, 
-//  jint numComponents, jint pixelStride, jint scanlineStride, jint width, jint height, jintArray bits,
-//  jintArray bankIndeces, jintArray bandOffsets, jint transparency, jboolean isAlphaPre){
-//
-//      SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)calloc(sizeof(SURFACE_STRUCTURE), 1);
-//      if(surf != NULL){
-//          surf->ss_type = surfDataType;
-//          surf->cm_type = COMPONENT_CM;
-//          surf->cs_type = csType;
-//          surf->num_components = numComponents;
-//          surf->pixel_stride = pixelStride;
-//          surf->scanline_stride = scanlineStride;
-//          switch(surf->ss_type){
-//              case BYTE_BGR:
-//              case BYTE_ABGR:
-//              case BYTE_ABGR_PRE:
-//              case BYTE_GRAY:
-//                  surf->scanline_stride_byte = scanlineStride;
-//                  break;
-//              case USHORT_GRAY:
-//                  surf->scanline_stride_byte = scanlineStride << 1;
-//                  break;
-//              //default:
-//                  // TODO
-//          }
-//          surf->width = width;
-//          surf->height = height;
-//          surf->transparency = transparency;
-//          surf->has_alpha = (transparency == GL_OPAQUE ? 0 : 1);
-//          surf->alpha_pre = isAlphaPre;
-//
-//          surf->bits = (int *)malloc(numComponents * sizeof(int));
-//          surf->bank_indexes = (int *)malloc(numComponents * sizeof(int));
-//          surf->band_offsets = (int *)malloc(numComponents * sizeof(int));
-//
-//          void *p = env->GetPrimitiveArrayCritical(bits, 0);
-//          memcpy((void *)surf->bits, p, numComponents << 2);
-//          env->ReleasePrimitiveArrayCritical(bits, p, 0);
-//
-//          p = env->GetPrimitiveArrayCritical(bankIndeces, 0);
-//          memcpy((void *)surf->bank_indexes, p, numComponents << 2);
-//          env->ReleasePrimitiveArrayCritical(bankIndeces, p, 0);
-//
-//          p = env->GetPrimitiveArrayCritical(bandOffsets, 0);
-//          memcpy((void *)surf->band_offsets, p, numComponents << 2);
-//          env->ReleasePrimitiveArrayCritical(bandOffsets, p, 0);
-//      }
-//#ifdef _WIN32
-//          GLBITMAPINFO glbmpInfo;
-//          memset(&glbmpInfo, 0, sizeof(GLBITMAPINFO));
-//          UINT stride;
-//          glbmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-//          glbmpInfo.bmiHeader.biWidth = surf->width;
-//          glbmpInfo.bmiHeader.biHeight = -surf->height;
-//          glbmpInfo.bmiHeader.biPlanes = 1;
-//          glbmpInfo.bmiHeader.biBitCount = 32;
-//          stride = surf->width << 2;
-//          glbmpInfo.bmiHeader.biSizeImage = stride * surf->height;
-//          glbmpInfo.bmiHeader.biCompression = BI_BITFIELDS;
-//          DWORD *colors = (DWORD *)glbmpInfo.bmiColors;
-//          colors[0] = 0xff0000;
-//          colors[1] = 0xff00;
-//          colors[2] = 0xff;
-//          surf->srcDC = CreateCompatibleDC(NULL);
-//          surf->bitmap = CreateDIBSection(NULL, (BITMAPINFO *)&glbmpInfo, DIB_RGB_COLORS, &surf->bmpData, NULL, 0);
-//          if(surf->srcDC != NULL && surf->bitmap != NULL){
-//              SelectObject(surf->srcDC, surf->bitmap);
-//          }
-//          surf->invalidated = true;
-//          surf->isAlphaPre = true;
-//#endif
-//
-//      return (jlong)surf;
-//  }
+}
 
 JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_updateCache
 (JNIEnv *env, jobject obj, jlong ptr, jobject data, jboolean alphaPre){
 
     SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)ptr;
-       jlong cachePtr = 0;
-       if(surf != NULL){
-               updateCache(surf, env, data, alphaPre != 0);
-               cachePtr = (jlong)surf->bmpData;
-       }
-       return cachePtr;
+    jlong cachePtr = 0;
+    if(surf != NULL){
+        updateCache(surf, env, data, alphaPre != 0);
+        cachePtr = (jlong)surf->bmpData;
+    }
+    return cachePtr;
 }
 
 JNIEXPORT void JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_dispose
-  (JNIEnv *env, jobject obj, jlong ptr){
+(JNIEnv *env, jobject obj, jlong ptr){
 
     SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)ptr;
 
@@ -971,20 +732,25 @@
         if(surf->colormap) free(surf->colormap);
         if(surf->bank_indexes) free(surf->bank_indexes);
         if(surf->band_offsets) free(surf->band_offsets);
-               if(surf->bmpData) free(surf->bmpData);
 #ifdef _WIN32
+        if(surf->isTrueColor){
+            if(surf->bmpData) free(surf->bmpData);
+        }
         if(surf->bitmap) DeleteObject(surf->bitmap);
         if(surf->srcDC) DeleteDC(surf->srcDC);
+#else
+        if(surf->bmpData) free(surf->bmpData);
 #endif
         free(surf);
     }
-  }
+}
 
 JNIEXPORT void JNICALL Java_org_apache_harmony_awt_gl_ImageSurface_setImageSize
-  (JNIEnv *env, jobject obj, jlong ptr, jint width, jint height) {
+(JNIEnv *env, jobject obj, jlong ptr, jint width, jint height) {
+
     SURFACE_STRUCTURE *surf = (SURFACE_STRUCTURE *)ptr;
     surf->scanline_stride = surf->scanline_stride / surf->width * width;
     surf->scanline_stride_byte = surf->scanline_stride_byte / surf->width * width;
     surf->width = width;
     surf->height = height;
-  }
+}

Modified: harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.h?rev=572378&r1=572377&r2=572378&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.h (original)
+++ harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/shared/SurfaceDataStructure.h Mon Sep  3 09:08:13 2007
@@ -139,9 +139,9 @@
     int *band_offsets;
 
        // Cached Data
-       long bmp_byte_stride;
+    long bmp_byte_stride;
     void *bmpData;
-       bool hasRealAlpha;
+    bool hasRealAlpha;
     bool invalidated;
     bool isAlphaPre;
 
@@ -153,6 +153,7 @@
     HBITMAP bitmap;
     HDC srcDC;
     DWORD rtc;
+    BOOL isTrueColor;
 #endif
 
 

Modified: harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/windows/GDIBlitter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/windows/GDIBlitter.cpp?rev=572378&r1=572377&r2=572378&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/windows/GDIBlitter.cpp (original)
+++ harmony/enhanced/classlib/trunk/modules/awt/src/main/native/gl/windows/GDIBlitter.cpp Mon Sep  3 09:08:13 2007
@@ -196,7 +196,10 @@
       memset(&blitStruct, 0, sizeof(BLITSTRUCT));
 
       srcSurf->invalidated = invalidated != 0;
-      if(!initBlitData(srcSurf, env, srcData, compType, srca, &blitStruct)) return;
+
+      if(!initBlitData(srcSurf, env, srcData, compType, srca, &blitStruct)){
+           return;
+      }
 
       XFORM currentTransform, transform;
       if(matrix != NULL){
@@ -487,7 +490,11 @@
         return false;
     }
     updateCache(srcSurf, env, srcData, alphaPre != 0);
-    SetDIBits(srcSurf->srcDC, srcSurf->bitmap, 0, srcSurf->height, srcSurf->bmpData, (BITMAPINFO *)&srcSurf->bmpInfo, DIB_RGB_COLORS);
+    if(srcSurf->isTrueColor){
+        SetDIBits(srcSurf->srcDC, srcSurf->bitmap, 0, srcSurf->height, srcSurf->bmpData, (BITMAPINFO *)&srcSurf->bmpInfo, DIB_RGB_COLORS);
+    }else{
+        GdiFlush();
+    }
     return true;
 }
 



Mime
View raw message