NRTAPI(NRT_DATA *) nrt_List_get(nrt_List * list, int index, nrt_Error * error)
{
int i = 0;
if (list)
{
nrt_ListIterator iter = nrt_List_begin(list);
nrt_ListIterator end = nrt_List_end(list);
for (i = 0; i < index && nrt_ListIterator_notEqualTo(&iter, &end); ++i)
nrt_ListIterator_increment(&iter);
if (i == index && nrt_ListIterator_notEqualTo(&iter, &end))
{
return nrt_ListIterator_get(&iter);
}
else
{
nrt_Error_init(error, "Object not found at index", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
return NULL;
}
}
else
{
nrt_Error_init(error, "Invalid list -> NULL", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
return NULL;
}
}
NRTAPI(nrt_Uint32) nrt_List_size(nrt_List * list)
{
nrt_Uint32 size = 0;
if (list)
{
nrt_ListIterator iter = nrt_List_begin(list);
nrt_ListIterator end = nrt_List_end(list);
while (nrt_ListIterator_notEqualTo(&iter, &end))
{
++size;
nrt_ListIterator_increment(&iter);
}
}
return size;
}
NRTAPI(nrt_ListIterator) nrt_List_at(nrt_List * chain, int i)
{
nrt_ListIterator list_iterator = nrt_List_begin(chain);
nrt_ListIterator end = nrt_List_end(chain);
int j;
for (j = 0; j < i; j++)
{
if (nrt_ListIterator_equals(&list_iterator, &end))
{
list_iterator.current = NULL;
break;
}
nrt_ListIterator_increment(&list_iterator);
}
return list_iterator;
}
NRTAPI(nrt_List *) nrt_List_clone(nrt_List * source, NRT_DATA_ITEM_CLONE cloner,
nrt_Error * error)
{
nrt_List *l = NULL;
if (source)
{
nrt_ListIterator iter = nrt_List_begin(source);
nrt_ListIterator end = nrt_List_end(source);
l = nrt_List_construct(error);
if (!l)
return NULL;
while (nrt_ListIterator_notEqualTo(&iter, &end))
{
/* Foreach item in each list... */
NRT_DATA *data = nrt_ListIterator_get(&iter);
/* Use the function pointer to clone the object... */
NRT_DATA *newData = (NRT_DATA *) cloner(data, error);
if (!newData)
return NULL;
/* ... and then insert it with the key into the new table */
if (!nrt_List_pushBack(l, newData, error))
{
/* destruct the created list. NOTE - there is no way for us to
* destroy the NRT_DATA* chunks that have already been cloned */
nrt_List_destruct(&l);
return NULL;
}
nrt_ListIterator_increment(&iter);
}
}
else
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Trying to clone NULL pointer");
}
return l;
}
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);
}
