int main(int argc, char *argv[])
{
char *inFile; /* Input filename */
char *outFile; /* Output filename */
char *compCode; /* Compression code NC or NM */
char *padValueString = NULL; /* Pad value string */
nitf_Reader *reader; /* Reader object */
nitf_Record *record; /* Record used for input and output */
imgInfo *imgs; /* Image segment information */
nitf_FileHeader *fileHdr; /* File header */
nitf_Uint32 numImages; /* Total number of image segments */
nitf_ListIterator imgIter; /* Image segment list iterator */
nitf_IOHandle in; /* Input I/O handle */
nitf_IOHandle out; /* Output I/O handle */
nitf_Writer *writer; /* Writer object for output */
static nitf_Error errorObj; /* Error object for messages */
nitf_Error *error; /* Pointer to the error object */
int i;
error = &errorObj;
compCode = "NM";
if (argc == 3)
{
inFile = argv[1];
outFile = argv[2];
}
else if (argc == 4)
{
if (strcmp(argv[1], "-r") != 0)
{
fprintf(stderr,
"Usage %s [-r] [-p padValue] inputFile outputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
inFile = argv[2];
outFile = argv[3];
compCode = "NC";
}
else if (argc == 5)
{
if (strcmp(argv[1], "-p") != 0)
{
fprintf(stderr,
"Usage %s [-r] [-p padValue] inputFile outputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
inFile = argv[3];
outFile = argv[4];
padValueString = argv[2];
}
else
{
fprintf(stderr, "Usage %s [-r] inputFile outputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
/* Get the input record */
in = nitf_IOHandle_create(inFile,
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)
{
nitf_Error_print(error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, error);
if (!record)
{
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
fileHdr = record->header;
nitf_Field_get(fileHdr->numImages,
&numImages, NITF_CONV_UINT, NITF_INT32_SZ, error);
/* Get information about all image segments and set-up for write */
imgs = (imgInfo *) NITF_MALLOC(numImages * sizeof(imgInfo));
if (imgs == NULL)
{
nitf_Error_print(error, stderr, "Error allocating image info ");
exit(EXIT_FAILURE);
}
for (i = 0;i < numImages;i++)
{
imgs[i].index = i;
imgIter = nitf_List_at(record->images, i);
imgs[i].seg = (nitf_ImageSegment *) nitf_ListIterator_get(&imgIter);
if (!imgs[i].seg)
{
fprintf(stderr, "No Image segment in file\n");
exit(EXIT_FAILURE);
}
imgs[i].subhdr = imgs[i].seg->subheader;
if (padValueString != NULL)
{
if (!decodePadValue(&(imgs[i]), padValueString, imgs[i].padValue, error))
{
nitf_Error_print(error, stderr, "Error allocating image info ");
exit(EXIT_FAILURE);
}
}
else
memset(imgs[i].padValue, 0, MAX_PAD);
}
/* Read all of the image data into buffers */
for (i = 0;i < numImages;i++)
if (!readImageSegment(&(imgs[i]), reader, error))
{
nitf_Error_print(error, stderr, "Error reading image segment ");
exit(EXIT_FAILURE);
}
/* Set compression type to NM or NC (has to happen afetr read) */
for (i = 0;i < numImages;i++)
{
if (!nitf_ImageSubheader_setCompression(imgs[i].subhdr, compCode, "", error))
{
nitf_Error_print(error, stderr, "No DE segment in file ");
exit(EXIT_FAILURE);
}
}
/* Create output */
out = nitf_IOHandle_create(outFile, NITF_ACCESS_WRITEONLY, NITF_CREATE, error);
if (NITF_INVALID_HANDLE(out))
{
nitf_Error_print(error, stderr, "Could not create output file ");
exit(EXIT_FAILURE);
}
/* Setup write and write */
writer = nitf_Writer_construct(error);
if (writer == NULL)
{
nitf_Error_print(error, stderr, "Write setup failed ");
exit(EXIT_FAILURE);
}
if (!nitf_Writer_prepare(writer, record, out, error))
{
nitf_Error_print(error, stderr, "Write setup failed ");
exit(EXIT_FAILURE);
}
for (i = 0;i < numImages;i++)
if (!makeImageSource(&(imgs[i]), writer, error))
{
nitf_Error_print(error, stderr, "Write setup failed ");
exit(EXIT_FAILURE);
}
/* Set pad pixel if padValue string is not NULL */
if (padValueString != NULL)
for (i = 0;i < numImages;i++)
{
}
if (!nitf_Writer_write(writer, error))
{
nitf_Error_print(error, stderr, "Write error ");
exit(EXIT_FAILURE);
}
/* Clean-up */
nitf_Record_destruct(&record);
nitf_IOHandle_close(out);
return 0;
}
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);
}
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;
}
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 desIter; /* Iterator for getting the DES */
nitf_DESegment *des; /* DE segment to read */
nitf_DEReader *deReader; /* DE reader object for reading data */
char *data; /* Data buffer */
static nitf_Error errorObj; /* Error object for messages */
nitf_Error *error; /* Pointer to the error object */
error = &errorObj;
if (argc != 2)
{
fprintf(stderr, "Usage %s inputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
/* Get the input record */
in = nitf_IOHandle_create(argv[1],
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)
{
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, error);
if (!record)
{
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
/* Print the user header */
desIter = nitf_List_at(record->dataExtensions, 0);
des = (nitf_DESegment *) nitf_ListIterator_get(&desIter);
if (!des)
{
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "No DE segment in file ");
exit(EXIT_FAILURE);
}
nitf_TRE_print(des->subheader->subheaderFields, error);
/* Read the data and print it */
deReader = nitf_Reader_newDEReader(reader, 0, error);
if (!deReader)
{
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Could not create DEReader ");
exit(EXIT_FAILURE);
}
fprintf(stdout, "Data length = %d\n", deReader->user->dataLength);
fprintf(stdout, "Virtual data length = %d\n",
deReader->user->virtualLength);
fprintf(stdout, "File offset = %lld\n", deReader->user->baseOffset);
data = (char *) NITF_MALLOC(deReader->user->virtualLength + 2);
if (!data)
{
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Could not allocate data buffer ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read
(deReader, data, deReader->user->virtualLength, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
fprintf(stdout, "Data: |%s|\n", data);
/* Try some seeks */
if (nitf_DEReader_seek(deReader, (nitf_Off) 4, SEEK_SET, error) == (nitf_Off) - 1)
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read(deReader, data, 1, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
data[1] = 0;
fprintf(stdout, "Data after set seek: |%s|\n", data);
/*
The last read advanced to position 5 so relative position10 should be
the last byte in the file
*/
if (nitf_DEReader_seek(deReader, (nitf_Off) 10, SEEK_CUR, error) == (nitf_Off) - 1)
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read(deReader, data, 1, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
data[1] = 0;
fprintf(stdout, "Data after current seek: |%s|\n", data);
if (nitf_DEReader_seek(deReader, (nitf_Off) - 2, SEEK_END, error) == (nitf_Off) - 1)
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read(deReader, data, 1, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
data[1] = 0;
fprintf(stdout, "Data after end seek: |%s|\n", data);
/* Clean-up */
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
return 0;
}
