/*
* Class: nitf_LookupTable
* Method: construct
* Signature: (II[B)V
*/
JNIEXPORT void JNICALL Java_nitf_LookupTable_construct
(JNIEnv * env, jobject self, jint numTables, jint numEntries,
jbyteArray lutData)
{
nitf_LookupTable *lut = NULL;
nitf_Error error;
char *dataBuf = NULL;
/* construct the LUT */
lut = nitf_LookupTable_construct((nitf_Uint32) numTables,
(nitf_Uint32) numEntries, &error);
if (!lut)
{
/* throw an error */
_ThrowNITFException(env, error.message);
return;
}
dataBuf = (char *) (*env)->GetByteArrayElements(env, lutData, 0);
if (!dataBuf)
{
_ThrowNITFException(env, "Out of memory!");
return;
}
/* initialize the data */
nitf_LookupTable_init(lut, (nitf_Uint32) numTables,
(nitf_Uint32) numEntries, (NITF_DATA *) dataBuf,
&error);
(*env)->ReleaseByteArrayElements(env, lutData, dataBuf, 0);
_SetObj(env, self, lut);
}
/*
* Class: nitf_ImageSubheader
* Method: getBandInfo
* Signature: ()[Lnitf/BandInfo;
*/
JNIEXPORT jobjectArray JNICALL Java_nitf_ImageSubheader_getBandInfo
(JNIEnv * env, jobject self)
{
nitf_ImageSubheader *header = _GetObj(env, self);
jclass infoClass = (*env)->FindClass(env, "nitf/BandInfo");
nitf_Error error;
jobjectArray info;
jobject element;
jint i;
jint numBands;
jint numXBands;
jmethodID methodID;
NITF_TRY_GET_UINT32(header->numImageBands, &numBands, &error);
NITF_TRY_GET_UINT32(header->numMultispectralImageBands, &numXBands,
&error);
numBands = numXBands > 0 ? numXBands : numBands;
info = (*env)->NewObjectArray(env, numBands, infoClass, NULL);
methodID = (*env)->GetMethodID(env, infoClass, "<init>", "(J)V");
for (i = 0; i < numBands; ++i)
{
element = (*env)->NewObject(env,
infoClass,
methodID, (jlong) header->bandInfo[i]);
(*env)->SetObjectArrayElement(env, info, i, element);
}
return info;
CATCH_ERROR:
_ThrowNITFException(env, error.message);
return NULL;
}
/*
* Class: nitf_ImageSource
* Method: getBand
* Signature: (I)Lnitf/BandSource;
*/
JNIEXPORT jobject JNICALL Java_nitf_ImageSource_getBand
(JNIEnv * env, jobject self, jint number)
{
nitf_ImageSource *source = _GetObj(env, self);
nitf_BandSource *bandSource;
jobject bandSourceObject;
nitf_Error error;
jclass bandSourceClass = (*env)->FindClass(env, "nitf/BandSource");
jmethodID methodID =
(*env)->GetMethodID(env, bandSourceClass, "<init>", "(J)V");
bandSource = nitf_ImageSource_getBand(source, number, &error);
if (!bandSource)
{
_ThrowNITFException(env, error.message);
return NULL;
}
/* make the object */
bandSourceObject = (*env)->NewObject(env,
bandSourceClass,
methodID, (jlong) bandSource);
return bandSourceObject;
}
/*
* Class: nitf_ImageSource
* Method: addBand
* Signature: (Lnitf/BandSource;)Z
*/
JNIEXPORT jboolean JNICALL Java_nitf_ImageSource_addBand
(JNIEnv * env, jobject self, jobject jBandSource)
{
nitf_ImageSource *source = _GetObj(env, self);
nitf_BandSource *bandSource;
nitf_Error error;
jclass bandSourceClass = (*env)->FindClass(env, "nitf/BandSource");
jmethodID methodID =
(*env)->GetMethodID(env, bandSourceClass, "getAddress", "()J");
bandSource = (nitf_BandSource *) (*env)->CallLongMethod(
env, jBandSource, methodID);
if (!bandSource)
{
return JNI_FALSE;
}
if (!nitf_ImageSource_addBand(source, bandSource, &error))
{
_ThrowNITFException(env, error.message);
return JNI_FALSE;
}
/* Now, tell Java not to manage it anymore */
_ManageObject(env, (jlong)bandSource, JNI_FALSE);
return JNI_TRUE;
}
/*
* Class: nitf_PixelSkipDownSampler
* Method: construct
* Signature: (II)V
*/
JNIEXPORT void JNICALL Java_nitf_PixelSkipDownSampler_construct
(JNIEnv *env, jobject self, jint rowSkip, jint colSkip)
{
nitf_Error error;
jmethodID methodID;
nitf_DownSampler *downSampler;
jclass downSamplerClass = (*env)->FindClass(env, "nitf/DownSampler");
jmethodID downSamplerMethodID = (*env)->GetStaticMethodID(env,
downSamplerClass, "register", "(Lnitf/DownSampler;)V");
if (rowSkip <= 0)
rowSkip = 1;
if (colSkip <= 0)
colSkip = 1;
downSampler =
nitf_PixelSkip_construct(rowSkip, colSkip, &error);
if (!downSampler)
{
_ThrowNITFException(env, error.message);
return;
}
_SetObj(env, self, downSampler);
/* now, we must also register this type */
(*env)->CallStaticVoidMethod(env, downSamplerClass,
downSamplerMethodID, self);
return;
}
JNIEXPORT jlong JNICALL Java_nitf_NativeIOInterface_seek
(JNIEnv *env, jobject self, jlong offset, jint whence)
{
nitf_Error error;
int cWhence;
nitf_IOInterface *interface = _GetObj(env, self);
switch(whence)
{
case nitf_IOInterface_SEEK_CUR:
cWhence = NITF_SEEK_CUR;
break;
case nitf_IOInterface_SEEK_END:
cWhence = NITF_SEEK_END;
break;
case nitf_IOInterface_SEEK_SET:
cWhence = NITF_SEEK_SET;
break;
default:
cWhence = NITF_SEEK_SET;
break;
}
if (interface->iface->seek(interface->data, offset, cWhence, &error))
{
return interface->iface->tell(interface->data, &error);
}
else
{
_ThrowNITFException(env, error.message);
return -1;
}
}
/*
* Class: nitf_Record
* Method: makeClone
* Signature: ()Lnitf/Cloneable;
*/
JNIEXPORT jobject JNICALL Java_nitf_Record_makeClone
(JNIEnv * env, jobject self)
{
nitf_Record *record = _GetObj(env, self);
nitf_Record *clone;
jobject cloneObject;
jclass recordClass = (*env)->FindClass(env, "nitf/Record");
jmethodID methodID =
(*env)->GetMethodID(env, recordClass, "<init>", "(J)V");
nitf_Error error;
/* clone it */
clone = nitf_Record_clone(record, &error);
if (!clone)
{
_ThrowNITFException(env, error.message);
return NULL;
}
/* create the object */
cloneObject = (*env)->NewObject(env,
recordClass, methodID, (jlong) clone);
/* set the clone function */
methodID = (*env)->GetMethodID(env, recordClass, "setClone", "(Z)V");
(*env)->CallVoidMethod(env, cloneObject, methodID, JNI_TRUE);
return cloneObject;
}
/*
* Class: nitf_ImageSubheader
* Method: getExtendedSection
* Signature: ()Lnitf/Extensions;
*/
JNIEXPORT jobject JNICALL Java_nitf_ImageSubheader_getExtendedSection
(JNIEnv * env, jobject self)
{
nitf_ImageSubheader *header = _GetObj(env, self);
jclass extensionsClass = (*env)->FindClass(env, "nitf/Extensions");
jmethodID methodID =
(*env)->GetMethodID(env, extensionsClass, "<init>", "(J)V");
nitf_Error error;
jobject extensions;
/* we need to construct it if it doesn't already exist */
if (!header->extendedSection)
{
header->extendedSection = nitf_Extensions_construct(&error);
if (!header->extendedSection)
goto CATCH_ERROR;
}
extensions = (*env)->NewObject(env,
extensionsClass,
methodID,
(jlong) header->extendedSection);
return extensions;
CATCH_ERROR:
_ThrowNITFException(env, error.message);
return NULL;
}
JNIEXPORT jobject JNICALL Java_nitf_Record_newDESegment
(JNIEnv *env, jobject self)
{
nitf_Record *record = _GetObj(env, self);
nitf_DESegment *segment;
nitf_Error error;
jmethodID methodID;
jobject segmentObject;
jclass segmentClass = (*env)->FindClass(env, "nitf/DESegment");
segment = nitf_Record_newDataExtensionSegment(record, &error);
if (!segment)
goto CATCH_ERROR;
/* return it */
methodID = (*env)->GetMethodID(env, segmentClass, "<init>", "(J)V");
segmentObject = (*env)->NewObject(env,
segmentClass,
methodID, (jlong) segment);
return segmentObject;
CATCH_ERROR:
_ThrowNITFException(env, error.message);
return NULL;
}
JNIEXPORT jobject JNICALL Java_cgm_MetafileReader_read
(JNIEnv *env, jobject self, jobject interface)
{
nitf_Error error;
nitf_IOInterface* io;
cgm_Metafile *metafile;
cgm_MetafileReader *reader = _GetObj(env, self);
/* get some classIDs */
jclass ioInterfaceClass = (*env)->GetObjectClass(env, interface);
jclass metafileClass = (*env)->FindClass(env, "cgm/Metafile");
/* get the IOInterface */
jmethodID methodID =
(*env)->GetMethodID(env, ioInterfaceClass, "getAddress", "()J");
io = (nitf_IOInterface*) ((*env)->CallLongMethod(env, interface, methodID));
/* just to be sure, seek to start of file */
if (nitf_IOInterface_seek(io, 0, NITF_SEEK_SET, &error) == -1)
goto CATCH_ERROR;
if (!(metafile = cgm_MetafileReader_read(reader, io, &error)))
goto CATCH_ERROR;
methodID = (*env)->GetMethodID(env, metafileClass, "<init>", "(J)V");
return (*env)->NewObject(env, metafileClass, methodID, (jlong) metafile);
CATCH_ERROR:
_ThrowNITFException(env, error.message);
return NULL;
}
JNIEXPORT void JNICALL Java_nitf_BandSource_construct
(JNIEnv * env, jobject self)
{
/* make the interface */
static nitf_IDataSource iBandSource = {
&BandSource_read,
&BandSource_destruct,
&BandSource_getSize,
&BandSource_setSize
};
/* the return bandSource */
nitf_BandSource *bandSource = NULL;
BandSourceImpl *impl; /* gets malloc'd for this object */
nitf_Error error;
jclass bandSourceClass = (*env)->FindClass(env, "nitf/BandSource");
jmethodID methodID = (*env)->GetStaticMethodID(env, bandSourceClass,
"register", "(Lnitf/BandSource;)V");
/* construct the persisent one */
impl = (BandSourceImpl *) NITF_MALLOC(sizeof(BandSourceImpl));
if (!impl)
{
_ThrowNITFException(env, "Out of memory");
return;
}
/**************************************************************/
/* THIS IS VERY IMPORTANT... WE MUST MAKE A STRONG GLOBAL REF */
/**************************************************************/
impl->self = (*env)->NewGlobalRef(env, self);
bandSource = (nitf_BandSource *) NITF_MALLOC(sizeof(nitf_BandSource));
if (!bandSource)
{
_ThrowNITFException(env, "Out of Memory");
return;
}
bandSource->data = impl;
bandSource->iface = &iBandSource;
_SetObj(env, self, bandSource);
/* now, we must also register this type */
(*env)->CallStaticVoidMethod(env, bandSourceClass,
methodID, self);
}
/*
* Class: nitf_ImageSource
* Method: getBandSources
* Signature: ()[Lnitf/BandSource;
*/
JNIEXPORT jobjectArray JNICALL Java_nitf_ImageSource_getBandSources
(JNIEnv * env, jobject self)
{
nitf_ImageSource *imageSource = _GetObj(env, self);
jclass bandSourceClass = (*env)->FindClass(env, "nitf/BandSource");
nitf_Error error;
jobjectArray sources;
jobject element;
jint index = 0;
jint num, actualNum = 0;
jmethodID methodID;
nitf_ListIterator iter, end;
jlong address; /* temp address */
num = imageSource->size;
/* iterate over the bandsources to get the correct count */
iter = nitf_List_begin(imageSource->bandSources);
end = nitf_List_end(imageSource->bandSources);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
actualNum++;
nitf_ListIterator_increment(&iter);
}
/* check to see if the size member is WRONG */
if (num != actualNum)
{
num = actualNum;
/* set the size member to the RIGHT value */
imageSource->size = num;
}
sources = (*env)->NewObjectArray(env, num, bandSourceClass, NULL);
methodID = (*env)->GetStaticMethodID(env, bandSourceClass, "getByAddress",
"(J)Lnitf/BandSource;");
index = 0;
/* Now, iterate over the bandsources to create an array */
iter = nitf_List_begin(imageSource->bandSources);
end = nitf_List_end(imageSource->bandSources);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
address = (jlong)((nitf_BandSource *)nitf_ListIterator_get(&iter));
element = (*env)->CallStaticObjectMethod(env, bandSourceClass,
methodID, address);
(*env)->SetObjectArrayElement(env, sources, index++, element);
nitf_ListIterator_increment(&iter);
}
return sources;
CATCH_ERROR:
_ThrowNITFException(env, error.message);
return NULL;
}
JNIEXPORT void JNICALL Java_nitf_NativeIOInterface_close
(JNIEnv *env, jobject self)
{
nitf_Error error;
nitf_IOInterface *interface = _GetObj(env, self);
if (interface && interface->iface &&
!interface->iface->close(interface->data, &error))
_ThrowNITFException(env, error.message);
}
/*
* Class: nitf_ImageSubheader
* Method: removeBand
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_nitf_ImageSubheader_removeBand
(JNIEnv *env, jobject self, jint index)
{
nitf_ImageSubheader *header = _GetObj(env, self);
nitf_Error error;
if (!nitf_ImageSubheader_removeBand(header, (nitf_Uint32) index, &error))
{
_ThrowNITFException(env, error.message);
}
}
JNIEXPORT void JNICALL Java_cgm_MetafileReader_construct
(JNIEnv *env, jobject self)
{
cgm_MetafileReader *reader = NULL;
nitf_Error error;
reader = cgm_MetafileReader_construct(&error);
if (!reader)
_ThrowNITFException(env, "Unable to create new MetafileReader");
_SetObj(env, self, reader);
}
JNIEXPORT void JNICALL Java_nitf_MemorySource_setSize
(JNIEnv *env, jobject self, jlong size)
{
nitf_BandSource *source = _GetObj(env, self);
nitf_Error error;
if (!source->iface->setSize(source->data, (nitf_Off)size, &error))
{
_ThrowNITFException(env, error.message);
return;
}
}
/*
* Class: nitf_Record
* Method: removeReservedExtensionSegment
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_nitf_Record_removeReservedExtensionSegment
(JNIEnv *env, jobject self, jint segmentNumber)
{
nitf_Record *record = _GetObj(env, self);
nitf_Error error;
if (!nitf_Record_removeReservedExtensionSegment(record, (nitf_Uint32)segmentNumber, &error))
{
_ThrowNITFException(env, error.message);
}
return;
}
JNIEXPORT void JNICALL Java_nitf_NativeIOInterface_write
(JNIEnv *env, jobject self, jbyteArray buf, jint size)
{
nitf_Error error;
nitf_Off tell;
jbyte *array = NULL;
nitf_IOInterface *interface = _GetObj(env, self);
array = (*env)->GetByteArrayElements(env, buf, 0);
if (!array)
{
_ThrowNITFException(env, "Out of memory!");
return;
}
if (!(interface->iface->write(interface->data, array, size, &error)))
{
_ThrowNITFException(env, error.message);
}
(*env)->ReleaseByteArrayElements(env, buf, array, 0);
}
JNIEXPORT void JNICALL Java_nitf_Record_unmergeTREs
(JNIEnv *env, jobject self)
{
nitf_Record *record = _GetObj(env, self);
nitf_Error error;
if (!nitf_Record_unmergeTREs(record, &error))
{
_ThrowNITFException(env, error.message);
}
return;
}
JNIEXPORT void JNICALL Java_nitf_Record_moveDataExtensionSegment
(JNIEnv *env, jobject self, jint oldIndex, jint newIndex)
{
nitf_Record *record = _GetObj(env, self);
nitf_Error error;
if (!nitf_Record_moveDataExtensionSegment(record,
(nitf_Uint32)oldIndex, (nitf_Uint32)newIndex, &error))
{
_ThrowNITFException(env, error.message);
}
return;
}
/*
* Class: nitf_ImageSubheader
* Method: removeImageComment
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL Java_nitf_ImageSubheader_removeImageComment
(JNIEnv * env, jobject self, jint index)
{
nitf_ImageSubheader *header = _GetObj(env, self);
nitf_Error error;
if (!nitf_ImageSubheader_removeImageComment(header, index, &error))
{
_ThrowNITFException(env, error.message);
return JNI_FALSE;
}
return JNI_TRUE;
}
/*
* Class: nitf_MemorySource
* Method: read
* Signature: ([BI)V
*/
JNIEXPORT void JNICALL Java_nitf_MemorySource_read
(JNIEnv * env, jobject self, jbyteArray buf, jint size)
{
nitf_BandSource *source = _GetObj(env, self);
jbyte *byteBuf;
nitf_Error error;
byteBuf = (*env)->GetByteArrayElements(env, buf, 0);
if (!byteBuf)
{
_ThrowNITFException(env, "ERROR getting data from array");
return;
}
if (!source->iface->read(source->data, (char *) byteBuf, size, &error))
{
_ThrowNITFException(env, error.message);
return;
}
(*env)->ReleaseByteArrayElements(env, buf, byteBuf, 0);
return;
}
/*
* Class: nitf_ImageSubheader
* Method: createBands
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL Java_nitf_ImageSubheader_createBands
(JNIEnv * env, jobject self, jint numBands)
{
nitf_ImageSubheader *header = _GetObj(env, self);
nitf_Error error;
if (!nitf_ImageSubheader_createBands
(header, (nitf_Uint32) numBands, &error))
{
_ThrowNITFException(env, error.message);
return JNI_FALSE;
}
return JNI_TRUE;
}
JNIEXPORT jlong JNICALL Java_nitf_MemorySource_getSize
(JNIEnv *env, jobject self)
{
nitf_BandSource *source = _GetObj(env, self);
nitf_Error error;
nitf_Off size;
if (0 > (size = source->iface->getSize(source->data, &error)))
{
_ThrowNITFException(env, error.message);
return -1;
}
return (jlong)size;
}
JNIEXPORT void JNICALL Java_nitf_WriteHandler_construct
(JNIEnv *env, jobject self)
{
/* make the interface */
static nitf_IWriteHandler iWriteHandler = {
&WriteHandler_write,
&WriteHandler_destruct
};
nitf_WriteHandler *writeHandler = NULL;
WriteHandlerImpl *impl = NULL;
nitf_Error error;
/* construct the persisent one */
impl = (WriteHandlerImpl *) NITF_MALLOC(sizeof(WriteHandlerImpl));
if (!impl)
{
_ThrowNITFException(env, "Out of memory");
return;
}
/**************************************************************/
/* THIS IS VERY IMPORTANT... WE MUST MAKE A STRONG GLOBAL REF */
/**************************************************************/
impl->self = (*env)->NewGlobalRef(env, self);
writeHandler = (nitf_WriteHandler *) NITF_MALLOC(sizeof(nitf_WriteHandler));
if (!writeHandler)
{
_ThrowNITFException(env, "Out of Memory");
return;
}
writeHandler->data = impl;
writeHandler->iface = &iWriteHandler;
_SetObj(env, self, writeHandler);
}
JNIEXPORT jlong JNICALL Java_nitf_NativeIOInterface_getSize(JNIEnv *env,
jobject self)
{
nitf_Error error;
nitf_Off size;
nitf_IOInterface *interface = _GetObj(env, self);
size = interface->iface->getSize(interface->data, &error);
if (size == (nitf_Off)NITF_INVALID_HANDLE_VALUE)
{
_ThrowNITFException(env, error.message);
return -1;
}
return (jlong)size;
}
JNIEXPORT jobject JNICALL Java_nitf_TRE_00024TREIterator_next
(JNIEnv *env, jobject self)
{
nitf_TREEnumerator *enumerator = _GetObj(env, self);
nitf_Pair *pair = NULL;
jclass fieldClass, fieldPairClass;
jmethodID fieldInitMethod, fieldPairInitMethod;
jfieldID nameFieldID, fieldFieldID;
jobject jField, jFieldPair;
jstring jFieldName;
nitf_Error error;
if (!enumerator)
return NULL;
/* get the next value */
pair = enumerator->next(enumerator, &error);
if (!pair)
{
_ThrowNITFException(env, "NULL pair");
return NULL;
}
fieldClass = (*env)->FindClass(env, "nitf/Field");
fieldPairClass = (*env)->FindClass(env, "nitf/TRE$FieldPair");
nameFieldID = (*env)->GetFieldID(env, fieldPairClass, "name",
"Ljava/lang/String;");
fieldFieldID = (*env)->GetFieldID(env, fieldPairClass, "field",
"Lnitf/Field;");
fieldInitMethod =
(*env)->GetMethodID(env, fieldClass, "<init>", "(J)V");
fieldPairInitMethod =
(*env)->GetMethodID(env, fieldPairClass, "<init>", "()V");
jField = (*env)->NewObject(env,
fieldClass, fieldInitMethod, (jlong) pair->data);
jFieldName = (*env)->NewStringUTF(env, pair->key);
jFieldPair = (*env)->NewObject(env,
fieldPairClass, fieldPairInitMethod);
(*env)->SetObjectField(env, jFieldPair, nameFieldID, jFieldName);
(*env)->SetObjectField(env, jFieldPair, fieldFieldID, jField);
return jFieldPair;
}
/*
* Class: nitf_Record
* Method: construct
* Signature: (Lnitf/Version;)V
*/
JNIEXPORT void JNICALL Java_nitf_Record_construct
(JNIEnv * env, jobject self, jobject version)
{
nitf_Record *record;
nitf_Error error;
nitf_Version nitfVersion = _GetNITFVersion(env, version);
record = nitf_Record_construct(nitfVersion, &error);
if (!record)
{
/* throw an error */
_ThrowNITFException(env, error.message);
}
_SetObj(env, self, record);
}
/*
* Class: nitf_SubWindow
* Method: construct
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_nitf_SubWindow_construct
(JNIEnv * env, jobject self)
{
nitf_SubWindow *subWindow;
nitf_Error error;
subWindow = nitf_SubWindow_construct(&error);
if (!subWindow)
{
/* throw an error */
_ThrowNITFException(env, error.message);
}
else
{
_SetObj(env, self, subWindow);
}
}
JNIEXPORT jobject JNICALL Java_nitf_DESubheader_setSubheaderFields
(JNIEnv *env, jobject self, jobject subheaderFields)
{
nitf_DESubheader *header = _GetObj(env, self);
jobject tre = NULL;
jmethodID initMethod = NULL, addressMethod = NULL;
nitf_TRE *newTRE = NULL, *clonedTRE = NULL;
jclass treClass = (*env)->FindClass(env, "nitf/TRE");
nitf_Error error;
if (subheaderFields != NULL)
{
initMethod = (*env)->GetMethodID(env, treClass, "<init>", "(J)V");
addressMethod = (*env)->GetMethodID(env, treClass, "getAddress", "()J");
/* get the address of the new one passed in */
newTRE = (nitf_TRE*) (*env)->CallLongMethod(env, subheaderFields,
addressMethod);
/* clone it */
clonedTRE = nitf_TRE_clone(newTRE, &error);
if (!clonedTRE)
{
_ThrowNITFException(env, error.message);
return NULL;
}
}
/* get the current TRE object, and tell Java we're done with it */
if (header->subheaderFields)
{
_ManageObject(env, (jlong)header->subheaderFields, JNI_TRUE);
}
/* set the cloned one to the subheaderFields */
header->subheaderFields = clonedTRE;
if (clonedTRE != NULL)
{
/* create a new Java TRE from the clone and tell Java not to manage it */
tre = _NewObject(env, (jlong)header->subheaderFields, "nitf/TRE");
_ManageObject(env, (jlong)header->subheaderFields, JNI_FALSE);
}
return tre;
}
