m3gimage2d.c

java 1.1 gemini 08_16

																					  (((pixel>>0)&0xFF) * 25)) >> 8);
							((jbyte_array*)dst)->elements[2*(i*width + j)+1] = (kal_uint8)((pixel >> 24) & 0xFF);
						}
					}
				}
			}
			break;
		case M3G_IMAGE2D_RGB:
			handle_type = M3G_IMAGE2D_PIXEL_IMAGEHANDLE;
			pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_SHORT_5_6_5;

			/* Graphics3D test, if image soaurce has alpha, but we only need RGB, transform that */
			if(gc->prop==HAS_ALPHA || gc->prop==HAS_TRANS) {
				int pixel, *pixel_ptr = &pixel;
				flag_handle = KAL_TRUE;
				handle_type = M3G_IMAGE2D_PIXEL_BYTEARRAYHANDLE;
				pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_BYTES;
	
				imgdest = (void*)instantiateArrayKNI(PrimitiveArrayClasses[T_BYTE], width*height*3);
	
				if(imgdest == NULL) {
					KNI_ThrowNew("java/lang/OutOfMemoryError", "heap memory not available");
					goto _return;
				}

				/* instantiateArrayKNI will trigger gc, update src again */
				dst = imgdest;
				imgdest = ((image_class)*object_handle)->imgData;
	

				for(i=0; i<height; i++) {
					for(j=0; j<width; j++) {
						LCDUIgetRGB(&pixel_ptr, 0, width, j, i, 1, 1, imgdest);
	
						((jbyte_array*)dst)->elements[3*(i*width + j)] = (kal_uint8)((((kal_uint32)pixel) & 0x00ff0000)>>16);
						((jbyte_array*)dst)->elements[3*(i*width + j) + 1] = (kal_uint8)((((kal_uint32)pixel) & 0x0000ff00)>>8);
						((jbyte_array*)dst)->elements[3*(i*width + j) + 2] = (kal_uint8)(((kal_uint32)pixel) & 0x000000ff);
					}
				}
			}
			/*
			if(gc->prop == HAS_ALPHA) pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_SHORT_4_4_4_4;
			else pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_SHORT_5_6_5;
			*/
			break;
		case M3G_IMAGE2D_RGBA:
			handle_type = M3G_IMAGE2D_PIXEL_IMAGEHANDLE;
			if(gc->flag_mutable) {
			} else {
				if(gc->prop == HAS_ALPHA) {
					pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_SHORT_4_4_4_4;
				} else if(gc->prop == HAS_TRANS) {
					int pixel, *pixel_ptr = &pixel;
					flag_handle = KAL_TRUE;
					handle_type = M3G_IMAGE2D_PIXEL_BYTEARRAYHANDLE;
					pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_BYTES;

					imgdest = (void*)instantiateArrayKNI(PrimitiveArrayClasses[T_BYTE], width*height*4);

					if(imgdest == NULL) {
						KNI_ThrowNew("java/lang/OutOfMemoryError", "heap memory not available");
						goto _return;
					}

					/* instantiateArrayKNI will trigger gc, update src again */
					dst = imgdest;
					imgdest = ((image_class)*object_handle)->imgData;

					for(i=0; i<height; i++) {
						for(j=0; j<width; j++) {
							LCDUIgetRGB(&pixel_ptr, 0, width, j, i, 1, 1, imgdest);
							/* 0xAARRGGBB -> RGBA array */
							((jbyte_array*)dst)->elements[4*(i*width + j)] = (kal_uint8)((((kal_uint32)pixel) & 0x00ff0000)>>16);
							((jbyte_array*)dst)->elements[4*(i*width + j) + 1] = (kal_uint8)((((kal_uint32)pixel) & 0x0000ff00)>>8);
							((jbyte_array*)dst)->elements[4*(i*width + j) + 2] = (kal_uint8)(((kal_uint32)pixel) & 0x000000ff);
							((jbyte_array*)dst)->elements[4*(i*width + j) + 3] = (kal_uint8)((((kal_uint32)pixel) & 0xff000000)>>24);
						}
					}
				} else {
					pixel_type = M3G_IMAGE2D_PIXEL_UNSIGNED_SHORT_5_6_5;
				}
			}
			break;
		default:
			break;
		}

		if(flag_handle) {
			if (handle_type == M3G_IMAGE2D_PIXEL_IMAGEHANDLE) {
				/* Fix to update image handle type only */
				gc = (pImageGC)((imgdest==NULL)?(((BYTEARRAY)canvas)->bdata):(((BYTEARRAY)imgdest)->bdata));
				img_data = (kal_uint16*)((imgdest==NULL)? gc->u.datap:gc->u.data);
			}

			ENTER_M3D_CS;
			handle = M3G_Image2D_new((kal_uint8)format, pixel_type, (kal_uint32)width, (kal_uint32)height, 
									 (kal_uint8*)dst, KAL_FALSE, handle_type);
			LEAVE_M3D_CS;

			/* Add pixels to global root which protected by gc */
			if (handle->pixels) {
				ADD_TO_GLOBAL_ROOT(handle->pixels);
			}
		} else {
			ENTER_M3D_CS;
			handle = M3G_Image2D_new((kal_uint8)format, pixel_type, (kal_uint32)width, (kal_uint32)height, 
									 (kal_uint8*)img_data, KAL_FALSE, M3G_IMAGE2D_PIXEL_POINTER);
			LEAVE_M3D_CS;
		}

		if(handle == NULL) KNI_ThrowNew("java/lang/OutOfMemoryError", "memory not available");
#else
	ASSERT(0);
#endif /* FAST_KNI */
	}

_return:
	KNI_EndHandles();
	KNI_ReturnInt((jint)handle);
}

KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_m3g_Image2D_createPalettized()
{
	jint format = KNI_GetParameterAsInt(1);
	jint width = KNI_GetParameterAsInt(2);
	jint height = KNI_GetParameterAsInt(3);
	st_m3g_image2d* handle = NULL;
	kal_uint32 i;

	KNI_StartHandles(2);
	KNI_DeclareHandle(object_handle);
	KNI_DeclareHandle(palette_handle);
	KNI_GetParameterAsObject(4, object_handle);
	KNI_GetParameterAsObject(5, palette_handle);

	if(width<=0 || height<=0 || format<M3G_IMAGE2D_ALPHA || format>M3G_IMAGE2D_RGBA) {
		KNI_ThrowNew("java/lang/IllegalArgumentException", "invalid argument");
		goto _return;
	}

	if(*object_handle == NULL || *palette_handle == NULL) {
		KNI_ThrowNew("java/lang/NullPointerException", "NULL target");
	} else {
#if FAST_KNI && defined(CLDCHI)
		jbyte_array* data = (jbyte_array*)*object_handle;
		jbyte_array* palette = (jbyte_array*)*palette_handle;
		kal_uint16* pixels = NULL;
		int pixel_bytes = 1;

		switch(format) {
		case M3G_IMAGE2D_ALPHA:
		case M3G_IMAGE2D_LUMINANCE:
			pixel_bytes = 1;
			break;
		case M3G_IMAGE2D_LUMINANCE_ALPHA:
			pixel_bytes = 2;
			break;
		case M3G_IMAGE2D_RGB:
			pixel_bytes = 3;
			break;
		case M3G_IMAGE2D_RGBA:
			pixel_bytes = 4;
			break;
		break;
			ASSERT(0);
			break;
		}

		if(data->length<width*height || (palette->length < 256*pixel_bytes && palette->length%pixel_bytes !=0)) {
			KNI_ThrowNew("java/lang/IllegalArgumentException", "invalid data");
			goto _return;
		}

		pixels = (kal_uint16*)instantiateArrayKNI(PrimitiveArrayClasses[T_BYTE], width*height*pixel_bytes);

		/* instantiateArrayKNI will trigger gc, update src data pointer again */
		data = (jbyte_array*)*object_handle;
		palette = (jbyte_array*)*palette_handle;

		if(pixels == NULL) KNI_ThrowNew("java/lang/OutOfMemoryError", "heap memory not available");
		else {
			ENTER_M3D_CS;
			handle = M3G_Image2D_new((kal_uint8)format, M3G_IMAGE2D_PIXEL_UNSIGNED_BYTES, 
									 (kal_uint32)width, (kal_uint32)height, 
									 (kal_uint8*)pixels, KAL_FALSE, M3G_IMAGE2D_PIXEL_BYTEARRAYHANDLE);
			LEAVE_M3D_CS;

			if(handle == NULL) {
				KNI_ThrowNew("java/lang/OutOfMemoryError", "memory not available");
			} else {
				/* Add pixels to global root which protected by gc */
				if (handle->pixels) {
					ADD_TO_GLOBAL_ROOT(handle->pixels);
				}

				for(i=0; i<data->length; i++) {
					memcpy(&((jbyte_array*)handle->pixels)->elements[i*pixel_bytes],  
						&palette->elements[((kal_uint8)data->elements[i])*pixel_bytes], pixel_bytes);
				}
			}
		}
#else
	ASSERT(0);
#endif /* CLDCHI */
	}

_return:
	KNI_EndHandles();
	KNI_ReturnInt((jint)handle);
}

KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_m3g_Image2D_getFormatImpl()
{
	st_m3g_image2d* handle = (st_m3g_image2d*)KNI_GetParameterAsInt(1);
	
	//KNI_ReturnInt(handle->format);
	KNI_ReturnInt(M3G_Image2D_getFormat(handle));
}

KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_m3g_Image2D_getHeightImpl()
{
	st_m3g_image2d* handle = (st_m3g_image2d*)KNI_GetParameterAsInt(1);
	//KNI_ReturnInt(handle->height);
	KNI_ReturnInt(M3G_Image2D_getHeight(handle));
}

KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_m3g_Image2D_getWidthImpl()
{
	st_m3g_image2d* handle = (st_m3g_image2d*)KNI_GetParameterAsInt(1);
	//KNI_ReturnInt(handle->width);
	KNI_ReturnInt(M3G_Image2D_getWidth(handle));
}

KNIEXPORT KNI_RETURNTYPE_BOOLEAN
Java_javax_microedition_m3g_Image2D_isMutableImpl()
{
	st_m3g_image2d* handle = (st_m3g_image2d*)KNI_GetParameterAsInt(1);
	//KNI_ReturnBoolean(handle->flag_mutable);
	KNI_ReturnBoolean(M3G_Image2D_isMutable(handle));
}

KNIEXPORT KNI_RETURNTYPE_VOID
Java_javax_microedition_m3g_Image2D_setImpl()
{
	st_m3g_image2d* handle = (st_m3g_image2d*)KNI_GetParameterAsInt(1);
	jint x = KNI_GetParameterAsInt(2);
	jint y = KNI_GetParameterAsInt(3);
	jint width = KNI_GetParameterAsInt(4);
	jint height = KNI_GetParameterAsInt(5);
	//kal_uint32 i, j;

	KNI_StartHandles(1);
	KNI_DeclareHandle(object_handle);
	KNI_GetParameterAsObject(6, object_handle);

	if(x<0 || y<0 || width<=0 || height<=0 || (x+width)>handle->width || (y+height)>handle->height) {
		KNI_ThrowNew("java/lang/IllegalArgumentException", "invalid argument");
		goto _return;
	}

	if(!handle->flag_mutable) {
		KNI_ThrowNew("java/lang/IllegalStateException", "immutable image");
		goto _return;
	}

	if(*object_handle == NULL) {
		KNI_ThrowNew("java/lang/NullPointerException", "NULL target");
	} else {
#if FAST_KNI && defined(CLDCHI)
		jbyte_array* data = (jbyte_array*)*object_handle;
		//kal_uint16 *data_ptr, pixel;
		kal_uint32 pixel_bytes = 3;

		switch(handle->format) {
		case M3G_IMAGE2D_ALPHA:
		case M3G_IMAGE2D_LUMINANCE:
			pixel_bytes = 1;
			break;
		case M3G_IMAGE2D_LUMINANCE_ALPHA:
			pixel_bytes = 2;
			break;
		case M3G_IMAGE2D_RGB:
			pixel_bytes = 3;
			break;
		case M3G_IMAGE2D_RGBA:
			pixel_bytes = 4;
			break;
		break;
		}

		if(data->length < width*height*pixel_bytes) {
			KNI_ThrowNew("java/lang/IllegalArgumentException", "invalid data");
			goto _return;
		}
        
       if(M3G_Image2D_set(handle,x,y,width,height,(kal_uint8*)data->elements)!= M3G_SUCCESS)
       {
            goto _return;
       }
       
       //////
#else
	ASSERT(0);
#endif /* CLDCHI */
	}

_return:
	KNI_EndHandles();
	KNI_ReturnVoid();
}	
#endif /* #ifdef SUPPORT_JSR_184 */