images.c

SUN官方的资料

  /* width * height * 4 gives us the size of a 32 bpp image */
  imgLen = nWidth * nHeight << 2;
  srcImgLen = imageWidth  * imageHeight << 2;
        
  if(transform & TRANSFORM_INVERTED_AXES) {
    t_width = nHeight;
    t_height = nWidth;
  } else {
    t_width = nWidth;
    t_height = nHeight;
  }

  if (transform & TRANSFORM_Y_FLIP) {
    yStart = nHeight-1;
    yIncr = -1;
  } else {
    yStart = 0;
    yIncr = +1;
  }

  if (transform & TRANSFORM_X_FLIP) {
    xStart = nWidth-1;
    xIncr = -1;
  } else {
    xStart = 0;
    xIncr = +1;
  }

  /* increment srcX,Y regular. increment destX,Y according to transform.
     this makes handling of mask and alpha values easier */

  for (srcY = nYOriginSrc, destY = yStart, yCounter = 0; 
       yCounter < nHeight; 
       srcY++, destY+=yIncr, yCounter++) {

    /* in the current implementation we have source bitmap
       dimension as the width of the image and the height of the region
       destination bitmap is of the dimensions of the region */
    
    for (srcX = nXOriginSrc, destX = xStart, xCounter = 0; 
	 xCounter < nWidth; 
	 srcX++, destX+=xIncr, xCounter++) {

      if ( transform & TRANSFORM_INVERTED_AXES ) {

      /* copy the pixel that is pointed to */
      XPutPixel(&destP->bitmap->image, destY, destX, 
		XGetPixel(&sourceBitmap->image, srcX, srcY));

      } else {

      /* copy the pixel that is pointed to */
      XPutPixel(&destP->bitmap->image, destX, destY, 
		XGetPixel(&sourceBitmap->image, srcX, srcY));

      }

    } /*for x*/

  } /* for y */

    /* --- */

}


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

    if (p == NULL) return;

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

    return (void*)p->bitmap;
}

/*
 * Dither matrices.
 *
 * canonical matrix is
 *  { 0,  6,  9, 15},
 *  {11, 13,  2,  4},
 *  { 7,  1, 14,  8},
 *  {12, 10,  5,  3}
 *
 * or, converted to signed:
 *
 *  {-8, -2,  1,  7},
 *  { 3,  5, -6, -4},
 *  {-1, -7,  6,  0},
 *  { 4,  2, -3, -5}
 *
 */

static signed char cmat[4][4] = {
    {-24,  -6,   3,  21},
    {  9,  15, -18, -12},
    { -3, -21,  18,   0},
    { 12,   6,  -9, -15}
};



static void
blendPixel(int *r, int *g, int *b, int *alpha, int off)
{
#if USE_ALPHA_BLEND

    if (*alpha < TRANS_THRESHOLD) {
        *alpha = 0;
    }
#if TRANS_BINARY_THRESHOLD
    else {
        *alpha = 0xff;
    }
#endif

    *r = (*r * *alpha) / 0xff;
    *g = (*g * *alpha) / 0xff;
    *b = (*b * *alpha) / 0xff;

#else /* USE_ALPHA_BLEND */

    /*
     * if we're not using alphablending then dither the alpha
     * values so we can approximate a blending effect
     */
    if ((*alpha != 0x00) && (*alpha != 0xff)) {
        *alpha += off * 3;
        if (*alpha < TRANS_THRESHOLD) {
            *alpha = 0;
        } else {
            *alpha = 0xff;
        }
    }
#endif

}

/*
 * build a bit mask for dealing with transparent images that either
 * only have pixels that are on or off or are dithering an alpha blend
 *
 */
static void
buildMask(myBitmapStruct *bitmap, int alpha, int x, int y)
{
    /* the mask must be 8-bit aligned for myPtImageMask */
    int width = bitmap->width + (8 - (bitmap->width & 7));

    if (bitmap->imageMask == NULL) {
        int len = (width >> 3) * bitmap->height;
        bitmap->imageMask = (unsigned char *)midpCalloc(len, sizeof(char));
    }

    if (bitmap->imageMask != NULL) {
        /* 
         * build the image mask
         */ 
        int offset = (y * width + x) >> 3;
        *(bitmap->imageMask + offset) |= (alpha & 1) << (7 - (x & 7));
    }
}

static void
buildAlphaChannel(myBitmapStruct *bitmap, int alpha, int x, int y) {
 
    if (bitmap->imageMask == NULL) {
        int len = bitmap->width * bitmap->height;
        bitmap->imageMask = (unsigned char *)midpCalloc(len, sizeof(char));
    }

    if (bitmap->imageMask != NULL) {
        int offset = y * bitmap->width + x;
        *(bitmap->imageMask + offset) = (unsigned char)(alpha & 0xff);
    }
}

static void 
setARGBPixels(imageDstPtr self, int** imageBuf, int bufLen, int width,
	      int height, jboolean useAlpha)
{
    int x;
    int y; 
    int offset;
    int pixel; 
    int alpha;
    int r;
    int g;
    int b;
    
    _imageDstPtr p = (_imageDstPtr)self;
    
    if ((p->bitmap == NULL) || (p->mutable)){
	fprintf(stderr, "setARGBPixel error\n");
	return;    
    }
    
    if (useAlpha) {
	p->bitmap->prop = HAS_ALPHA;
    }
    for (y = 0; y < height; y++){
	for (x = 0; x < width; x++){
	    offset = (y * width) + x;
	    pixel = (*imageBuf)[offset];
	    
	    alpha = (pixel >> 24) & 0xff;
	    r = (pixel >> 16) & 0xff;
	    g = (pixel >> 8 ) & 0xff;
	    b = pixel & 0xff;
	    
	    XPutPixel(&p->bitmap->image, x, y, getPixelValue(r, g, b));
	    
	    if (useAlpha){ 
		buildAlphaChannel(p->bitmap, alpha, x, y);
	    }
	}
    }
}

static void
sendPixelsColor(imageDstPtr self, int y, uchar *pixels, int pixelType)
{
    int x;
    signed char *mat = cmat[y & 3];
    _imageDstPtr p = (_imageDstPtr)self;

    if ((p->bitmap == NULL) || (p->mutable)) return;

    if ((pixelType == CT_COLOR) ||              /* color triplet */
        (pixelType == (CT_COLOR | CT_ALPHA))) { /* color triplet with alpha */
        for (x = 0; x < p->bitmap->width; ++x) {
            int off = mat[x & 3];
            int r = pixels[0];
            int g = pixels[1];
            int b = pixels[2];
            int alpha = 0xff;

            if (pixelType & CT_ALPHA) {
                alpha = pixels[3];
                p->bitmap->prop = HAS_ALPHA;
                pixels++;
            } else if (p->hasTransMap) {

                alpha = pixels[3];
                p->bitmap->prop = HAS_ALPHA;
                pixels++;

            }
            pixels += 3;
 
            r += off;
            g += off;
            b += off;

            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;

            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_ALPHA) {
                buildAlphaChannel(p->bitmap, alpha, x, y);
            }
#else
            if (p->bitmap->prop == HAS_MASK ||
                p->bitmap->prop == HAS_ALPHA) {

                buildMask(p->bitmap, alpha, x, y);
            } 
#endif

            XPutPixel(&p->bitmap->image, x, y, getPixelValue(r, g, b));
        }
    } else { /* indexed color */
        for (x = 0; x < p->bitmap->width; ++x) {
            int off = mat[x & 3];
            int cmapIndex = *pixels++;

            int color = p->cmap[cmapIndex];

            int r = ((color >> 16) & 0xff) + off;
            int g = ((color >>  8) & 0xff) + off;
            int b = ((color >>  0) & 0xff) + off;

            int alpha = 0xff;

            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;

            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_ALPHA) {
                buildAlphaChannel(p->bitmap, alpha, x, y);
            }
#else
            if (p->bitmap->prop == HAS_MASK ||
                p->bitmap->prop == HAS_ALPHA) {

                buildMask(p->bitmap, alpha, x, y);
            } 
#endif

            XPutPixel(&p->bitmap->image, x, y, getPixelValue(r, g, b));
        }
    } 
}

static void
sendPackedPixelsColor(imageDstPtr self, int y, uchar *pixels)
{
    /* 
     * since we specified a depth of 8, these must be 
     * pixels in 8-bit grayscale.  pngDecode gives us a
     * colormap for that case, so...
     */
    sendPixelsColor(self, y, pixels, KNI_FALSE);
}

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

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

    p->super.ptr = p;

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

    if ((p->bitmap=(myBitmapStruct*)midpCalloc(sizeof(myBitmapStruct),1)) == NULL) {
        midpFree(p);
	return NULL;
    }
    p->mutable           = mutable;
    p->hasColormap = KNI_FALSE;
    p->hasTransMap = KNI_FALSE;

    return (imageDstPtr)p;
}

#define XDRAWPOINT(dx) \
    XPutPixel(dest, x + dx, y, XGetPixel(image, x + dx, y));
    
static void
myPutImageMask(Display *display, Drawable d, GC gc, XImage *image, 
	       unsigned char *mask, int src_x, int src_y, int dest_x, 
	       int dest_y, unsigned int width, unsigned int height)
{
    int i, x, y;
    unsigned char data;
    unsigned char *maskPtr = mask;

    XImage *dest;

    dest = XGetImage(display, d, dest_x, dest_y, width, height, 0xff, ZPixmap);

    if (dest == NULL || mask == NULL) {
        XPutImage(display, d, gc, image, src_x, src_y, dest_x, dest_y,
                  width, height);
	if (dest != NULL) {
	    XDestroyImage(dest);
	}
        return;
    }

    /* it won't matter if the new width is larger than the actual bitmap 
     * since invalid bitmap locations will have 0 in the corresponding
     * mask position and therefore won't be accesed
     */
    width = width + (8 - (width & 7));

    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x += 8) {

            data = *maskPtr++;

            if (data == 0xff) {
                /*
                 * all the bits in the mask are set so just put all the pixels
                 */
                XDRAWPOINT(0);
                XDRAWPOINT(1);
                XDRAWPOINT(2);
                XDRAWPOINT(3);
                XDRAWPOINT(4);
                XDRAWPOINT(5);
                XDRAWPOINT(6);
                XDRAWPOINT(7);
            } else if ((data & 0xf0) == 0xf0) {
                /*
                 * only half of the pixels are definitely set so put those
                 * and then run through the others
                 */
                XDRAWPOINT(0);
                XDRAWPOINT(1);
                XDRAWPOINT(2);
                XDRAWPOINT(3);
                for (i = 4; i < 8; i++) {
                    if (data & (1 << (7-i))) {
                        XDRAWPOINT(i);
                    }
                }
            } else if ((data & 0x0f) == 0x0f) {
                /*
                 * the other half of the pixels are definitely set so 
                 * run through the first set and put the rest
                 */
                for (i = 0; i < 4; i++) {
                    if (data & (1 << (7-i))) {
                        XDRAWPOINT(i);
                    }
                }
                XDRAWPOINT(4);
                XDRAWPOINT(5);
                XDRAWPOINT(6);
                XDRAWPOINT(7);
            } else if (data != 0x00) {
                /*