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; }