/*
* 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;
}
NITFPRIV(NITF_CLEVEL) checkCCSExtent(nitf_Record* record,
nitf_Error* error)
{
int i = 0;
int clevel = NITF_CLEVEL_03;
nitf_ListIterator it = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&it, &end))
{
nitf_ImageSegment* imageSegment =
(nitf_ImageSegment*)nitf_ListIterator_get(&it);
int result = checkILOC(imageSegment->subheader, error);
if (result == NITF_CLEVEL_CHECK_FAILED )
return result;
if ( result > clevel )
{
clevel = result;
}
++i;
nitf_ListIterator_increment(&it);
}
return clevel;
}
NITFPRIV(void) polyDestroy(NITF_DATA* data)
{
/* TODO!! */
cgm_PolyLineElement* poly = (cgm_PolyLineElement*)data;
nitf_ListIterator it, end;
nitf_List* list = (nitf_List*)poly->vertices;
if (poly->attributes)
cgm_LineAttributes_destruct( &(poly->attributes) );
it = nitf_List_begin(list);
end = nitf_List_end(list);
while (nitf_ListIterator_notEqualTo(&it, &end))
{
cgm_Vertex* v = (cgm_Vertex*)nitf_ListIterator_get(&it);
cgm_Vertex_destruct(&v);
nitf_ListIterator_increment(&it);
}
nitf_List_destruct(&list);
NITF_FREE(data);
}
/*
* Class: nitf_ImageSource
* Method: getSize
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_nitf_ImageSource_getSize
(JNIEnv * env, jobject self)
{
nitf_ImageSource *imageSource = _GetObj(env, self);
jint num, actualNum = 0;
nitf_ListIterator iter, end;
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)
{
/* set the size member to the RIGHT value */
imageSource->size = num;
}
return imageSource->size;
}
/*
* Class: nitf_Record
* Method: getGraphics
* Signature: ()[Lnitf/GraphicSegment;
*/
JNIEXPORT jobjectArray JNICALL Java_nitf_Record_getGraphics
(JNIEnv * env, jobject self)
{
nitf_Record *record = _GetObj(env, self);
jclass segmentClass = (*env)->FindClass(env, "nitf/GraphicSegment");
jobjectArray graphics;
jobject segment;
jint count = 0;
nitf_GraphicSegment *graphicSegment;
nitf_ListIterator iter, end;
/* get the initial count */
iter = nitf_List_begin(record->graphics);
end = nitf_List_end(record->graphics);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
count++;
nitf_ListIterator_increment(&iter);
}
/* make the array */
graphics = (*env)->NewObjectArray(env, count, segmentClass, NULL);
iter = nitf_List_begin(record->graphics);
end = nitf_List_end(record->graphics);
count = 0;
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
jmethodID methodID =
(*env)->GetMethodID(env, segmentClass, "<init>", "(J)V");
/* Get the image segment as its proper object */
graphicSegment =
(nitf_GraphicSegment *) nitf_ListIterator_get(&iter);
segment = (*env)->NewObject(env,
segmentClass,
methodID, (jlong) graphicSegment);
(*env)->SetObjectArrayElement(env, graphics, count, segment);
count++;
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
return graphics;
}
void findInExtensions(nitf_Extensions* ext)
{
/* These iterators are for going through the image segments */
nitf_ListIterator iter;
nitf_ListIterator end;
nitf_List* list;
assert( ext );
list = nitf_Extensions_get(ext, "ACFTB");
if (list)
{
/* Set the iterator to traverse the list of image segments */
iter = nitf_List_begin(list);
/* And set this one to the end, so we'll know when we're done! */
end = nitf_List_end(list);
/* While we are not done... */
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
nitf_TRE* tre;
printf("Found ACFTB instance\n");
/* Get the image segment as its proper object */
tre = (nitf_TRE*)nitf_ListIterator_get(&iter);
if ( nitf_HashTable_exists( tre->hash, "raw_data" ) )
{
printf("Your plugin for ACFTB was not loaded so the data is contained in the RAW section\n");
}
else
{
nitf_Pair* mission = nitf_HashTable_find( tre->hash,
"ACMSNID" );
if (! mission )
{
printf("Error: no Mission ID available\n");
nitf_HashTable_print( tre->hash );
}
else
{
nitf_Field* field = (nitf_Field*)mission->data;
printf("Mission ID: [%.*s]\n", field->length, field->raw);
}
}
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No ACFTB\n");
}
}
/*
* Class: nitf_Record
* Method: getImages
* Signature: ()[Lnitf/ImageSegment;
*/
JNIEXPORT jobjectArray JNICALL Java_nitf_Record_getImages
(JNIEnv * env, jobject self)
{
nitf_Record *record = _GetObj(env, self);
jclass segmentClass = (*env)->FindClass(env, "nitf/ImageSegment");
jobjectArray images;
jobject segment;
jint count = 0;
nitf_ImageSegment *imageSegment;
nitf_ListIterator iter, end;
/* get the initial count */
iter = nitf_List_begin(record->images);
end = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
count++;
nitf_ListIterator_increment(&iter);
}
/* make the array */
images = (*env)->NewObjectArray(env, count, segmentClass, NULL);
iter = nitf_List_begin(record->images);
end = nitf_List_end(record->images);
count = 0;
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
jmethodID methodID =
(*env)->GetMethodID(env, segmentClass, "<init>", "(J)V");
imageSegment = (nitf_ImageSegment *) nitf_ListIterator_get(&iter);
segment = (*env)->NewObject(env,
segmentClass,
methodID, (jlong) imageSegment);
(*env)->SetObjectArrayElement(env, images, count, segment);
count++;
nitf_ListIterator_increment(&iter);
}
return images;
}
void lookForTREField(nitf_Extensions* ext,
const char* tag,
const char* pattern)
{
nitf_ListIterator current, last;
nitf_List* list = nitf_Extensions_getTREsByName(ext, tag);
if (list == NULL) return;
current = nitf_List_begin(list);
last = nitf_List_end(list);
while (nitf_ListIterator_notEqualTo(¤t, &last))
{
nitf_Error error;
nitf_TRE* tre = nitf_ListIterator_get(¤t);
nitf_ListIterator currentInst;
nitf_ListIterator lastInst;
nitf_List* found = nitf_TRE_find(tre, pattern, &error);
if (!found) return;
currentInst = nitf_List_begin(found);
lastInst = nitf_List_end(found);
while (nitf_ListIterator_notEqualTo(¤tInst, &lastInst))
{
nitf_Pair* pair = nitf_ListIterator_get(¤tInst);
nitf_Field* field = (nitf_Field*)pair->data;
printf("Found: %s [%.*s]\n", pair->key, (int)field->length, field->raw);
nitf_ListIterator_increment(¤tInst);
}
nitf_ListIterator_increment(¤t);
}
}
NITFPRIV(void) polyPrint(NITF_DATA* data)
{
cgm_PolyLineElement* poly = (cgm_PolyLineElement*)data;
nitf_ListIterator it, end;
nitf_List* list = (nitf_List*)poly->vertices;
if (poly->attributes)
cgm_LineAttributes_print( poly->attributes );
it = nitf_List_begin(list);
end = nitf_List_end(list);
while (nitf_ListIterator_notEqualTo(&it, &end))
{
cgm_Vertex* v = (cgm_Vertex*)nitf_ListIterator_get(&it);
printf("\t");
cgm_Vertex_print(v);
nitf_ListIterator_increment(&it);
}
}
/*
* Class: nitf_ImageSubheader
* Method: getImageComments
* Signature: ()[Lnitf/Field;
*/
JNIEXPORT jobjectArray JNICALL Java_nitf_ImageSubheader_getImageComments
(JNIEnv * env, jobject self)
{
nitf_ImageSubheader *header = _GetObj(env, self);
nitf_Uint32 numComments;
nitf_Error error;
jint i;
jobjectArray array;
jobject fieldObj;
nitf_ListIterator iter, end;
jclass fieldClass = (*env)->FindClass(env, "nitf/Field");
NITF_TRY_GET_UINT32(header->numImageComments, &numComments, &error);
if (numComments > 0)
{
array =
(*env)->NewObjectArray(env, numComments, fieldClass, NULL);
iter = nitf_List_begin(header->imageComments);
end = nitf_List_end(header->imageComments);
for (i = 0; nitf_ListIterator_notEqualTo(&iter, &end); ++i)
{
fieldObj = _GetFieldObj(env,
(nitf_Field*) nitf_ListIterator_get(&iter));
(*env)->SetObjectArrayElement(env, array, i, fieldObj);
nitf_ListIterator_increment(&iter);
}
}
else
{
array = (*env)->NewObjectArray(env, 0, fieldClass, NULL);
}
return array;
CATCH_ERROR:
_ThrowNITFException(env, error.message);
return NULL;
}
nitf_Record *doRead(const char *inFile)
{
/* This is the error we hopefully wont receive */
nitf_Error e;
/* This is the reader */
nitf_Reader *reader;
/* This is the record of the file we are reading */
nitf_Record *record;
/* This is the io handle we will give the reader to parse */
nitf_IOHandle io;
int count = 0;
int numImages;
int numTexts;
int numDataExtensions;
nitf_ListIterator iter;
nitf_ListIterator end;
nitf_ImageSegment *imageSegment = NULL;
nitf_ImageReader *deserializer = NULL;
nitf_TextSegment *textSegment = NULL;
nitf_DESegment *deSegment = NULL;
nitf_SegmentReader *segmentReader = NULL;
nitf_SegmentReader *deReader = NULL;
reader = nitf_Reader_construct(&e);
if (!reader)
{
nitf_Error_print(&e, stderr, "nitf::Reader::construct() failed");
exit(EXIT_FAILURE);
}
/* If you did, though, we'll be nice and open it for you */
io = nitf_IOHandle_create(inFile,
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &e);
/* But, oh boy, if you gave us a bad location...! */
if (NITF_INVALID_HANDLE(io))
{
/* You had this coming! */
nitf_Error_print(&e, stderr, "nitf::IOHandle::create() failed");
exit(EXIT_FAILURE);
}
/* Read the file */
record = nitf_Reader_read(reader, io, &e);
if (!record)
{
nitf_Error_print(&e, stderr, "nitf::Reader::read() failed");
exit(EXIT_FAILURE);
}
if (!nitf_Field_get
(record->header->numImages, &numImages, NITF_CONV_INT,
NITF_INT32_SZ, &e))
{
nitf_Error_print(&e, stderr, "nitf::Field::get() failed");
numImages = 0;
}
if (!nitf_Field_get
(record->header->numTexts, &numTexts, NITF_CONV_INT,
NITF_INT32_SZ, &e))
{
nitf_Error_print(&e, stderr, "nitf::Field::get() failed");
numTexts = 0;
}
if (!nitf_Field_get
(record->header->numDataExtensions, &numDataExtensions, NITF_CONV_INT,
NITF_INT32_SZ, &e))
{
nitf_Error_print(&e, stderr, "nitf::Field::get() failed");
numDataExtensions = 0;
}
if (record->images)
{
end = nitf_List_end(record->images);
for (count = 0; count < numImages; ++count)
{
iter = nitf_List_at(record->images, count);
if (nitf_ListIterator_equals(&iter, &end))
{
printf("Out of bounds on iterator [%d]!\n", count);
exit(EXIT_FAILURE);
}
imageSegment = (nitf_ImageSegment *) nitf_ListIterator_get(&iter);
deserializer = nitf_Reader_newImageReader(reader, count, &e);
if (!deserializer)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing image %d... ", count);
/* Write the thing out */
manuallyWriteImageBands(imageSegment, inFile, deserializer, count,
&e);
nitf_ImageReader_destruct(&deserializer);
printf("done.\n");
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
/* loop over texts and read the data to a file */
if (record->texts)
{
end = nitf_List_end(record->texts);
for (count = 0; count < numTexts; ++count)
{
iter = nitf_List_at(record->texts, count);
if (nitf_ListIterator_equals(&iter, &end))
{
printf("Out of bounds on iterator [%d]!\n", count);
exit(EXIT_FAILURE);
}
textSegment = (nitf_TextSegment *) nitf_ListIterator_get(&iter);
segmentReader = nitf_Reader_newTextReader(reader, count, &e);
if (!segmentReader)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing text %d... ", count);
/* Write the thing out */
writeTextData(textSegment, inFile, segmentReader, count, &e);
nitf_SegmentReader_destruct(&segmentReader);
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
/*XXX*/
/* loop over data extensions and read the data to a file */
if (record->dataExtensions)
{
fprintf(stderr, "XXX Data Ext %d\n", numDataExtensions);
end = nitf_List_end(record->dataExtensions);
for (count = 0; count < numDataExtensions; ++count)
{
iter = nitf_List_at(record->dataExtensions, count);
if (nitf_ListIterator_equals(&iter, &end))
{
printf("Out of bounds on iterator [%d]!\n", count);
exit(EXIT_FAILURE);
}
deSegment = (nitf_DESegment *) nitf_ListIterator_get(&iter);
deReader = nitf_Reader_newDEReader(reader, count, &e);
if (!deReader)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing data extension %d... ", count);
/* Write the thing out */
writeDEData(deSegment, inFile, deReader, count, &e);
nitf_SegmentReader_destruct(&segmentReader);
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
nitf_Reader_destruct(&reader);
return record;
}
nitf_TREPrivateData_clone(nitf_TREPrivateData *source, nitf_Error * error)
{
nitf_TREPrivateData *priv = NULL;
/* temporary nitf_List pointer */
nitf_List *lPtr;
/* temporary nitf_Field pointer */
nitf_Field *field;
/* temporary nitf_Pair pointer */
nitf_Pair *pair;
/* iterator to front of list */
nitf_ListIterator iter;
/* iterator to back of list */
nitf_ListIterator end;
/* used for iterating */
int i;
if (source)
{
priv = nitf_TREPrivateData_construct(error);
if (!priv)
goto CATCH_ERROR;
if (!nitf_TREPrivateData_setDescriptionName(
priv, source->descriptionName, error))
{
goto CATCH_ERROR;
}
/* Copy the entire contents of the hash */
for (i = 0; i < source->hash->nbuckets; i++)
{
/* Foreach chain in the hash table... */
lPtr = source->hash->buckets[i];
iter = nitf_List_begin(lPtr);
end = nitf_List_end(lPtr);
/* And while they are different... */
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
/* Retrieve the field at the iterator... */
pair = (nitf_Pair *) nitf_ListIterator_get(&iter);
/* Cast it back to a field... */
field = (nitf_Field *) pair->data;
/* clone the field */
field = nitf_Field_clone(field, error);
/* If that failed, we need to destruct */
if (!field)
goto CATCH_ERROR;
/* Yes, now we can insert the new field! */
if (!nitf_HashTable_insert(priv->hash,
pair->key, field, error))
{
goto CATCH_ERROR;
}
nitf_ListIterator_increment(&iter);
}
}
}
else
{
nitf_Error_initf(error,
NITF_CTXT,
NITF_ERR_INVALID_OBJECT,
"Trying to clone NULL pointer");
}
return priv;
CATCH_ERROR:
if (priv)
nitf_TREPrivateData_destruct(&priv);
return NULL;
}
int main(int argc, char **argv)
{
nitf_Reader* reader; /* The reader object */
nitf_Writer* writer; /* The writer object */
nitf_Record* record; /* a record object */
nitf_Record* record2;
nitf_ListIterator iter; /* current pos iterator */
nitf_ListIterator end; /* end of list iterator */
nitf_ImageSegment* segment; /* the image segment */
NITF_BOOL success; /* status bool */
nitf_IOHandle input_io; /* input IOHandle */
nitf_IOHandle output_io; /* output IOHandle */
nitf_Error error; /* error object */
/* Check argv and make sure we are happy */
if (argc != 3)
{
printf("Usage: %s <input-file> <output-file> \n", argv[0]);
exit(EXIT_FAILURE);
}
input_io = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if ( NITF_INVALID_HANDLE(input_io))
{
goto CATCH_ERROR;
}
output_io = nitf_IOHandle_create(argv[2],
NITF_ACCESS_WRITEONLY,
NITF_CREATE | NITF_TRUNCATE,
&error);
if ( NITF_INVALID_HANDLE(output_io))
{
goto CATCH_ERROR;
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
goto CATCH_ERROR;
}
writer = nitf_Writer_construct(&error);
if (!writer)
{
goto CATCH_ERROR;
}
record = nitf_Record_construct(&error);
if (!record)
{
goto CATCH_ERROR;
}
assert(nitf_Reader_read(reader, input_io, record, &error));
showFileHeader(record->header);
/* Write to the file */
success = nitf_Writer_writeHeader(writer, record->header, output_io, &error);
if (!success) goto CATCH_ERROR;
/* ------ IMAGES ------ */
iter = nitf_List_begin(record->images);
end = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
/* Cast it to an imageSegment... */
segment = (nitf_ImageSegment*)nitf_ListIterator_get(&iter);
/* write the image subheader */
if (!nitf_Writer_writeImageSubheader(writer,
segment->subheader,
record->header->NITF_FVER->raw,
output_io,
&error))
{
goto CATCH_ERROR;
}
/* Now, write the image */
if (!writeImage(segment, input_io, output_io))
{
goto CATCH_ERROR;
}
nitf_ListIterator_increment(&iter);
}
nitf_IOHandle_close(input_io);
nitf_IOHandle_close(output_io);
nitf_Record_destruct(&record);
nitf_Writer_destruct(&writer);
/* Open the file we just wrote to, and dump it to screen */
input_io = nitf_IOHandle_create(argv[2],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING,
&error);
if (NITF_INVALID_HANDLE(input_io))
{
goto CATCH_ERROR;
}
record2 = nitf_Record_construct(&error);
if (!record2)
{
goto CATCH_ERROR;
}
assert(nitf_Reader_readHeader(reader, input_io, record2, &error));
showFileHeader(record2->header);
nitf_IOHandle_close(input_io);
nitf_Record_destruct(&record2);
nitf_Reader_destruct(&reader);
return 0;
CATCH_ERROR:
if (input_io) nitf_IOHandle_close(input_io);
if (output_io) nitf_IOHandle_close(output_io);
if (record2) nitf_Record_destruct(&record2);
if (reader) nitf_Reader_destruct(&reader);
if (record) nitf_Record_destruct(&record);
if (writer) nitf_Writer_destruct(&writer);
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
/* This is the error we hopefully wont receive */
nitf_Error e;
/* This is the reader */
nitf_Reader* reader;
/* This is the record of the file we are reading */
nitf_Record* record;
/* This is the io handle we will give the reader to parse */
nitf_IOHandle io;
/* These iterators are for going through the image segments */
nitf_ListIterator iter;
nitf_ListIterator end;
/* If you didnt give us a nitf file, we're croaking */
if (argc != 2)
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&e);
if (!reader)
{
nitf_Error_print(&e, stderr, "nitf::Reader::construct() failed");
exit(EXIT_FAILURE);
}
/* If you did, though, we'll be nice and open it for you */
io = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING,
&e);
/* But, oh boy, if you gave us a bad location...! */
if ( NITF_INVALID_HANDLE( io ) )
{
/* You had this coming! */
nitf_Error_print(&e, stderr, "nitf::IOHandle::create() failed");
exit(EXIT_FAILURE);
}
/* Read the file */
record = nitf_Reader_read(reader,
io,
&e);
if (!record)
{
nitf_Error_print(&e, stderr, "nitf::Reader::read() failed");
exit(EXIT_FAILURE);
}
/* Set the iterator to traverse the list of image segments */
iter = nitf_List_begin(record->images);
/* And set this one to the end, so we'll know when we're done! */
end = nitf_List_end(record->images);
/* While we are not done... */
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
/* Get the image segment as its proper object */
nitf_ImageSegment* imageSegment =
(nitf_ImageSegment*)nitf_ListIterator_get(&iter);
assert( imageSegment->subheader);
if ( imageSegment->subheader->userDefinedSection )
findInExtensions( imageSegment->subheader->userDefinedSection );
else
printf("Nothing found in user defined section!\n");
if ( imageSegment->subheader->extendedSection )
findInExtensions( imageSegment->subheader->extendedSection );
else
printf("Nothing found in extended section!\n");
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(io);
return 0;
}
int main(int argc, char **argv)
{
/* This is the reader object */
nitf_Reader* reader;
nitf_Record* record;
/* The IO handle */
nitf_IOHandle io;
/* Get the error object */
nitf_Error error;
/* Check argv and make sure we are happy */
if ( argc != 2 )
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
io = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING,
&error);
if ( NITF_INVALID_HANDLE( io ) )
{
nitf_Error_print(&error, stdout, "Exiting...");
exit( EXIT_FAILURE );
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting (1) ...");
exit( EXIT_FAILURE );
}
printf("Here are the loaded handlers\n");
printf("* * * * * * * * * * * * * * * *\n");
{
nitf_PluginRegistry* reg = nitf_PluginRegistry_getInstance(&error);
nitf_HashTable_print( reg->treHandlers);
}
printf("* * * * * * * * * * * * * * * *\n");
record = nitf_Reader_read(reader, io, &error);
if (!record)
{
nitf_Error_print(&error, stderr, "Failed to read the file");
exit(EXIT_FAILURE);
}
/* Now show the header */
showFileHeader(record->header);
/* And now show the image information */
if (record->header->numImages)
{
/* Walk each image and show */
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
nitf_ImageSegment* segment =
(nitf_ImageSegment*)nitf_ListIterator_get(&iter);
nitf_ImageSubheader* dolly =
nitf_ImageSubheader_clone(segment->subheader, &error);
if (!dolly)
{
nitf_Error_print(&error, stdout, "During cloning!");
exit(EXIT_FAILURE);
}
SHOW_IMSUB(segment->subheader);
SHOW_IMSUB(dolly);
nitf_ImageSubheader_destruct(&dolly);
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No image in file!\n");
}
nitf_IOHandle_close(io);
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
return 0;
}
void showImageSubheader(nitf_ImageSubheader* imsub)
{
int q; /* iterator */
int nbands, xbands;
nitf_Error error;
nitf_ListIterator iter, end;
printf("Read image into imsub\n");
SHOW_VAL( imsub->filePartType );
SHOW_VAL( imsub->imageId );
SHOW_VAL( imsub->imageDateAndTime );
SHOW_VAL( imsub->targetId );
SHOW_VAL( imsub->imageTitle );
SHOW_VAL( imsub->imageSecurityClass );
SHOW_VAL( imsub->encrypted );
SHOW_VAL( imsub->imageSource );
SHOW_VAL( imsub->numRows );
SHOW_VAL( imsub->numCols );
SHOW_VAL( imsub->pixelValueType );
SHOW_VAL( imsub->imageRepresentation );
SHOW_VAL( imsub->imageCategory );
SHOW_VAL( imsub->actualBitsPerPixel );
SHOW_VAL( imsub->pixelJustification );
SHOW_VAL( imsub->imageCoordinateSystem );
SHOW_VAL( imsub->cornerCoordinates );
SHOW_VAL( imsub->numImageComments );
iter = nitf_List_begin(imsub->imageComments);
end = nitf_List_end(imsub->imageComments);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
nitf_Field* commentField = (nitf_Field*) nitf_ListIterator_get(&iter);
SHOW_VAL(commentField);
nitf_ListIterator_increment(&iter);
}
SHOW_VAL( imsub->imageCompression );
SHOW_VAL( imsub->compressionRate );
SHOW_VAL( imsub->numImageBands );
SHOW_VAL( imsub->numMultispectralImageBands );
NITF_TRY_GET_UINT32(imsub->numImageBands, &nbands, &error);
NITF_TRY_GET_UINT32(imsub->numMultispectralImageBands, &xbands, &error);
nbands += xbands;
for (q = 0; q < nbands; q++)
{
SHOW_VAL( imsub->bandInfo[q]->representation);
SHOW_VAL( imsub->bandInfo[q]->subcategory );
SHOW_VAL( imsub->bandInfo[q]->imageFilterCondition );
SHOW_VAL( imsub->bandInfo[q]->imageFilterCode );
SHOW_VAL( imsub->bandInfo[q]->numLUTs );
SHOW_VAL( imsub->bandInfo[q]->bandEntriesPerLUT );
}
/* Skip band stuff for now */
SHOW_VAL( imsub->imageSyncCode );
SHOW_VAL( imsub->imageMode );
SHOW_VAL( imsub->numBlocksPerRow );
SHOW_VAL( imsub->numBlocksPerCol );
SHOW_VAL( imsub->numPixelsPerHorizBlock );
SHOW_VAL( imsub->numPixelsPerVertBlock );
SHOW_VAL( imsub->numBitsPerPixel );
SHOW_VAL( imsub->imageDisplayLevel );
SHOW_VAL( imsub->imageAttachmentLevel );
SHOW_VAL( imsub->imageLocation );
SHOW_VAL( imsub->imageMagnification );
SHOW_VAL( imsub->userDefinedImageDataLength );
SHOW_VAL( imsub->userDefinedOverflow );
SHOW_VAL( imsub->extendedHeaderLength );
SHOW_VAL( imsub->extendedHeaderOverflow );
return;
CATCH_ERROR:
printf("Error processing\n");
}
NITFPRIV(NITF_CLEVEL) checkSpecificImageAttributes(nitf_Record* record,
nitf_Error* error)
{
NITF_CLEVEL clevel = NITF_CLEVEL_03;
nitf_ListIterator it = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
int i = 0;
while (nitf_ListIterator_notEqualTo(&it, &end) )
{
NITF_CLEVEL result = NITF_CLEVEL_UNKNOWN;
char irep[ NITF_IREP_SZ + 1];
nitf_ImageSegment* imageSegment =
(nitf_ImageSegment*)nitf_ListIterator_get(&it);
if (!nitf_Field_get(imageSegment->subheader->NITF_IREP,
irep, NITF_CONV_STRING,
NITF_IREP_SZ + 1, error))
return NITF_CLEVEL_CHECK_FAILED;
nitf_Utils_trimString(irep);
if (strcmp( irep, "MONO") == 0)
{
result = checkMonoImage(imageSegment->subheader, error);
}
else if (strcmp( irep, "RGB") == 0)
{
result = checkRGBImage(imageSegment->subheader, error);
}
else if (strcmp( irep, "RGB/LUT" ) == 0)
{
result = checkRGBLUTImage(imageSegment->subheader, error);
}
else if (strcmp( irep, "MULTI" ) == 0)
{
result = checkMultiImage(imageSegment->subheader, error);
}
else
{
/* What happens for these other reps ? */
return result;
}
if ( result == NITF_CLEVEL_CHECK_FAILED ) return result;
if ( result > clevel )
{
clevel = result;
}
++i;
nitf_ListIterator_increment(&it);
}
return clevel;
}
void doWrite(nitf_Record * record, char *inRootFile, char *outFile)
{
nitf_ListIterator iter;
nitf_ImageWriter *iWriter;
nitf_ImageSource *iSource;
nitf_SegmentWriter *segmentWriter;
nitf_SegmentSource *segmentSource;
nitf_ListIterator end;
int i;
int numImages;
int numTexts;
int numDataExtensions;
nitf_Writer *writer = NULL;
nitf_Error error;
nitf_IOHandle output_io = nitf_IOHandle_create(outFile,
NITF_ACCESS_WRITEONLY,
NITF_CREATE,
&error);
if (NITF_INVALID_HANDLE(output_io))
{
goto CATCH_ERROR;
}
writer = nitf_Writer_construct(&error);
if (!writer)
{
goto CATCH_ERROR;
}
if (!nitf_Writer_prepare(writer, record, output_io, &error))
{
goto CATCH_ERROR;
}
if (!nitf_Field_get
(record->header->numImages, &numImages, NITF_CONV_INT,
NITF_INT32_SZ, &error))
{
nitf_Error_print(&error, stderr, "nitf::Value::get() failed");
numImages = 0;
}
if (!nitf_Field_get
(record->header->numTexts, &numTexts, NITF_CONV_INT,
NITF_INT32_SZ, &error))
{
nitf_Error_print(&error, stderr, "nitf::Value::get() failed");
numTexts = 0;
}
if (!nitf_Field_get
(record->header->numDataExtensions, &numDataExtensions, NITF_CONV_INT,
NITF_INT32_SZ, &error))
{
nitf_Error_print(&error, stderr, "nitf::Value::get() failed");
numDataExtensions = 0;
}
if (record->images)
{
end = nitf_List_end(record->images);
for (i = 0; i < numImages; i++)
{
int nbands;
nitf_ImageSegment *imseg = NULL;
iter = nitf_List_at(record->images, i);
assert(nitf_ListIterator_notEqualTo(&iter, &end));
imseg = (nitf_ImageSegment *) nitf_ListIterator_get(&iter);
assert(imseg);
if (!nitf_Field_get
(imseg->subheader->numImageBands, &nbands, NITF_CONV_INT,
NITF_INT32_SZ, &error))
goto CATCH_ERROR;
iWriter = nitf_Writer_newImageWriter(writer, i, &error);
if (!iWriter)
{
goto CATCH_ERROR;
}
iSource = setupBands(nbands, i, inRootFile);
if (!iSource)
goto CATCH_ERROR;
if (!nitf_ImageWriter_attachSource(iWriter, iSource, &error))
goto CATCH_ERROR;
}
}
if (record->texts)
{
end = nitf_List_end(record->texts);
for (i = 0; i < numTexts; i++)
{
nitf_TextSegment *textSeg = NULL;
char *inFile = NULL;
nitf_IOHandle sourceHandle;
iter = nitf_List_at(record->texts, i);
assert(nitf_ListIterator_notEqualTo(&iter, &end));
textSeg = (nitf_TextSegment *) nitf_ListIterator_get(&iter);
assert(textSeg);
segmentWriter = nitf_Writer_newTextWriter(writer, i, &error);
if (!segmentWriter)
{
goto CATCH_ERROR;
}
/* setup file */
inFile = makeBandName(inRootFile, "text", i, -1);
sourceHandle =
nitf_IOHandle_create(inFile, NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(sourceHandle))
goto CATCH_ERROR;
freeBandName(&inFile);
segmentSource = nitf_SegmentFileSource_construct(sourceHandle, 0, 0, &error);
if (!segmentSource)
goto CATCH_ERROR;
if (!nitf_SegmentWriter_attachSource(segmentWriter, segmentSource, &error))
goto CATCH_ERROR;
}
}
if (record->dataExtensions)
{
end = nitf_List_end(record->dataExtensions);
for (i = 0; i < numDataExtensions; i++)
{
nitf_DESegment *DESeg = NULL;
char *inFile = NULL;
nitf_IOHandle sourceHandle;
iter = nitf_List_at(record->dataExtensions, i);
assert(nitf_ListIterator_notEqualTo(&iter, &end));
DESeg = (nitf_DESegment *) nitf_ListIterator_get(&iter);
assert(DESeg);
segmentWriter = nitf_Writer_newDEWriter(writer, i, &error);
if (!segmentWriter)
{
goto CATCH_ERROR;
}
/* setup file */
inFile = makeBandName(inRootFile, "DE", i, -1);
sourceHandle =
nitf_IOHandle_create(inFile, NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(sourceHandle))
goto CATCH_ERROR;
freeBandName(&inFile);
segmentSource = nitf_SegmentFileSource_construct(sourceHandle, 0, 0, &error);
if (!segmentSource)
goto CATCH_ERROR;
if (!nitf_SegmentWriter_attachSource(segmentWriter, segmentSource, &error))
goto CATCH_ERROR;
}
}
if (!nitf_Writer_write(writer, &error))
{
goto CATCH_ERROR;
}
/*nitf_ImageSource_destruct(&iSource);*/
nitf_IOHandle_close(output_io);
nitf_Writer_destruct(&writer);
return;
CATCH_ERROR:
nitf_Error_print(&error, stderr, "During write");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
/* Get the error object */
nitf_Error error;
/* so I can remember what Im doing with args */
const char* treName;
const char* fieldName;
/* This is the reader object */
nitf_Reader *reader;
nitf_Record *record;
/* The IO handle */
nitf_IOHandle io;
int num;
/* Check argv and make sure we are happy */
if (argc != 4)
{
printf("Usage: %s <nitf-file> <TRE> <field>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (nitf_Reader_getNITFVersion(argv[1]) == NITF_VER_UNKNOWN)
{
printf("File: %s is not a NITF\n", argv[1]);
exit(EXIT_FAILURE);
}
treName = argv[2];
fieldName = argv[3];
io = nitf_IOHandle_create(argv[1], NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(io))
{
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting (1) ...");
exit(EXIT_FAILURE);
}
#if NITF_VERBOSE_READER
printf("Here are the loaded handlers\n");
printf("* * * * * * * * * * * * * * * *\n");
nitf_HashTable_print(reader->reg->treHandlers);
printf("* * * * * * * * * * * * * * * *\n");
#endif
record = nitf_Reader_read(reader, io, &error);
lookForTREField(record->header->extendedSection, treName, fieldName);
lookForTREField(record->header->userDefinedSection, treName, fieldName);
if (!nitf_Field_get(record->header->numImages,
&num, NITF_CONV_INT, NITF_INT32_SZ, &error))
goto CATCH_ERROR;
/* And now show the image information */
if (num > 0)
{
/* Walk each image and show */
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
nitf_ImageSegment *segment =
(nitf_ImageSegment *) nitf_ListIterator_get(&iter);
lookForTREField(segment->subheader->extendedSection, treName, fieldName);
lookForTREField(segment->subheader->userDefinedSection, treName, fieldName);
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No image in file!\n");
}
nitf_IOHandle_close(io);
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
return 0;
CATCH_ERROR:
printf("!!! we had a problem reading the file !!!\n");
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
/* Get the error object */
nitf_Error error;
/* This is the reader object */
nitf_Reader* reader;
nitf_Record* record;
/* The IO handle */
nitf_IOHandle io;
int num;
/* Check argv and make sure we are happy */
if ( argc != 2 )
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
io = nitf_IOHandle_create(argv[1], NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, &error);
if ( NITF_INVALID_HANDLE( io ) )
{
nitf_Error_print(&error, stdout, "Exiting...");
exit( EXIT_FAILURE );
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting (1) ...");
exit( EXIT_FAILURE );
}
/* record = nitf_Record_construct(&error);
if (!record)
{
nitf_Error_print(&error, stdout, "Exiting (2) ...");
nitf_Reader_destruct(&reader);
exit( EXIT_FAILURE );
}*/
#if NITF_VERBOSE_READER
printf("Here are the loaded handlers\n");
printf("* * * * * * * * * * * * * * * *\n");
nitf_HashTable_print(reader->reg->treHandlers);
printf("* * * * * * * * * * * * * * * *\n");
#endif
if ( ! (record = nitf_Reader_read(reader, io, &error )) )
{
nitf_Error_print(&error, stdout, "Exiting ...");
exit(EXIT_FAILURE);
}
printf("User defined: in file header\n");
showExtSection(record->header->userDefinedSection);
printf("Extended defined: in file header\n");
showExtSection(record->header->extendedSection);
if (!nitf_Field_get(record->header->numImages,
&num,
NITF_CONV_INT,
NITF_INT32_SZ,
&error))
nitf_Error_print(&error, stdout, "Skipping b/c Invalid numImages");
/* And now show the image information */
else if (num > 0)
{
/* Walk each image and show */
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
nitf_ImageSegment* segment =
(nitf_ImageSegment*)nitf_ListIterator_get(&iter);
printf("User defined: in image segment\n");
showExtSection(segment->subheader->userDefinedSection);
printf("Extended defined: in image segment\n");
showExtSection(segment->subheader->extendedSection);
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No image in file!\n");
}
nitf_IOHandle_close(io);
nitf_Record_destruct(&record);
if ( !nitf_List_isEmpty(reader->warningList))
{
/* Iterator to a list */
nitf_ListIterator it;
/* Iterator to the end of list */
nitf_ListIterator endList;
it = nitf_List_begin(reader->warningList);
/* End of list pointer */
endList = nitf_List_end(reader->warningList);
printf("WARNINGS: ");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
/* While we are not at the end */
while ( nitf_ListIterator_notEqualTo( &it, &endList ) )
{
/* Get the last data */
char* p = (char*)nitf_ListIterator_get(&it);
/* Make sure */
assert(p != NULL);
/* Show the data */
printf("\tFound problem: [%s]\n\n", p);
/* Increment the list iterator */
nitf_ListIterator_increment(&it);
}
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}
nitf_Reader_destruct(&reader);
return 0;
}
int main(int argc, char **argv)
{
/* This is the error we hopefully wont receive */
nitf_Error e;
/* Skip factors */
nitf_Uint32 rowSkipFactor = 1;
nitf_Uint32 columnSkipFactor = 1;
/* This is the reader */
nitf_Reader *reader;
/* This is the record of the file we are reading */
nitf_Record *record;
/* This is the io handle we will give the reader to parse */
nitf_IOHandle io;
int count = 0;
int numImages;
/* These iterators are for going through the image segments */
nitf_ListIterator iter;
nitf_ListIterator end;
char* inputFile;
NITF_BOOL optz = 0;
/* If you didnt give us a nitf file, we're croaking */
if (argc < 2)
{
printf("Usage: %s <nitf-file> (-o)\n", argv[0]);
exit(EXIT_FAILURE);
}
if (argc == 3)
{
optz = 1;
if (strcmp(argv[1], "-o") == 0)
{
inputFile = argv[2];
}
else if (strcmp(argv[2], "-o") == 0)
{
inputFile = argv[1];
}
else
{
printf("Usage: %s <nitf-file> (-o)\n", argv[0]);
exit(EXIT_FAILURE);
}
}
else
inputFile = argv[1];
/* You should use this function to test that you have a valid NITF */
if (nitf_Reader_getNITFVersion( inputFile ) == NITF_VER_UNKNOWN)
{
printf("This file does not appear to be a valid NITF");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&e);
if (!reader)
{
nitf_Error_print(&e, stderr, "Reader creation failed");
exit(EXIT_FAILURE);
}
/*
* As of 2.5, you do not have to use an IOHandle if you use
* readIO instead of read()
*/
io = nitf_IOHandle_create(inputFile,
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &e);
if (NITF_INVALID_HANDLE(io))
{
nitf_Error_print(&e, stderr, "IO creation failed");
exit(EXIT_FAILURE);
}
/* Read the file */
record = nitf_Reader_read(reader, io, &e);
if (!record)
{
nitf_Error_print(&e, stderr, "Read failed");
nitf_IOHandle_close(io);
nitf_Reader_destruct(&reader);
exit(EXIT_FAILURE);
}
numImages = nitf_Record_getNumImages(record, &e);
if ( NITF_INVALID_NUM_SEGMENTS( numImages ) )
{
nitf_Error_print(&e, stderr, "Failed to get the number of images");
nitf_IOHandle_close(io);
nitf_Reader_destruct(&reader);
nitf_Record_destruct( &record );
exit(EXIT_FAILURE);
}
/* Set the iterator to traverse the list of image segments */
iter = nitf_List_begin(record->images);
/* And set this one to the end, so we'll know when we're done! */
end = nitf_List_end(record->images);
for (count = 0; count < numImages; ++count)
{
nitf_ImageSegment *imageSegment =
(nitf_ImageSegment *) nitf_ListIterator_get(&iter);
nitf_ImageReader *deserializer =
nitf_Reader_newImageReader(reader, count, &e);
if (!deserializer)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing image %d... ", count);
/* Write the thing out */
writeImage(imageSegment, inputFile, deserializer, count,
rowSkipFactor, columnSkipFactor, optz, &e);
nitf_ImageReader_destruct(&deserializer);
printf("done.\n");
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(io);
return 0;
}
int main(int argc, char **argv)
{
int rc = 0;
int argIt = 0, i = 0, num = 0, dump = 0;
char *fname = NULL;
nrt_Error error;
nrt_IOInterface *io = NULL;
nitf_Reader *reader = NULL;
nitf_Record *record = NULL;
nrt_Uint8 *buf = NULL;
for (argIt = 1; argIt < argc; ++argIt)
{
if (strcmp(argv[argIt], "--dump") == 0)
dump = 1;
else if (!fname)
{
fname = argv[argIt];
}
}
if (!fname)
{
nrt_Error_init(&error, "Usage: [--x0 --y0 --x1 --y1] <j2k-file>",
NRT_CTXT, NRT_ERR_INVALID_OBJECT);
goto CATCH_ERROR;
}
if (nitf_Reader_getNITFVersion(fname) == NITF_VER_UNKNOWN)
{
nrt_Error_init(&error, "This file does not appear to be a valid NITF",
NRT_CTXT, NRT_ERR_INVALID_OBJECT);
goto CATCH_ERROR;
}
if (!(io = nrt_IOHandleAdapter_open(fname, NRT_ACCESS_READONLY, NRT_OPEN_EXISTING,
&error)))
goto CATCH_ERROR;
if (!(reader = nitf_Reader_construct(&error)))
goto CATCH_ERROR;
if (!(record = nitf_Reader_readIO(reader, io, &error)))
goto CATCH_ERROR;
num = nitf_Record_getNumImages(record, &error);
if (num > 0)
{
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
for (i = 0; nitf_ListIterator_notEqualTo(&iter, &end); ++i)
{
nitf_ImageSegment *segment =
(nitf_ImageSegment *) nitf_ListIterator_get(&iter);
nitf_ImageSubheader *subheader = segment->subheader;
if (strcmp(subheader->imageCompression->raw, "C8") == 0)
{
j2k_Reader *j2kReader = NULL;
j2k_Container *container = NULL;
nrt_Uint32 cmpIt, nComponents;
printf("Image %d contains J2K compressed data\n", (i + 1));
printf("Offset: %d\n", segment->imageOffset);
if (!nrt_IOInterface_seek(io, segment->imageOffset,
NRT_SEEK_SET, &error))
goto CATCH_ERROR;
if (!(j2kReader = j2k_Reader_openIO(io, &error)))
goto CATCH_ERROR;
if (!(container = j2k_Reader_getContainer(j2kReader, &error)))
goto CATCH_ERROR;
printf("grid width:\t%d\n", j2k_Container_getGridWidth(container, &error));
printf("grid height:\t%d\n", j2k_Container_getGridHeight(container, &error));
printf("tile width:\t%d\n", j2k_Container_getTileWidth(container, &error));
printf("tile height:\t%d\n", j2k_Container_getTileHeight(container, &error));
printf("x tiles:\t%d\n", j2k_Container_getTilesX(container, &error));
printf("y tiles:\t%d\n", j2k_Container_getTilesY(container, &error));
printf("image type:\t%d\n", j2k_Container_getImageType(container, &error));
nComponents = j2k_Container_getNumComponents(container, &error);
printf("components:\t%d\n", nComponents);
for(cmpIt = 0; cmpIt < nComponents; ++cmpIt)
{
j2k_Component* c = j2k_Container_getComponent(container, cmpIt, &error);
printf("===component %d===\n", (cmpIt + 1));
printf("width:\t\t%d\n", j2k_Component_getWidth(c, &error));
printf("height:\t\t%d\n", j2k_Component_getHeight(c, &error));
printf("precision:\t%d\n", j2k_Component_getPrecision(c, &error));
printf("x0:\t\t%d\n", j2k_Component_getOffsetX(c, &error));
printf("y0:\t\t%d\n", j2k_Component_getOffsetY(c, &error));
printf("x separation:\t%d\n", j2k_Component_getSeparationX(c, &error));
printf("y separation:\t%d\n", j2k_Component_getSeparationY(c, &error));
printf("signed:\t\t%d\n", j2k_Component_isSigned(c, &error));
}
if (dump)
{
char namePrefix[NRT_MAX_PATH];
nrt_Uint32 width, height;
nrt_Uint64 bufSize;
if (buf)
{
NRT_FREE(buf);
buf = NULL;
}
width = j2k_Container_getWidth(container, &error);
height = j2k_Container_getWidth(container, &error);
if ((bufSize = j2k_Reader_readRegion(j2kReader, 0, 0,
width, height,
&buf, &error)) == 0)
{
goto CATCH_ERROR;
}
NRT_SNPRINTF(namePrefix, NRT_MAX_PATH, "image-%d", (i + 1));
if (!writeFile(0, 0, width, height, buf, bufSize,
namePrefix, &error))
{
goto CATCH_ERROR;
}
}
}
nitf_ListIterator_increment(&iter);
}
}
goto CLEANUP;
CATCH_ERROR:
{
nrt_Error_print(&error, stdout, "Exiting...");
rc = 1;
}
CLEANUP:
{
if (reader)
nitf_Reader_destruct(&reader);
if (record)
nitf_Record_destruct(&record);
if (io)
nrt_IOInterface_destruct(&io);
}
return rc;
}
int main(int argc, char *argv[])
{
nitf_Reader *reader; /* Reader object */
nitf_Record *record; /* Record used for input and output */
nitf_IOHandle in; /* Input I/O handle */
nitf_ListIterator imgIter; /* Image segment list iterator */
nitf_ListIterator imgEnd; /* Image segment list iterator */
nitf_ImageSegment *seg; /* Image segment object */
nitf_ImageSubheader *subhdr; /* Image subheader object */
nitf_ImageReader *iReader; /* Image reader */
nitf_BlockingInfo *blkInfo; /* Blocking information */
static nitf_Error errorObj; /* Error object for messages */
nitf_Error *error; /* Pointer to the error object */
/* Image information */
char imageMode[NITF_IMODE_SZ+1]; /* Image (blocking) mode */
/* Mask structure and mask components */
nitf_Uint32 imageDataOffset; /* Offset to actual image data past masks */
nitf_Uint32 blockRecordLength; /* Block mask record length */
nitf_Uint32 padRecordLength; /* Pad mask record length */
nitf_Uint32 padPixelValueLength; /* Pad pixel value length in bytes */
nitf_Uint8 *padValue; /* Pad value */
nitf_Uint64 *blockMask; /* Block mask array */
nitf_Uint64 *padMask; /* Pad mask array */
size_t imgCtr = 0;
const char* pathname;
error = &errorObj;
if (argc != 2)
{
fprintf(stderr, "Usage %s inputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
pathname = argv[1];
/* Get the input record */
in = nitf_IOHandle_create(pathname,
NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, error);
if (NITF_INVALID_HANDLE(in))
{
nitf_Error_print(error, stderr, "Error opening input ");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(error);
if (reader == NULL)
{
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, error);
if (record == NULL)
{
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
/* Loop through the image segments */
imgIter = nitf_List_begin(record->images);
imgEnd = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&imgIter, &imgEnd))
{
/* Get information from the image subheader */
seg = (nitf_ImageSegment *) nitf_ListIterator_get(&imgIter);
if (seg == NULL)
{
fprintf(stderr, "No Image segment\n");
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
exit(EXIT_FAILURE);
}
subhdr = seg->subheader;
nitf_Field_get(subhdr->imageMode,
imageMode, NITF_CONV_STRING, NITF_IMODE_SZ + 1, error);
imageMode[NITF_IMODE_SZ] = 0;
/* Get an image reader which creates the nitf_ImageIO were the masks are */
iReader = nitf_Reader_newImageReader(reader, imgCtr, NULL, error);
if (iReader == NULL)
{
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Record_destruct(&record);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
blkInfo = nitf_ImageReader_getBlockingInfo(iReader, error);
if (blkInfo == NULL)
{
nitf_ImageReader_destruct(&iReader);
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Record_destruct(&record);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
/* Print the blocking information */
printf("Image %s segment %zu:\n", pathname, imgCtr);
printf(" Blocking (mode is %s):\n", imageMode);
printf(" Block array dimensions (r,c) = %d %d\n",
blkInfo->numBlocksPerRow, blkInfo->numBlocksPerCol);
printf(" Block dimensions (r,c) = %d,%d\n",
blkInfo->numRowsPerBlock, blkInfo->numColsPerBlock);
printf(" Block length in bytes %zu\n", blkInfo->length);
/* Get the actual information */
if (nitf_ImageIO_getMaskInfo(iReader->imageDeblocker,
&imageDataOffset, &blockRecordLength,
&padRecordLength, &padPixelValueLength,
&padValue, &blockMask, &padMask))
{
nitf_Uint32 i;
printf(" Masked image:\n");
printf(" Image data offset = %d\n", imageDataOffset);
printf(" Block and pad mask record lengths = %u %u\n",
blockRecordLength, padRecordLength);
printf(" Pad value length = %u\n", padPixelValueLength);
printf(" Pad value = ");
for (i = 0;i < padPixelValueLength;i++)
{
printf("%x ", padValue[i]);
}
printf("\n");
if (blockRecordLength != 0)
{
dumpMask("Block",
blockMask,
blkInfo->numBlocksPerRow,
blkInfo->numBlocksPerCol);
}
if (padRecordLength != 0)
{
dumpMask("Pad",
padMask,
blkInfo->numBlocksPerRow,
blkInfo->numBlocksPerCol);
}
}
else
{
printf("Not a masked image\n");
}
nitf_ImageReader_destruct(&iReader);
nrt_ListIterator_increment(&imgIter);
++imgCtr;
}
/* Clean-up */
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Record_destruct(&record);
return(0);
}