imgj_imagedatafactory_kni.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 980 行 · 第 1/3 页

 * Initializes an <tt>ImageData</tt> from a romized pixel data
 * <p>
 * Java declaration:
 * <pre>
 *     loadRomizedImage(Ljavax/microedition/lcdui/ImageData;I)V
 * </pre>
 *
 * @param imageData The ImageData to load to
 * @param imageDataPtr native pointer to image data as Java int
 * @param imageDataLength length of image data array
 */
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
KNIDECL(javax_microedition_lcdui_ImageDataFactory_loadRomizedImage) {
    int imageDataPtr = KNI_GetParameterAsInt(2);
    int imageDataLength = KNI_GetParameterAsInt(3);

    int alphaSize;
    int pixelSize;
    int imageSize;
    int expectedLength;

    imgdcd_image_buffer_raw *rawBuffer;
    java_imagedata *midpImageData;

    jboolean status = KNI_FALSE;


    KNI_StartHandles(1);
    KNI_DeclareHandle(imageData);
    KNI_GetParameterAsObject(1, imageData);

    rawBuffer = (imgdcd_image_buffer_raw*)imageDataPtr;

    do {
        if (rawBuffer == NULL) {
            REPORT_ERROR(LC_LOWUI, "Romized image data is null");

            status = KNI_FALSE;
            break;
        }

        /** Check header */
        if (memcmp(rawBuffer->header, imgdcd_raw_header, 4) != 0) {
            REPORT_ERROR(LC_LOWUI, "Unexpected romized image type");

            status = KNI_FALSE;
            break;
        }

        imageSize = rawBuffer->width * rawBuffer->height;
        pixelSize = sizeof(PIXEL) * imageSize;
        alphaSize = 0;
        if (rawBuffer->hasAlpha) {
            alphaSize = sizeof(ALPHA) * imageSize;
        }

        /** Check data array length */
        expectedLength = offsetof(imgdcd_image_buffer_raw, data) +
            pixelSize + alphaSize;
        if (imageDataLength != expectedLength) {
            REPORT_ERROR(LC_LOWUI,
                    "Unexpected romized image data array length");

            status = KNI_FALSE;
            break;
        }

        midpImageData = IMGAPI_GET_IMAGEDATA_PTR(imageData);

        midpImageData->width = (jint)rawBuffer->width;
        midpImageData->height = (jint)rawBuffer->height;

        midpImageData->nativePixelData = (jint)rawBuffer->data;

        if (rawBuffer->hasAlpha) {
            midpImageData->nativeAlphaData =
                (jint)(rawBuffer->data + pixelSize);
        }

        status = KNI_TRUE;

    } while (0);

    KNI_EndHandles();
    KNI_ReturnBoolean(status);
}

/**
 * Loads the <tt>ImageData</tt> with the given ARGB integer
 * array. The array consists of values in the form of 0xAARRGGBB.
 * <p>
 * Java declaration:
 * <pre>
 *     loadRGB(Ljavax/microedition/lcdui/ImageData;[I)V
 * </pre>
 *
 * @param rgbData The array of argb image data
 */
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(javax_microedition_lcdui_ImageDataFactory_loadRGB) {
    /* jboolean processAlpha = KNI_GetParameterAsBoolean(2); */
    int height;
    int width;
    PIXEL *pixelData;
    ALPHA *alphaData;

    int *rgbBuffer;
   
    KNI_StartHandles(2);
    KNI_DeclareHandle(rgbData);
    KNI_DeclareHandle(imageData);

    KNI_GetParameterAsObject(2, rgbData);
    KNI_GetParameterAsObject(1, imageData);


    rgbBuffer = JavaIntArray(rgbData);
    if (getImageData(imageData, &width, &height, &pixelData, &alphaData) 
        == KNI_TRUE) {
        int i;
        int len = KNI_GetArrayLength(rgbData);
        int data_length = width * height;

        if (len > data_length) {
            len = data_length;
        }

        /* if (len != width*height) {
         *    JAVA_TRACE("len mismatch  %d !=  %d\n", len, width*height);
         * }
         */

        if (alphaData != NULL) {
            for (i = 0; i < len; i++) {
                pixelData[i] = RGB24TORGB16(rgbBuffer[i]);
                alphaData[i] = (rgbBuffer[i] >> 24) & 0x00ff;
            }
        } else {
            for (i = 0; i < len; i++) {
                pixelData[i] = RGB24TORGB16(rgbBuffer[i]);
            }
        }
    }

    KNI_EndHandles();
    KNI_ReturnVoid();
}

static void pixelCopy(PIXEL *src, const int srcLineW, const int srcXInc,
                      const int srcYInc, const int srcXStart,
                      PIXEL *dst, const int w, const int h) {
    int x, srcX;
    PIXEL *dstPtrEnd = dst + (h * w );

    (void)srcLineW; /* Surpress unused warning */

    for (; dst < dstPtrEnd; dst += w, src += srcYInc) {
        for (x = 0, srcX = srcXStart; x < w; srcX += srcXInc) {
            // printf("%d = %d\n", ((dst+x)-dstData), (src+srcX)-srcData);
            dst[x++] = src[srcX];
        }
    }
}

static void pixelAndAlphaCopy(PIXEL *src, 
                              const int srcLineW, const int srcXInc,
                              const int srcYInc, const int srcXStart, 
                              PIXEL *dst,
                              const int w, const int h,
                              const ALPHA *srcAlpha, ALPHA *dstAlpha) {
    int x, srcX;
    PIXEL *dstPtrEnd = dst + (h * w );

    (void)srcLineW; /* Surpress unused warning */

    for (; dst < dstPtrEnd; dst += w, src += srcYInc,
        dstAlpha += w, srcAlpha += srcYInc) {
        for (x = 0, srcX = srcXStart; x < w; srcX += srcXInc) {
            // printf("%d = %d\n", ((dst+x)-dstData), (src+srcX)-srcData);
            dstAlpha[x] = srcAlpha[srcX];
            dst[x++] = src[srcX];
        }
    }
}

static void blit(int srcWidth, int srcHeight,
                 PIXEL *srcPixelData, ALPHA *srcAlphaData,
                 int xSrc, int ySrc, int width, int height,
                 PIXEL *dstPixelData, ALPHA *dstAlphaData,
                 int transform) {
    PIXEL *srcPtr = NULL;
    int srcXInc=0, srcYInc=0, srcXStart=0;
    (void)srcHeight;

    switch (transform) {
    case TRANS_NONE:
        srcPtr = srcPixelData + (ySrc * srcWidth + xSrc);
        srcYInc = srcWidth;
        srcXStart = 0;
        srcXInc = 1;
        break;
    case TRANS_MIRROR_ROT180:
        srcPtr = srcPixelData + ((ySrc + height - 1) * srcWidth + xSrc);
        srcYInc = -srcWidth;
        srcXStart = 0;
        srcXInc = 1;
        break;
    case TRANS_MIRROR:
        srcPtr = srcPixelData + (ySrc * srcWidth + xSrc);
        srcYInc = srcWidth;
        srcXStart = width - 1;
        srcXInc = -1;
        break;
    case TRANS_ROT180:
        srcPtr = srcPixelData + ((ySrc + height - 1) * srcWidth + xSrc);
        srcYInc = -srcWidth;
        srcXStart = width - 1;
        srcXInc = -1;
        break;
    case TRANS_MIRROR_ROT270:
        srcPtr = srcPixelData + (ySrc * srcWidth + xSrc);
        srcYInc = 1;
        srcXStart = 0;
        srcXInc = srcWidth;
        break;
    case TRANS_ROT90:
        srcPtr = (srcPixelData) + ((ySrc + height - 1) * srcWidth + xSrc);
        srcYInc = 1;
        srcXStart = 0;
        srcXInc = -(srcWidth);
        break;
    case TRANS_ROT270:
        srcPtr = (srcPixelData) + (ySrc * srcWidth + xSrc + width - 1);
        srcYInc = -1;
        srcXStart = 0;
        srcXInc = srcWidth;
        break;
    case TRANS_MIRROR_ROT90:
        srcPtr = (srcPixelData) + ((ySrc + height - 1) * srcWidth + xSrc);
        srcYInc = -1;
        srcXStart = width - 1;
        srcXInc = -(srcWidth);
        break;
    }

    if (transform & TRANSFORM_INVERTED_AXES) {
        if (srcAlphaData == NULL) {
            pixelCopy(srcPtr, srcWidth, srcXInc, srcYInc, srcXStart,
                      dstPixelData, height, width);
        } else {
            ALPHA *srcAlpha = srcAlphaData + (srcPtr - srcPixelData);
            pixelAndAlphaCopy(srcPtr, srcWidth, srcXInc, srcYInc,
                              srcXStart,
                              dstPixelData, height, width, srcAlpha,
                              dstAlphaData);
        }
    } else {
        if (srcAlphaData == NULL) {
            pixelCopy(srcPtr, srcWidth, srcXInc, srcYInc, srcXStart,
                      dstPixelData, width, height);
        } else {
            ALPHA *srcAlpha = srcAlphaData + (srcPtr - srcPixelData);
            pixelAndAlphaCopy(srcPtr, srcWidth, srcXInc, srcYInc, srcXStart,
                              dstPixelData, width, height,
                              srcAlpha, dstAlphaData);
        }
    }
}

/**
 * Copies the region of the specified <tt>ImageData</tt> to
 * the specified <tt>ImageData</tt> object.
 * <p>
 * Java declaration:
 * <pre>
 *     loadRegion(Ljavax/microedition/lcdui/ImageData;
 *                Ljavax/microedition/lcdui/ImageData;IIIII)V
 * </pre>
 *
 * @param dest the ImageData to copy to
 * @param source the source image to be copied from
 * @param x The x coordinate of the upper left corner of the
 *          region to copy
 * @param y The y coordinate of the upper left corner of the
 *          region to copy
 * @param width The width of the region to copy
 * @param height The height of the region to copy
 * @param transform The transform to apply to the selected region.
 */
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(javax_microedition_lcdui_ImageDataFactory_loadRegion) {
    int      transform = KNI_GetParameterAsInt(7);
    int         height = KNI_GetParameterAsInt(6);
    int          width = KNI_GetParameterAsInt(5);
    int              y = KNI_GetParameterAsInt(4);
    int              x = KNI_GetParameterAsInt(3);

    int srcWidth, srcHeight;
    PIXEL *srcPixelData;
    ALPHA *srcAlphaData;

    int dstWidth, dstHeight;
    PIXEL *dstPixelData;
    ALPHA *dstAlphaData;

    KNI_StartHandles(2);
    KNI_DeclareHandle(srcImg);
    KNI_DeclareHandle(destImg);

    KNI_GetParameterAsObject(2, srcImg);
    KNI_GetParameterAsObject(1, destImg);

    if ((getImageData(destImg, &dstWidth, &dstHeight, 
                     &dstPixelData, &dstAlphaData) == KNI_TRUE) &&
        (getImageData(srcImg, &srcWidth, &srcHeight,
                     &srcPixelData, &srcAlphaData) == KNI_TRUE)) {

      blit(srcWidth, srcHeight, srcPixelData, srcAlphaData, 
           x, y, width, height, 
           dstPixelData, dstAlphaData, transform);
    }

    KNI_EndHandles();
    KNI_ReturnVoid();
}