images.c

用于移动设备上的java虚拟机源代码

            color  = makeImagePixel((r << 16) | (g << 8) | b);
            pel    = p->bitmap->image + ((y * p->bitmap->width + x) << 2);

            /*
             * DIBs use bgr triples not rgb
             */
            *pel++ = GetBValue(color);
            *pel++ = GetGValue(color);
            *pel++ = GetRValue(color);
#if USE_ALPHA_BLEND
            *pel++ = alpha;
#endif
        }
        
    } else { /* grayscale or indexed color */
        for (x = 0; x < p->bitmap->width; ++x) {
            unsigned char *pel;

            int cmapIndex = *pixels++;
            off = mat[x & 3];
            color = p->cmap[cmapIndex];

            r = ((color >> 16) & 0xff) + off;
            g = ((color >>  8) & 0xff) + off;
            b = ((color >>  0) & 0xff) + off;
            alpha = 0xff; /* assume full opacity */

            if (r < 0) r = 0; else if (r > 0xff) r = 0xff;
            if (g < 0) g = 0; else if (g > 0xff) g = 0xff;
            if (b < 0) b = 0; else if (b > 0xff) b = 0xff;
           
            /* grayscale with alpha */
            if ((pixelType & (CT_ALPHA | CT_COLOR)) == CT_ALPHA) { 
                alpha = *pixels++;
                p->bitmap->prop = HAS_ALPHA;
            } else if (p->hasTransMap) {
                if ((pixelType & CT_COLOR) == 0) { /* grayscale */

                alpha = *pixels++;
                p->bitmap->prop = HAS_ALPHA;

                } else { /* indexed color */
                    alpha = p->tmap[cmapIndex];
                    p->bitmap->prop = HAS_ALPHA;
                }

            }

            if (p->bitmap->prop == HAS_ALPHA) {
                blendPixel(&r, &g, &b, &alpha, off);
            } 
            
#if USE_ALPHA_BLEND
            if (p->bitmap->prop == HAS_MASK) {
                buildMask(p->bitmap, alpha, x, y);
            }
#else
            if (p->bitmap->prop == HAS_MASK || 
                p->bitmap->prop == HAS_ALPHA) {
                buildMask(p->bitmap, alpha, x, y);
            }
#endif

            color  = makeImagePixel((r << 16) | (g << 8) | b);
            pel    = p->bitmap->image + ((y * p->bitmap->width + x) << 2);
            
            /*
             * DIBs use bgr triples not rgb
             */
            *pel++ = GetBValue(color);
            *pel++ = GetGValue(color);
            *pel++ = GetRValue(color);
#if USE_ALPHA_BLEND
            *pel++ = alpha;
#endif
        }
    }

    DeleteDC(hdcMem);    
}

static void
sendPackedImagePixels(imageDstPtr self, int y, uchar *pixels) 
{
    /* we specified a depth of 8, so... */
    sendImagePixels(self, y, pixels, KNI_FALSE);
}

static void*
imageDone(imageDstPtr self, int *width, int *height)
{
    _imageDstPtr p = (_imageDstPtr)self;

    if (p == NULL) return NULL;

    if ((width != NULL) && (height != NULL)) {
        *width  = p->bitmap->width;
        *height = p->bitmap->height;
    }

    return (void*)p->bitmap;
}

void
LCDUIdestroyNativeImage(void* imagePtr) {
    myBitmapStruct *imgData = (myBitmapStruct*)imagePtr;

    if (imgData != NULL) {
        if (imgData->bitmap) {
            DeleteObject(imgData->bitmap);
        }
        if (imgData->mask) {
            DeleteObject(imgData->mask);
        }
        
        midpFree(imagePtr);
    }
}

imageDstPtr 
LCDUIcreateImageDst(jboolean mutable) {
    _imageDstPtr p = midpMalloc(sizeof(_imageDstData));

    if (p == NULL) {
        return NULL;
    }

    p->super.depth            = 8;
    p->super.setColormap      = setImageColormap;
    p->super.setTransMap      = setImageTransparencyMap;
    p->super.setSize          = setImageSize;
    p->super.sendPixels       = sendImagePixels;
    p->super.sendPackedPixels = sendPackedImagePixels;
    p->super.copyPixels       = copyImagePixels;
    p->super.done             = imageDone;
    p->super.setARGBPixels    = setARGBPixels;
    p->super.copyPixelsTransformed
                              = copyPixelsTransformed;

    /* Create a bitmap structure. We use our own private data structure. 
     * But, on some platforms, this may be an opaque data structure 
     * managed by the platform.
     */
    if ((p->bitmap=(myBitmapStruct*)midpMalloc(sizeof(myBitmapStruct))) == NULL) {
        midpFree(p);
        return NULL;
    }
    p->mutable       = mutable;
    p->hasColormap   = KNI_FALSE;
    p->hasTransMap   = KNI_FALSE;

    return (imageDstPtr)p;
}


#if USE_ALPHA_BLEND
BOOL customAlphaBlend(HDC hdcDest, int nXOriginDest, int nYOriginDest, 
                  HDC hdcSrc,  int nXOriginSrc,  int nYOriginSrc,  
                  int nWidth,  int nHeight,
                                    int transform, jboolean processAlpha) {

    int imgLen;
    int scanLength;
    unsigned char *srcBits       = NULL, 
                  *destBits      = NULL, 
                  *destBitsPtr   = NULL,
                  *srcBitsPtr    = NULL,
                  *srcBitsEndPtr = NULL,
                  *lineEndPtr    = NULL;
    int destX, destY;
    int xStart;
    int yStart;
    int xIncr;
    int yIncr;

    int alpha;

    int t_width;
    int t_height;
    
    BOOL ret = KNI_FALSE;
    HDC srcHDC, 
        destHDC;

    HBITMAP srcHBmp, destHBmp;

    BITMAP srcBmp;
    
    BITMAPINFO bi;
    HGDIOBJ oobj;

    destHDC = CreateCompatibleDC(hdcSrc);
    srcHBmp = GetCurrentObject(hdcSrc, OBJ_BITMAP);
    
    DB(GetObject(srcHBmp, sizeof(srcBmp), &srcBmp));
        
#if 0
        fprintf(stderr, "bmType=%i\n"
                        "bmWidth=%i\n"
                        "bmHeight=%i\n"
                        "bmWidthBytes=%i\n"
                        "bmPlanes=%i\n"
                        "bmBitsPixel=%i\n\n",
                        srcBmp.bmType,
                        srcBmp.bmWidth,
                        srcBmp.bmHeight,
                        srcBmp.bmWidthBytes,
                        srcBmp.bmPlanes,
                        srcBmp.bmBitsPixel);
#endif

    imgLen = nWidth * nHeight << 2;

    if(transform & TRANSFORM_INVERTED_AXES) {
        t_width  = nHeight;
        t_height = nWidth;
    } else {
        t_width  = nWidth;
        t_height = nHeight;
    }

    bi.bmiHeader.biSize          = sizeof(bi.bmiHeader);
    bi.bmiHeader.biPlanes        = srcBmp.bmPlanes;

    bi.bmiHeader.biBitCount      = 32; 
    /* srcBmp.bmPlanes * srcBmp.bmBitsPixel;*/

    bi.bmiHeader.biCompression   = BI_RGB;
    bi.bmiHeader.biXPelsPerMeter = 0;
    bi.bmiHeader.biYPelsPerMeter = 0;
    bi.bmiHeader.biClrUsed       = 0;
    bi.bmiHeader.biClrImportant  = 0;
    
    bi.bmiHeader.biWidth         = t_width;
    bi.bmiHeader.biHeight        = -t_height;
    bi.bmiHeader.biSizeImage     = t_width * t_height << 2;

    destHBmp = CreateDIBSection(destHDC, &bi, DIB_RGB_COLORS, 
                                &destBits, NULL, 0);
    
    srcBits = (unsigned char *)midpMalloc((srcBmp.bmWidth << 2) * nHeight);

    if ((srcBits != NULL) && (destBits != NULL)) {

        oobj = SelectObject(destHDC, destHBmp);

        /* 
         * grab the screen contents into a bitmap 
         * the same size as our source image
         * + ~510ms 
         */

        DB(BitBlt(destHDC, 0, 0, t_width, t_height, 
            hdcDest, nXOriginDest, nYOriginDest, SRCCOPY));

        bi.bmiHeader.biWidth  = srcBmp.bmWidth;
        bi.bmiHeader.biHeight = -srcBmp.bmHeight;
        bi.bmiHeader.biSizeImage = srcBmp.bmWidth * srcBmp.bmWidth << 2;

        /* grab source bits */
        DB(GetDIBits(hdcSrc, srcHBmp, srcBmp.bmHeight - nHeight - nYOriginSrc, 
                     nHeight, srcBits, &bi, DIB_RGB_COLORS));

#if 1
        scanLength    = srcBmp.bmWidth << 2;
        srcBitsPtr    = srcBits + (nXOriginSrc << 2); 
        destBitsPtr   = destBits;
        srcBitsEndPtr = srcBitsPtr + 
                        (nHeight - 1) * scanLength + (nWidth << 2);
        lineEndPtr    = srcBitsPtr + (nWidth << 2);
                
        if (transform != 0) {
            if (transform & TRANSFORM_Y_FLIP) {
                destY = nHeight - 1;
                yIncr = -1;
            } else {
                destY = 0;
                yIncr = +1;
            }
    
            if (transform & TRANSFORM_X_FLIP) {
                xStart = nWidth - 1;
                xIncr = -1;
            } else {
                xStart = 0;
                xIncr = +1;
            }

        }


        while (srcBitsPtr < srcBitsEndPtr) {
        
            /** 
             * these may not have valid values is transform == 0,
             * but in that case they are never used.
             */
            destX  = xStart;

            while (srcBitsPtr < lineEndPtr) {
    
                if (transform != 0) {
                    destBitsPtr = destBits;

                    if (transform & TRANSFORM_INVERTED_AXES) {
                        destBitsPtr += 
                            ((destX * t_width) + destY) << 2;
                    } else {
                        destBitsPtr +=
                            ((destY * t_width) + destX) << 2;
                    }

                    destX += xIncr;
                } 

                alpha = srcBitsPtr[3];
        
                if (alpha == 0xff || (processAlpha == KNI_FALSE)) {
                    /* completely opaque */

                    /*
                     * this operation can be optimized 
                     * for the bus size of a device 
                     */
                        
                    *((int *)destBitsPtr) = *((int *)srcBitsPtr);
                        
                   /*
                    *(destBitsPtr + x + 0) = *(srcBitsPtr + x + 0);
                    *(destBitsPtr + x + 1) = *(srcBitsPtr + x + 1);
                    *(destBitsPtr + x + 2) = *(srcBitsPtr + x + 2);
                    *(destBitsPtr + x + 3) = alpha;
                    */
                        
                } else if (alpha != 0x00) {  /* needs blending */
                        
                    /* save on dereferencing these values everywhere */
                    unsigned char *d0 = destBitsPtr + 0,  
                    *d1 = destBitsPtr + 1,
                    *d2 = destBitsPtr + 2;
                    int c;
                
                
                    /* this could be optimized if the alpha values could be
                     * rounded to powers of two, then we could simply shift
                     * by alpha. we could also be careless with the divide
                     * and right shift by 8
                     */
                
                    /* doing the calculations this way is faster than the
                     * other method which is compiler defined out below
                     * but the results are still not very good
                     */
                    c =  srcBitsPtr[0] + ((*d0 * (0xff - alpha)) / 0xff);
                    if (c > 0xff) c = 0xff;
                    *d0 = (unsigned char)c;
                        
                    c =  srcBitsPtr[1] + ((*d1 * (0xff - alpha)) / 0xff);
                    if (c > 0xff) c = 0xff;
                    *d1 = (unsigned char)c;
                        
                    c =  srcBitsPtr[2] + ((*d2 * (0xff - alpha)) / 0xff);
                    if (c > 0xff) c = 0xff;
                    *d2 = (unsigned char)c;
                        
                    /*fprintf(stderr, "RGB(%i, %i, %i)\n", *d0, *d1, *d2);*/
                
#if 0
                    *d0 = *(srcBitsPtr + 0) + 
                          *d0 - ((*d0 * alpha) / 0xff);
                        
                    *d1 = *(srcBitsPtr + 1) + 
                          *d1 - ((*d1 * alpha) / 0xff);
                
                    *d2 = *(srcBitsPtr + 2) + 
                          *d2 - ((*d2 * alpha) / 0xff);
#endif
                      /* this operation is unnecessary */
                      /* destBitsPtr[4] = alpha; */
        
                }      

                /* changing destBitsPtr if transform != 0 is ok since we reset
                 * it's value at the top of the loop
                 */
                destBitsPtr += 4;
                srcBitsPtr  += 4;
            }

            lineEndPtr += scanLength;
            srcBitsPtr  = lineEndPtr - (nWidth << 2);
    
            destY += yIncr;
        }
        
#endif
        bi.bmiHeader.biWidth         = t_width;
        bi.bmiHeader.biHeight        = -t_height; 
        bi.bmiHeader.biSizeImage     = t_width * t_height << 2;

        ret = BitBlt(hdcDest, nXOriginDest, nYOriginDest, t_width, t_height, 
                    destHDC, 0, 0, SRCCOPY);

        SelectObject(destHDC, oobj);


        /* Delete the DIB */
        DeleteObject(destHBmp);
    }
    
    DeleteDC(destHDC);

    midpFree(srcBits);

    return ret;
}                    

#endif /* USE_ALPHA_BLEND */