Application: gvSIG desktop

	FILE(GLOB LIB_COMMON_FILES "*.cpp")

IF(UNIX)

	FILE(GLOB LIB_COMMON_FILES "*.c")

ENDIF(UNIX)

/**********************************************************************

 * $Id: ncsecwcompressclient_wrapper.c 4274 2006-03-06 07:32:00Z nacho $

 *

 * Name:     bsb_interfaz.c

 * Project:  JGDAL. Interface java to gdal (Frank Warmerdam).

 * Purpose:  Interface functions to manage bsb files. This include gdal

 * 			code but it doesn't use the gdal API.

 * Author:   Nacho Brodin, brodin_ign@gva.es

 *

 **********************************************************************/

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

*

* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

*

* For more information, contact:

*

*  Generalitat Valenciana

*   Conselleria d'Infraestructures i Transport

*   Av. Blasco Ib??ez, 50

*   46010 VALENCIA

*   SPAIN

*

*      +34 963862235

*   gvsig@gva.es

*      www.gvsig.gva.es

*

*    or

*

*   IVER T.I. S.A

*   Salamanca 50

*   46005 Valencia

*   Spain

*

*   +34 963163400

*   dac@iver.es

*/

#include <jni.h>

#include <string.h>

#include <malloc.h>

#include "NCSECWCompressClient.h"

typedef struct ReadInfo {

	//NCSFileView 	*pNCSFileView;

	UINT8 			**ppInputBandBufferArray;

	UINT32 			nPercentComplete;

	jclass			clase;

	jobject			*jclient;

	jobject			*jreadcall;

	JNIEnv 			*env;

	char 			pErrorBuffer[1024];

} ReadInfo;

static BOOLEAN 	callBackOn = TRUE;

/******************************************************************************/

//								ReadCallback

/******************************************************************************/

static BOOLEAN ReadCallback(NCSEcwCompressClient *pClient,

							UINT32 nNextLine,

							IEEE4 **ppOutputBandBufferArray)

{

	ReadInfo *pReadInfo = (ReadInfo *)pClient->pClientData;

	UINT32 nBand;

	jfieldID fid;

	jbyteArray jarray;

	JNIEnv *env=pReadInfo->env;

	int longitud;

	jclass clase_client;

	jclass clase_readcall;

	jmethodID metodo;

    if(callBackOn){

		clase_client = (env)->GetObjectClass(*(pReadInfo->jclient));

		clase_readcall = (env)->GetObjectClass(*(pReadInfo->jreadcall));

		//Ponemos el valor de la banda un n?mero de l?nea en el objeto cliente		

	  	fid = (env)->GetFieldID(clase_readcall, "nNextLine", "I");

	  	(env)->SetIntField(*(pReadInfo->jreadcall), fid, nNextLine); 

	   	//Ejecutamos la funci?n de java que carga el buffer

		metodo = (env)->GetMethodID(clase_readcall, "loadBuffer", "()V");

		(env)->CallVoidMethod(*(pReadInfo->jreadcall), metodo);

		//Obtenemos el array de bytes desde java

		fid = (env)->GetFieldID(clase_client, "buffer", "[B");

	    jarray =(jbyteArray)(env)->GetObjectField(*(pReadInfo->jclient), fid);  

	    longitud = (env)->GetArrayLength(jarray);

	    (env)->GetByteArrayRegion(jarray,0,longitud,(jbyte *)pReadInfo->ppInputBandBufferArray[0]);

		for(nBand = 0; nBand < pClient->nInputBands; nBand++) {

			UINT32 nCell;		

			UINT8 *pInputValue = pReadInfo->ppInputBandBufferArray[nBand];

			IEEE4 *pOutputValue = ppOutputBandBufferArray[nBand];

			// Compression needs input to be IEEE4

			for (nCell = 0; nCell < pClient->nInOutSizeX; nCell++) {

				*pOutputValue++ = (IEEE4)*pInputValue++;

			}

		}

		return(TRUE);	

    }else

    	return(FALSE);

}

/******************************************************************************/

//								StatusCallback

/******************************************************************************/

//Asigna el tanto por cien de imagen que lleva comprimido en una variable de java

//Ejecuta la funci?n updatePercent de java despues de actualizar la varible.

static void StatusCallback(NCSEcwCompressClient *pClient,

						   UINT32 nCurrentLine)

{

	ReadInfo 	*pReadInfo = (ReadInfo *)pClient->pClientData;

	UINT32 		nPercentComplete = (nCurrentLine * 100) / (pClient->nInOutSizeY - 1);

	jclass 		clase_client;

	jclass 		clase_readcall;

	JNIEnv 		*env=pReadInfo->env;

	jfieldID 	fid;

	jmethodID 	metodo;

	clase_client = (env)->GetObjectClass(*(pReadInfo->jclient));

	clase_readcall = (env)->GetObjectClass(*(pReadInfo->jreadcall));

	if (nPercentComplete != pReadInfo->nPercentComplete) {

		fid = (env)->GetFieldID(clase_client, "porcentaje", "I");

	  	(env)->SetIntField(*(pReadInfo->jclient), fid, nPercentComplete);

  		metodo = (env)->GetMethodID(clase_readcall, "updatePercent", "()V");

		(env)->CallVoidMethod(*(pReadInfo->jreadcall), metodo); 

		pReadInfo->nPercentComplete = nPercentComplete;

	}

}

/******************************************************************************/

//								NCSEcwCompressClient

/******************************************************************************/

JNIEXPORT jlong JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressClientNat

  (JNIEnv *env, jobject obj){

  	NCSEcwCompressClient 	*pClient;

  	jlong 					jresult = 0 ;

  	if(pClient = NCSEcwCompressAllocClient()){

  		*(NCSEcwCompressClient **)&jresult = pClient;

  		return jresult;

  	}else

  		return -1;

  }

/******************************************************************************/

//								NCSEcwCompressOpen

/******************************************************************************/

JNIEXPORT jint JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressOpenNat

  (JNIEnv *env, jobject obj, jlong cPtr, jboolean bCalculateSizesOnly){

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

  	NCSError 				eError;

  	jfieldID 				fid;

    jobject					obj_str;

    const char				*str;

    ReadInfo 				*compress_readInfo;

    jmethodID 				metodo;

    UINT8 *pReadBuffer,nBand;

  	pClient = *(NCSEcwCompressClient **)&cPtr;

  	if(pClient!=NULL){

  		//Asignamos los valores de los campos de NCSEcwCompress

  		jclass clase = (env)->GetObjectClass(obj);

  		fid = (env)->GetFieldID(clase, "inputFilename", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szInputFilename,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("inputFilename=%s\n",pClient->szInputFilename);

  		}

  		fid = (env)->GetFieldID(clase, "outputFilename", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szOutputFilename,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("outputFilename=%s\n",pClient->szOutputFilename);

  		}

  		fid = (env)->GetFieldID(clase, "targetCompression", "D");

  		pClient->fTargetCompression = (IEEE4)(env)->GetDoubleField(obj, fid);

  		//printf("targetCompression=%f\n",pClient->fTargetCompression);

  		fid = (env)->GetFieldID(clase, "eCompressFormat", "I");

  		pClient->eCompressFormat = (CompressFormat)(env)->GetIntField(obj, fid);

  		//printf("eCompressFormat=%d\n",pClient->eCompressFormat);

  		fid = (env)->GetFieldID(clase, "eCompressHint", "I");

  		pClient->eCompressHint = (CompressHint)(env)->GetIntField(obj, fid);

  		//printf("eCompressHint=%d\n",pClient->eCompressHint);

  		fid = (env)->GetFieldID(clase, "nBlockSizeX", "I");

  		pClient->nBlockSizeX = (env)->GetIntField(obj, fid);

  		//printf("nBlockSizeX=%d\n",pClient->nBlockSizeX);

  		fid = (env)->GetFieldID(clase, "nBlockSizeY", "I");

  		pClient->nBlockSizeY = (env)->GetIntField(obj, fid);

  		//printf("nBlockSizeY=%d\n",pClient->nBlockSizeY);

  		fid = (env)->GetFieldID(clase, "nInOutSizeX", "I");

  		pClient->nInOutSizeX = (env)->GetIntField(obj, fid);

  		//printf("nInOutSizeX=%d\n",pClient->nInOutSizeX);

  		fid = (env)->GetFieldID(clase, "nInOutSizeY", "I");

  		pClient->nInOutSizeY = (env)->GetIntField(obj, fid);

  		//printf("nInOutSizeY=%d\n",pClient->nInOutSizeY);

  		fid = (env)->GetFieldID(clase, "nInputBands", "I");

  		pClient->nInputBands = (env)->GetIntField(obj, fid);

  		//printf("nInputBands=%d\n",pClient->nInputBands);

  		fid = (env)->GetFieldID(clase, "nOutputBands", "I");

  		pClient->nOutputBands = (env)->GetIntField(obj, fid);

		//printf("nOutputBands=%d\n",pClient->nOutputBands);

  		fid = (env)->GetFieldID(clase, "nInputSize", "J");

  		pClient->nInputSize = (env)->GetLongField(obj, fid);

  		//printf("nInputSize=%ld\n",pClient->nInputSize);

  		fid = (env)->GetFieldID(clase, "fCellIncrementX", "D");

  		pClient->fCellIncrementX = (env)->GetDoubleField(obj, fid);

  		//printf("fCellIncrementX=%f\n",pClient->fCellIncrementX);

  		fid = (env)->GetFieldID(clase, "fCellIncrementY", "D");

  		pClient->fCellIncrementY = (env)->GetDoubleField(obj, fid);

  		//printf("fCellIncrementY=%f\n",pClient->fCellIncrementY);

  		fid = (env)->GetFieldID(clase, "fOriginX", "D");

  		pClient->fOriginX = (env)->GetDoubleField(obj, fid);

  		//printf("fOriginX=%f\n",pClient->fOriginX);

  		fid = (env)->GetFieldID(clase, "fOriginY", "D");

  		pClient->fOriginY = (env)->GetDoubleField(obj, fid);

  		//printf("fOriginY=%f\n",pClient->fOriginY);

  		fid = (env)->GetFieldID(clase, "eCellSizeUnits", "I");

  		pClient->fActualCompression = (IEEE4)(env)->GetIntField(obj, fid);

  		//printf("eCellSizeUnits=%d\n",pClient->fActualCompression);

  		fid = (env)->GetFieldID(clase, "szDatum", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szDatum,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("szDatum=%s\n",pClient->szDatum);

  		}

  		fid = (env)->GetFieldID(clase, "szProjection", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szProjection,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("szProjection=%s\n",pClient->szProjection);

  		}

  		fid = (env)->GetFieldID(clase, "fActualCompression", "D");

  		pClient->fActualCompression = (IEEE4)(env)->GetDoubleField(obj, fid);

  		//printf("fActualCompression=%f\n",pClient->fActualCompression);

  		fid = (env)->GetFieldID(clase, "fCompressionSeconds", "D");

  		pClient->fCompressionSeconds = (env)->GetDoubleField(obj, fid);

  		//printf("fCompressionSeconds=%f\n",pClient->fCompressionSeconds);

  		fid = (env)->GetFieldID(clase, "fCompressionMBSec", "D");

  		pClient->fCompressionMBSec = (env)->GetDoubleField(obj, fid);

  		//printf("fCompressionMBSec=%f\n",pClient->fCompressionMBSec);

  		fid = (env)->GetFieldID(clase, "nOutputSize", "J");

  		pClient->nOutputSize = (env)->GetLongField(obj, fid);

  		//printf("nOutputSize=%ld\n",pClient->nOutputSize);

  		pClient->pReadCallback = ReadCallback;

		pClient->pStatusCallback = StatusCallback;

		//Inicializar el buffer que tendr? una l?nea de entrada x el n?m de bandas

		metodo = (env)->GetMethodID(clase, "initialize", "()V");

		(env)->CallIntMethod(obj,metodo);

		compress_readInfo = (ReadInfo *)malloc(sizeof(ReadInfo));

		pReadBuffer = (UINT8 *)malloc(sizeof(UINT8) *

								  pClient->nInOutSizeX *

								  pClient->nInputBands);

		compress_readInfo->ppInputBandBufferArray = (UINT8 **)malloc(sizeof(UINT8 *) *

								   pClient->nInputBands);

		for (nBand = 0; nBand < pClient->nInputBands; nBand++) {

			compress_readInfo->ppInputBandBufferArray[nBand] = pReadBuffer + 

			(nBand * pClient->nInOutSizeX * sizeof(UINT8));

		}

		if (compress_readInfo->ppInputBandBufferArray == NULL) return 46;

		compress_readInfo->nPercentComplete = 0;

		pClient->pClientData = (void *)compress_readInfo;

	  	eError = NCSEcwCompressOpen(pClient, ((bCalculateSizesOnly==0)? FALSE : TRUE));

		return eError;

  	}

  	return -1;

  }

/******************************************************************************/

//								NCSEcwCompress

/******************************************************************************/

JNIEXPORT jint JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressNat

  (JNIEnv *env, jobject obj, jlong cPtr, jobject obj_read){

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

  	ReadInfo 				*compress_readInfo = (ReadInfo *) 0 ;

  	NCSError 				eError;

	pClient = *(NCSEcwCompressClient **)&cPtr;

	compress_readInfo = (ReadInfo *)pClient->pClientData;

	compress_readInfo->jclient=&obj;

	compress_readInfo->jreadcall=&obj_read;

	compress_readInfo->env=env;	

	eError = NCSEcwCompress(pClient);

	return eError;  	

  }

/******************************************************************************/

//								NCSEcwCompressClose

/******************************************************************************/

JNIEXPORT jint JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressCloseNat

  (JNIEnv *env, jobject obj, jlong cPtr){

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

  	NCSError 				eError;

	pClient = *(NCSEcwCompressClient **)&cPtr;	

	eError = NCSEcwCompressClose(pClient);

	return eError;  	

  }  

/******************************************************************************/

//								NCSEcwCompressCancel

/******************************************************************************/

JNIEXPORT void JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressCancelNat

  (JNIEnv *env, jobject obj, jlong cPtr){

  	callBackOn = FALSE;

  }

/******************************************************************************/

//								finalize

/******************************************************************************/

JNIEXPORT void JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_finalizeNat

  (JNIEnv *env, jobject obj, jlong cPtr){

  	ReadInfo 				*compress_readInfo = (ReadInfo *) 0 ;

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

    int 					nBand;	

	pClient = *(NCSEcwCompressClient **)&cPtr;	

  	//Liberamos la memoria

  	compress_readInfo = (ReadInfo *)pClient->pClientData;

  	for (nBand = 0; nBand < pClient->nInputBands; nBand++) {

			free(compress_readInfo->ppInputBandBufferArray[nBand]);

	}

  	free(compress_readInfo->ppInputBandBufferArray);

  	free(pClient->pClientData);

  	pClient->pClientData = NULL;

  	NCSEcwCompressFreeClient(pClient);

  }

/********************************************************** 

** Copyright 1998 Earth Resource Mapping Ltd.

** This document contains proprietary source code of

** Earth Resource Mapping Ltd, and can only be used under

** one of the three licenses as described in the 

** license.txt file supplied with this distribution. 

** See separate license.txt file for license details 

** and conditions.

**

** This software is covered by US patent #6,442,298,

** #6,102,897 and #6,633,688.  Rights to use these patents 

** is included in the license agreements.

** 

** FILE:   	ecw_jni.c

** CREATED:	4 Jan 2000

** AUTHOR: 	Mark Sheridan

** PURPOSE:	Java wrappers for JNI usage of the ECW library in Java.

** EDITS:

** 

** [01] 01Nov00 mjs Rewrote to be JVM 1.1 compliant.

** [02] 08Mar04 mjs Removed old 1.1 spec stuff, now needs a 1.2 compatible virtual machine.

** [03] 01Oct05 nbt ECWOpenArray function to support name parameter in char array

**

*******************************************************/

#include "NCSErrors.h"

#include "NCSECWClient.h"

#include "NCSMalloc.h" 

#include "NCSUtil.h"

#include "NCSBuildNumber.h"

#include "JNCSFile.h"

#include "NCSFile.h"

#include "NCSDynamicLib.h"

//#ifndef JNI_VERSION_1_2

//#error You must compile this class against a 1.2 virtual machine specification

//#endif

static JavaVM *pJavaVirtualMachineInst = NULL;

struct NCSJNIFieldIDs *pGlobalJNCSFieldIDs = NULL;

typedef struct NCSJNIFieldIDs {

	jfieldID jIDNativeDataPointer;

	jfieldID jIDWidth;

	jfieldID jIDHeight;	

	jfieldID jIDNumberOfBands;

	jfieldID jIDCompressionRate;

	jfieldID jIDCellIncrementX;

	jfieldID jIDCellIncrementY;

	jfieldID jIDCellSizeUnits;

	jfieldID jIDOriginX;

	jfieldID jIDOriginY;

	jfieldID jIDDatum;

	jfieldID jIDProjection;

	jfieldID jIDFilename;

	jfieldID jIDIsOpen;

	jmethodID jIDRefreshUpdateMethod;

	jfieldID jIDFileType;

	jfieldID jIDFileMimeType;

} NCSJNIFieldIDs;

// This is the object specific data structure, its cached.

typedef struct NCSJNIInfo {

	//jobject  ECWFile;

	NCSFileView *pFileView;

} NCSJNIInfo;

void NCSJNIThrowException(JNIEnv *pEnv, const char *pSignature, const char *pMessage)

{

	jclass jExceptionClass = NULL;

	if ((pEnv)->ExceptionCheck()) {

		(pEnv)->ExceptionDescribe();

		(pEnv)->ExceptionClear();

	}

	jExceptionClass = (pEnv)->FindClass(pSignature);

	if (jExceptionClass != NULL) {

		(pEnv)->ThrowNew(jExceptionClass, pMessage); 

	}

	(pEnv)->DeleteLocalRef(jExceptionClass);

}

NCSError NCSCreateJNIInfoStruct(JNIEnv *pEnv, jobject ECWFile, NCSFileView *pNCSFileView, NCSJNIInfo **pReturn)

{

	NCSJNIInfo *pJNIInfo;

	//char *pErrorString = NULL;

	pJNIInfo = (NCSJNIInfo *)NCSMalloc(sizeof(NCSJNIInfo), TRUE);

	if (pJNIInfo != NULL)

	{

		pJNIInfo->pFileView = pNCSFileView;

		//pJNIInfo->ECWFile = (void *)(*pEnv)->NewGlobalRef(pEnv, ECWFile);

		*pReturn = pJNIInfo;

	}

	else

	{

		return NCS_COULDNT_ALLOC_MEMORY;

	}

	return NCS_SUCCESS;

}

/*

 * Class:     None

 * Method:    JNI_OnLoad

 * Signature: ()Z

 */

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *pJVM, void *reserved)

{

	JNIEnv *pEnv;

	if ((pJVM)->GetEnv((void **)&pEnv, JNI_VERSION_1_2)) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "JNCS classes require a version 1.2 or higher virtual machine.");

		return JNI_ERR;

	}

	else {

		pJavaVirtualMachineInst = pJVM;

#ifndef WIN32

		NCSecwInit();

#endif

	}

	return JNI_VERSION_1_2;

}

/*

 * Class:     None

 * Method:    JNI_OnUnload

 * Signature: ()Z

 */

JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *pJVM, void *reserved)

{

#ifndef WIN32

		NCSecwShutdown();

#endif

		NCSFree((void *)pGlobalJNCSFieldIDs);

	return;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    NCSJNIInit

 * Signature: ()I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_NCSJNIInit

  (JNIEnv *pEnv, jclass ECWFileClass)

{

	NCSJNIFieldIDs *pJNIInfo = NULL;

	char *pErrorString = NULL;

	if (!pGlobalJNCSFieldIDs) {

		pJNIInfo = (NCSJNIFieldIDs *)NCSMalloc(sizeof(NCSJNIFieldIDs), TRUE);

		// Get all the field ids of the ECWFile object

		pJNIInfo->jIDNativeDataPointer	= (pEnv)->GetFieldID(ECWFileClass, "nativeDataPointer", "J" );

		pJNIInfo->jIDWidth				= (pEnv)->GetFieldID(ECWFileClass, "width", "I" );

		pJNIInfo->jIDHeight				= (pEnv)->GetFieldID(ECWFileClass, "height", "I" );

		pJNIInfo->jIDNumberOfBands		= (pEnv)->GetFieldID(ECWFileClass, "numBands", "I" );

		pJNIInfo->jIDCompressionRate	= (pEnv)->GetFieldID(ECWFileClass, "compressionRate", "D" );

		pJNIInfo->jIDCellIncrementX		= (pEnv)->GetFieldID(ECWFileClass, "cellIncrementX", "D" );

		pJNIInfo->jIDCellIncrementY		= (pEnv)->GetFieldID(ECWFileClass, "cellIncrementY", "D" );

		pJNIInfo->jIDCellSizeUnits		= (pEnv)->GetFieldID(ECWFileClass, "cellSizeUnits", "I" );

		pJNIInfo->jIDOriginX			= (pEnv)->GetFieldID(ECWFileClass, "originX", "D" );

		pJNIInfo->jIDOriginY			= (pEnv)->GetFieldID(ECWFileClass, "originY", "D" );

		pJNIInfo->jIDDatum				= (pEnv)->GetFieldID(ECWFileClass, "datum", "Ljava/lang/String;" );

		pJNIInfo->jIDProjection			= (pEnv)->GetFieldID(ECWFileClass, "projection", "Ljava/lang/String;" );

		pJNIInfo->jIDFilename			= (pEnv)->GetFieldID(ECWFileClass, "fileName", "Ljava/lang/String;" );

		pJNIInfo->jIDIsOpen				= (pEnv)->GetFieldID(ECWFileClass, "bIsOpen", "Z" );

		pJNIInfo->jIDRefreshUpdateMethod= (pEnv)->GetMethodID(ECWFileClass, "refreshUpdate", "(IIDDDD)V");

		//pJNIInfo->jIDFileType			= (pEnv)->GetFieldID(ECWFileClass, "fileType", "I" );

		//pJNIInfo->jIDFileMimeType		= (pEnv)->GetFieldID(ECWFileClass, "mimeType", "Ljava/lang/String;" );

		// Do some error checking

		if (!pJNIInfo->jIDNativeDataPointer)

			pErrorString = "Could not determine fieldID for 'nativeDataPointer' in ECWFile object.";

		if (!pJNIInfo->jIDWidth)

			pErrorString = "Could not determine fieldID for 'width' in ECWFile object.";

		if (!pJNIInfo->jIDHeight)

			pErrorString = "Could not determine fieldID for 'height' in ECWFile object.";

		if (!pJNIInfo->jIDNumberOfBands)

			pErrorString = "Could not determine fieldID for 'numBands' in ECWFile object.";

		if (!pJNIInfo->jIDCompressionRate)

			pErrorString = "Could not determine fieldID for 'compressionRate' in ECWFile object.";

		if (!pJNIInfo->jIDCellIncrementX)

			pErrorString = "Could not determine fieldID for 'cellIncrementX' in ECWFile object.";

		if (!pJNIInfo->jIDCellIncrementY)

			pErrorString = "Could not determine fieldID for 'cellIncrementY' in ECWFile object.";

		if (!pJNIInfo->jIDCellSizeUnits)

			pErrorString = "Could not determine fieldID for 'cellSizeUnits' in ECWFile object.";

		if (!pJNIInfo->jIDOriginX)

			pErrorString = "Could not determine fieldID for 'originX' in ECWFile object.";

		if (!pJNIInfo->jIDOriginY)

			pErrorString = "Could not determine fieldID for 'originY' in ECWFile object.";

		if (!pJNIInfo->jIDDatum)

			pErrorString = "Could not determine fieldID for 'datum' in ECWFile object.";

		if (!pJNIInfo->jIDProjection)

			pErrorString = "Could not determine fieldID for 'projection' in ECWFile object.";

		if (!pJNIInfo->jIDFilename)

			pErrorString = "Could not determine fieldID for 'fileName' in ECWFile object.";

		if (!pJNIInfo->jIDIsOpen)

			pErrorString = "Could not determine fieldID for 'bIsOpen' in ECWFile object.";

		/*if (!pJNIInfo->jIDFileType)

			pErrorString = "Could not determine fieldID for 'fileType' in ECWFile object.";

		if (!pJNIInfo->jIDFileMimeType)

			pErrorString = "Could not determine fieldID for 'mimeType' in ECWFile object.";*/

		if (pErrorString) {

#ifdef WIN32

			MessageBox(NULL, OS_STRING(pErrorString), TEXT("JNCSClass Library (JNI)"), MB_OK);

#else

			fprintf(stderr, "JNCSClass Library (JNI) : %s\n", pErrorString);

#endif

			NCSFormatErrorText(NCS_JNI_ERROR, pErrorString);

			return NCS_JNI_ERROR;

		}

		else {

			pGlobalJNCSFieldIDs = pJNIInfo;

			return NCS_SUCCESS;

		}

	}

	else {

		return NCS_SUCCESS;

	}

}

/*

 * There is so much that can go wrong in this call, that is why there is so much error checking.

 *

 * Class:     None

 * Method:    NCSJNIRefreshCallback

 * Signature: 

 */

NCSEcwReadStatus NCSJNIRefreshCallback(NCSFileView *pNCSFileView)

{

	NCSFileViewSetInfo	*pViewInfo;

	NCSJNIInfo *pJNIInfo;

	jint nError;

	JNIEnv *pEnv;

	jclass EcwObjectClass = NULL;

	jobject pECWFile = NULL;

	NCScbmGetViewInfo(pNCSFileView, &pViewInfo);

	// Must attach to the vm thread before calling any java methods.

	nError = (pJavaVirtualMachineInst)->AttachCurrentThread((void **)&pEnv, NULL);

	if (nError != 0) {

		char Message[] = "The ECW JNI interface could not attach to the current thread in\n"

						 "the Java virtual machine. Please refer to the Image Web Server\n"

						 "Java SDK documentation for more information about JVM threads.\n\n"

						 "Progressive imagery will not be available.";

#ifdef WIN32

		MessageBox(GetActiveWindow(), OS_STRING(Message), TEXT("JNCSFile VM Error"), MB_OK);

#else

		fprintf(stderr, "JNCSFile VM Error : %s\n", Message);

#endif

		return NCSECW_READ_FAILED;

	}

	// Make sure we got a view info struct.

	if (!pViewInfo) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "ECW JNI component could not obtain the NCSViewInfo pointer from the NCSFileView. No refreshUpdate() will occur.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	// The file is the global reference stashed in the client data pointer.

	pECWFile = (jobject)pViewInfo->pClientData;

	// Check to make sure that the ECW object has not been free'd or garbaged collected. This is only valid for JNI 1.2

	if ((pEnv)->IsSameObject(pECWFile/*pViewInfo->pClientData*/, NULL) == JNI_TRUE) {

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	// Use the valid reference to the object, to obtain the data pointer.

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField((jobject)pViewInfo->pClientData, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (!pJNIInfo) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "The ECW JNI component could not obtain the client data pointer from the NCSViewInfo struct. No refreshUpdate() will occur.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	EcwObjectClass = (pEnv)->GetObjectClass(pECWFile/*pJNIInfo->ECWFile*/);

	if (EcwObjectClass == NULL) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "The ECW JNI component could not determine the class signature of the ECW object.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	(pEnv)->DeleteLocalRef(EcwObjectClass);

	//Call the  "refreshUpdate" method on this object, if it implements the JNCSProgressiveUpdate interface.

	if (pGlobalJNCSFieldIDs->jIDRefreshUpdateMethod) {

		(pEnv)->CallVoidMethod(	pECWFile, \

								pGlobalJNCSFieldIDs->jIDRefreshUpdateMethod, \

								pViewInfo->nSizeX, pViewInfo->nSizeY, \

								pViewInfo->fTopX, pViewInfo->fLeftY, \

								pViewInfo->fBottomX, pViewInfo->fRightY);

	}

	else {

		NCSJNIThrowException(pEnv, "java/lang/ClassNotFoundException", "'refreshUpdate' method not found. Derived classes must implement the interface 'JNCSProgressiveUpdate' to use progressive imagery.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	(pJavaVirtualMachineInst)->DetachCurrentThread();

	return NCSECW_READ_OK;

}

/**

 * 

 */

int openFile(JNIEnv *pEnv, jobject *JNCSFile, jstring Filename, char *pFilename, jboolean bProgressive, NCSFileViewSetInfo *pNCSFileViewSetInfo, NCSFileView *pNCSFileView){

	NCSError nError;

	if (bProgressive) {

		nError = NCScbmOpenFileView((char *)pFilename, &pNCSFileView, NCSJNIRefreshCallback);

	}

	else {

		nError = NCScbmOpenFileView((char *)pFilename, &pNCSFileView, NULL);

	}

	if (NCS_FAILED(nError)) {

		// Return the short filename, since people dont like diplaying the full ecwp url

		char	*pProtocol, *pHost, *pECWFilename, *pShortFileName;

		int		nProtocolLength, nHostLength, nFilenameLength;

		NCSecwNetBreakdownUrl((char *)pFilename, &pProtocol, &nProtocolLength,

									 &pHost, &nHostLength,

									 &pECWFilename, &nFilenameLength);

		if (pECWFilename && nFilenameLength > 0 && (strstr(pECWFilename, "/") || strstr(pECWFilename, "\\")))

		{

			int len = strlen(pECWFilename), index = 0;

			for (index=len; index > 0; index--)

			{

				pShortFileName = &pECWFilename[index];

				if (pECWFilename[index] == '\\' || pECWFilename[index] == '/')

				{

					pShortFileName ++;

					break;

				}

			}

		}

		else 

		{

			pShortFileName = (char *)pFilename;

		}

		NCSFormatErrorText(NCS_FILE_OPEN_FAILED, pShortFileName, NCSGetLastErrorText(nError));

		return NCS_FILE_OPEN_FAILED;

	}

	else {

		NCSJNIInfo *pJNIInfo = NULL;

		char *pMimeType = NULL;

		NCSFileViewFileInfo	*pNCSFileInfo = NULL;

		nError = NCSCreateJNIInfoStruct(pEnv, (*JNCSFile), pNCSFileView, &pJNIInfo);

		NCScbmGetViewFileInfo(pNCSFileView, &pNCSFileInfo);

		// Set the properties in the actual Java object

		(pEnv)->SetIntField((*JNCSFile), pGlobalJNCSFieldIDs->jIDWidth, (jint)pNCSFileInfo->nSizeX	);

		(pEnv)->SetIntField((*JNCSFile), pGlobalJNCSFieldIDs->jIDHeight, (jint)pNCSFileInfo->nSizeY );

		(pEnv)->SetIntField((*JNCSFile), pGlobalJNCSFieldIDs->jIDNumberOfBands, (jint)pNCSFileInfo->nBands);

		(pEnv)->SetDoubleField((*JNCSFile), pGlobalJNCSFieldIDs->jIDCompressionRate, (jdouble)pNCSFileInfo->nCompressionRate );

		(pEnv)->SetDoubleField((*JNCSFile), pGlobalJNCSFieldIDs->jIDCellIncrementX, (jdouble)pNCSFileInfo->fCellIncrementX );

		(pEnv)->SetDoubleField((*JNCSFile), pGlobalJNCSFieldIDs->jIDCellIncrementY, (jdouble)pNCSFileInfo->fCellIncrementY );

		(pEnv)->SetIntField((*JNCSFile), pGlobalJNCSFieldIDs->jIDCellSizeUnits, (jint)pNCSFileInfo->eCellSizeUnits);

		(pEnv)->SetDoubleField((*JNCSFile), pGlobalJNCSFieldIDs->jIDOriginX, (jdouble)pNCSFileInfo->fOriginX );

		(pEnv)->SetDoubleField((*JNCSFile), pGlobalJNCSFieldIDs->jIDOriginY, (jdouble)pNCSFileInfo->fOriginY );

		(pEnv)->SetObjectField((*JNCSFile), pGlobalJNCSFieldIDs->jIDDatum, (pEnv)->NewStringUTF(pNCSFileInfo->szDatum));

		(pEnv)->SetObjectField((*JNCSFile), pGlobalJNCSFieldIDs->jIDProjection, (pEnv)->NewStringUTF(pNCSFileInfo->szProjection));

		(pEnv)->SetObjectField((*JNCSFile), pGlobalJNCSFieldIDs->jIDFilename, Filename);

		(pEnv)->SetBooleanField((*JNCSFile), pGlobalJNCSFieldIDs->jIDIsOpen, JNI_TRUE);

		(pEnv)->SetLongField((*JNCSFile), pGlobalJNCSFieldIDs->jIDNativeDataPointer, (jlong)pJNIInfo);

	}

	return NCS_SUCCESS;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWOpen

 * Signature: (Ljava/lang/String;Z)I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_ECWOpen

  (JNIEnv *pEnv, jobject JNCSFile, jstring Filename, jboolean bProgressive){

	const char *pFilename = (pEnv)->GetStringUTFChars(Filename, (jboolean *)NULL);

	NCSFileView *pNCSFileView = NULL;

	NCSFileViewSetInfo *pNCSFileViewSetInfo = NULL;

	int ret;

	ret = openFile(pEnv, &JNCSFile, Filename, (char *)pFilename, bProgressive, pNCSFileViewSetInfo, pNCSFileView);

	(pEnv)->ReleaseStringUTFChars(Filename, (const char *)pFilename);

	NCScbmGetViewInfo(pNCSFileView, &pNCSFileViewSetInfo);

	pNCSFileViewSetInfo->pClientData = (void *)(pEnv)->NewGlobalRef(JNCSFile);

	return ret;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWOpen

 * Signature: (Ljava/lang/String;Z)I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_ECWOpenArray

  (JNIEnv *pEnv, jobject JNCSFile, jstring Filename, jboolean bProgressive, jbyteArray pszF){

	NCSFileView *pNCSFileView = NULL;

	NCSFileViewSetInfo *pNCSFileViewSetInfo = NULL;

	int ret;

	jbyte *pFilename;

	int longitud = 0;

	NCSError nError;

  	longitud = (pEnv)->GetArrayLength(pszF); 

  	pFilename = (pEnv)->GetByteArrayElements(pszF, 0);

  	pFilename = (jbyte *)realloc(pFilename, longitud + 1);

  	pFilename[longitud] = '\0';

  	if (bProgressive) {

		nError = NCScbmOpenFileView((char *)pFilename, &pNCSFileView, NCSJNIRefreshCallback);

	}else {

		nError = NCScbmOpenFileView((char *)pFilename, &pNCSFileView, NULL);

	}

	if (NCS_FAILED(nError)) {

		// Return the short filename, since people dont like diplaying the full ecwp url

		char	*pProtocol, *pHost, *pECWFilename, *pShortFileName;

		int		nProtocolLength, nHostLength, nFilenameLength;

		NCSecwNetBreakdownUrl((char *)pFilename, &pProtocol, &nProtocolLength,

									 &pHost, &nHostLength,

									 &pECWFilename, &nFilenameLength);

		if (pECWFilename && nFilenameLength > 0 && (strstr(pECWFilename, "/") || strstr(pECWFilename, "\\")))

		{

			int len = strlen(pECWFilename), index = 0;

			for (index=len; index > 0; index--)

			{

				pShortFileName = &pECWFilename[index];

				if (pECWFilename[index] == '\\' || pECWFilename[index] == '/')

				{

					pShortFileName ++;

					break;

				}

			}

		}

		else 

		{

			pShortFileName = (char *)pFilename;

		}

		NCSFormatErrorText(NCS_FILE_OPEN_FAILED, pShortFileName, NCSGetLastErrorText(nError));

		return NCS_FILE_OPEN_FAILED;

	}

	else {

		NCSJNIInfo *pJNIInfo = NULL;

		char *pMimeType = NULL;

		NCSFileViewFileInfo	*pNCSFileInfo = NULL;

		nError = NCSCreateJNIInfoStruct(pEnv, JNCSFile, pNCSFileView, &pJNIInfo);

		NCScbmGetViewFileInfo(pNCSFileView, &pNCSFileInfo);

		// Set the properties in the actual Java object

		(pEnv)->SetIntField(JNCSFile, pGlobalJNCSFieldIDs->jIDWidth, (jint)pNCSFileInfo->nSizeX	);

		(pEnv)->SetIntField(JNCSFile, pGlobalJNCSFieldIDs->jIDHeight, (jint)pNCSFileInfo->nSizeY );

		(pEnv)->SetIntField(JNCSFile, pGlobalJNCSFieldIDs->jIDNumberOfBands, (jint)pNCSFileInfo->nBands);

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDCompressionRate, (jdouble)pNCSFileInfo->nCompressionRate );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDCellIncrementX, (jdouble)pNCSFileInfo->fCellIncrementX );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDCellIncrementY, (jdouble)pNCSFileInfo->fCellIncrementY );

		(pEnv)->SetIntField(JNCSFile, pGlobalJNCSFieldIDs->jIDCellSizeUnits, (jint)pNCSFileInfo->eCellSizeUnits);

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDOriginX, (jdouble)pNCSFileInfo->fOriginX );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDOriginY, (jdouble)pNCSFileInfo->fOriginY );

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDDatum, (pEnv)->NewStringUTF(pNCSFileInfo->szDatum));

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDProjection, (pEnv)->NewStringUTF(pNCSFileInfo->szProjection));

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDFilename, Filename);

		(pEnv)->SetBooleanField(JNCSFile, pGlobalJNCSFieldIDs->jIDIsOpen, JNI_TRUE);

		(pEnv)->SetLongField(JNCSFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer, (jlong)pJNIInfo);

	}

	//ret = openFile(pEnv, &JNCSFile, Filename, (char *)pszFilename, bProgressive, pNCSFileViewSetInfo, pNCSFileView);

	(pEnv)->ReleaseByteArrayElements(pszF,(jbyte *)pFilename, 0);

	NCScbmGetViewInfo(pNCSFileView, &pNCSFileViewSetInfo);

	pNCSFileViewSetInfo->pClientData = (void *)(pEnv)->NewGlobalRef(JNCSFile);

	return NCS_SUCCESS;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWClose

 * Signature: (Z)V

 */

JNIEXPORT void JNICALL Java_com_ermapper_ecw_JNCSFile_ECWClose

  (JNIEnv *pEnv , jobject JNCSFile, jboolean bFreeCache)

{

	NCSError nError;

	NCSJNIInfo *pJNIInfo = NULL;

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField(JNCSFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (pJNIInfo != NULL) {

		NCSFileViewSetInfo	*pViewInfo;

		NCScbmGetViewInfo(pJNIInfo->pFileView, &pViewInfo);

		// Clear the Java object members.

		(pEnv)->SetIntField   (JNCSFile, pGlobalJNCSFieldIDs->jIDWidth, (jint)0	);

		(pEnv)->SetIntField   (JNCSFile, pGlobalJNCSFieldIDs->jIDHeight, (jint)0 );

		(pEnv)->SetIntField   (JNCSFile, pGlobalJNCSFieldIDs->jIDNumberOfBands, (jint)0);

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDCompressionRate, (jdouble)0.0 );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDCellIncrementX, (jdouble)0.0 );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDCellIncrementY, (jdouble)0.0 );

		(pEnv)->SetIntField   (JNCSFile, pGlobalJNCSFieldIDs->jIDCellSizeUnits, (jint)0 );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDOriginX, (jdouble)0.0 );

		(pEnv)->SetDoubleField(JNCSFile, pGlobalJNCSFieldIDs->jIDOriginY, (jdouble)0.0 );

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDDatum, (pEnv)->NewStringUTF(""));

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDProjection, (pEnv)->NewStringUTF(""));

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDFilename, NULL);

		(pEnv)->SetBooleanField(JNCSFile, pGlobalJNCSFieldIDs->jIDIsOpen, JNI_FALSE);

		(pEnv)->SetLongField  (JNCSFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer, (jlong)0);

		(pEnv)->SetIntField(JNCSFile, pGlobalJNCSFieldIDs->jIDFileType, (jint)0 );

		(pEnv)->SetObjectField(JNCSFile, pGlobalJNCSFieldIDs->jIDFileMimeType, NULL );

		// Clean up any global refs

		//(pEnv)->DeleteGlobalRef(pJNIInfo->ECWFile);

		(pEnv)->DeleteGlobalRef((jobject)pViewInfo->pClientData);

		nError = NCScbmCloseFileViewEx(pJNIInfo->pFileView, bFreeCache);

		pJNIInfo->pFileView = NULL;

		NCSFree(pJNIInfo);

	}

	return;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWSetView

 * Signature: (I[IIIIIDDDDII)I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_ECWSetView

  (JNIEnv *pEnv, jobject ECWFile, jint nBands, jintArray nBandList, jint nDatasetTLX, jint nDatasetTLY, jint nDatasetBRX, jint nDatasetBRY, jdouble dWorldTLX, jdouble dWorldTLY, jdouble dWorldBRX, jdouble dWorldBRY, jint nWidth, jint nHeight)

{

	NCSError nError = NCS_SUCCESS;

	NCSJNIInfo *pJNIInfo = NULL;

	// Sanity check

	if ((pEnv)->IsInstanceOf(ECWFile, (pEnv)->FindClass("com/ermapper/ecw/JNCSFile")) == JNI_FALSE)

	{

#ifdef WIN32

		MessageBox(NULL, OS_STRING("ECWSetView() error : object is not a JNCSFile instance"), TEXT("JNCSClass Library (JNI)"), MB_OK);

#endif //WIN32

		return NCS_JNI_ERROR;

	}

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField(ECWFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (pJNIInfo) {

		jint *pBandBuffer = (jint *)NCSMalloc(sizeof(UINT32)*nBands+1, TRUE);

		(pEnv)->GetIntArrayRegion(nBandList, 0, nBands, pBandBuffer);

		nError = NCScbmSetFileViewEx(   pJNIInfo->pFileView, 

										nBands, 

										(UINT32*)pBandBuffer,

										nDatasetTLX, nDatasetTLY, nDatasetBRX, nDatasetBRY,

										nWidth,

										nHeight,

										dWorldTLX,

										dWorldTLY,

										dWorldBRX,

										dWorldBRY);

		NCSFree(pBandBuffer);

	} else {

		NCSFormatErrorText(NCS_JNI_ERROR, "method SetView() could not get native data from JNCSFile object.");

		nError = NCS_JNI_ERROR;

	}

	return nError;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWReadImageRGBA

 * Signature: ([I)I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_ECWReadImageRGBA

  (JNIEnv *pEnv, jobject JNCSFile, jintArray pRGBArray, jint width, jint height)

{

	jboolean bIsCopy;

	NCSEcwReadStatus eStatus;

	NCSJNIInfo *pJNIInfo = NULL;

	NCSError nError = NCS_SUCCESS;

	jint *pRGBAPixels;

	jint *pRGBLineArrayPtr = NULL;

	int nIndex;

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField(JNCSFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (!pJNIInfo) {

		NCSFormatErrorText(NCS_JNI_ERROR, "method readLineRGB() could not get native data from JNCSFile object.");

		nError = NCS_JNI_ERROR;

	}

	else {

		// Lock the primitive array and get a pointer to the memory.

		pRGBAPixels = (jint *)(pEnv)->GetPrimitiveArrayCritical(pRGBArray, &bIsCopy);

		if (pRGBAPixels) {

			pRGBLineArrayPtr = pRGBAPixels;

			for (nIndex = 0; nIndex < height; nIndex ++) {

#if defined(NCSBO_LSBFIRST)

				eStatus = NCScbmReadViewLineBGRA( pJNIInfo->pFileView, (UINT32 *)pRGBLineArrayPtr);

#elif defined(NCSBO_MSBFIRST)

				eStatus = NCScbmReadViewLineBGRA( pJNIInfo->pFileView, (UINT32 *)pRGBLineArrayPtr);

				//eStatus = NCScbmReadViewLineRGBA( pJNIInfo->pFileView, (UINT32 *)pRGBLineArrayPtr);

#endif

				pRGBLineArrayPtr += width;

				if (eStatus == NCSECW_READ_CANCELLED) {

					nError = NCS_SUCCESS;

					break;

				}

				if (eStatus == NCSECW_READ_FAILED) {

					NCSFormatErrorText(NCS_JNI_ERROR, "method readLineRGB() failed (internal error).");

					nError = NCS_JNI_ERROR;

					break;

				}

#ifndef WIN32

				NCSThreadYield();

#endif

			}

		}

		else {

			NCSFormatErrorText(NCS_JNI_ERROR, "method readLineRGB() could not allocate memory for RGB Array.");

			nError = NCS_JNI_ERROR;

		}

		// Copy the array back to the object and free the memory

		(pEnv)->ReleasePrimitiveArrayCritical(pRGBArray, pRGBAPixels, 0);

	}

	return nError;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWReadLineRGB

 * Signature: ([I)I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_ECWReadLineRGBA

  (JNIEnv *pEnv, jobject JNCSFile, jintArray pRGBArray)

{

	jboolean bIsCopy;

	NCSEcwReadStatus eStatus;

	NCSJNIInfo *pJNIInfo = NULL;

	NCSError nError = NCS_SUCCESS;

	jint *pRGBAPixels;

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField(JNCSFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (!pJNIInfo) {

		NCSFormatErrorText(NCS_JNI_ERROR, "method readLineRGB() could not get native data from JNCSFile object.");

		nError = NCS_JNI_ERROR;

	}

	else {

		// Lock the primitive array and get a pointer to the memory.

		pRGBAPixels = (jint *)(pEnv)->GetPrimitiveArrayCritical(pRGBArray, &bIsCopy);

		if (pRGBAPixels) {

			// Read into a RGBA Java scaneline (which is byte reversed, so go the BGRA here (???)

			eStatus = NCScbmReadViewLineBGRA( pJNIInfo->pFileView, (UINT32 *)pRGBAPixels);

			if (eStatus == NCSECW_READ_FAILED) {

				NCSFormatErrorText(NCS_JNI_ERROR, "method readLineRGB() failed (internal error).");

				nError = NCS_JNI_ERROR;

			}	

		}

		else {

			NCSFormatErrorText(NCS_JNI_ERROR, "method readLineRGB() could not allocate memory for RGB Array.");

			nError = NCS_JNI_ERROR;

		}

		// Copy the array back to the object and free the memory

		(pEnv)->ReleasePrimitiveArrayCritical(pRGBArray, pRGBAPixels, 0);

	}

	return nError;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWGetErrorString

 * Signature: (I)Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_com_ermapper_ecw_JNCSFile_ECWGetErrorString

  (JNIEnv *pEnv, jobject JNCSFile, jint nErrorNumber)

{

	//return (*pEnv)->NewStringUTF(pEnv, NCSGetLastErrorText(nErrorNumber));

	return (pEnv)->NewStringUTF("....");

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWGetLibVersion

 * Signature: ()Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_com_ermapper_ecw_JNCSFile_ECWGetLibVersion

  (JNIEnv *pEnv, jclass clazz)

{

	return (pEnv)->NewStringUTF(NCS_VERSION_STRING_NO_NULL);	

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    ECWGetPercentComplete

 * Signature: ()I

 */

JNIEXPORT jshort JNICALL Java_com_ermapper_ecw_JNCSFile_ECWGetPercentComplete

  (JNIEnv *pEnv, jobject JNCSFile)

{

	NCSFileViewSetInfo *pViewInfo = NULL;

	NCSJNIInfo *pJNIInfo = NULL;

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField(JNCSFile, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (!pJNIInfo) 

		return 0;

	if (pJNIInfo->pFileView) {

		NCScbmGetViewInfo(pJNIInfo->pFileView, &pViewInfo); 

		if (pViewInfo) {

			return (jshort)((pViewInfo->nBlocksAvailable / (double)pViewInfo->nBlocksInView) * 100);

		}

	}

	else { 

		return 0;

	}

	return 0;

}