NRTAPI(void) nrt_DLL_destruct(nrt_DLL ** dll)
{
nrt_Error error;
if (*dll)
{
/* destroy the lib */
nrt_DLL_unload((*dll), &error);
if ((*dll)->libname)
{
NRT_FREE((*dll)->libname);
(*dll)->libname = NULL;
}
NRT_FREE(*dll);
*dll = NULL;
}
}
NRTPROT(void) nrt_IntStack_destruct(nrt_IntStack ** stk)
{
if (*stk)
{
NRT_FREE(*stk);
*stk = NULL;
}
}
NRTAPI(void) nrt_DateTime_destruct(nrt_DateTime ** dt)
{
if (*dt)
{
NRT_FREE(*dt);
*dt = NULL;
}
}
NRTAPI(void) nrt_ListNode_destruct(nrt_ListNode ** this_node)
{
if (*this_node)
{
NRT_FREE(*this_node);
*this_node = NULL;
}
}
NRTAPI(void) nrt_List_destruct(nrt_List ** this_list)
{
NRT_DATA *data;
if (*this_list)
{
/* Destroy each node in our list. */
while (!nrt_List_isEmpty(*this_list))
{
/* Pop one off the back and delete it */
data = nrt_List_popBack(*this_list);
/* delete it */
if (data)
NRT_FREE(data);
}
NRT_FREE(*this_list);
*this_list = NULL;
}
}
NRTAPI(nrt_DateTime *) nrt_DateTime_fromString(const char *string,
const char *format,
nrt_Error * error)
{
struct tm t;
nrt_DateTime *dateTime = NULL;
double millis = 0.0;
/* NOTE: _NRT_strptime() does not use the tm_isdst flag at all. */
t.tm_isdst = -1;
if (!_NRT_strptime(string, format, &t, &millis))
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Unknown error caused by the call to strptime with string [%s] and format string [%s]",
string, format);
return NULL;
}
/* Create a DateTime object */
dateTime = (nrt_DateTime *) NRT_MALLOC(sizeof(nrt_DateTime));
if (!dateTime)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NULL;
}
/* Initialize it from the tm struct
* TODO: Update _NRT_strptime() to just use a DateTime directly */
dateTime->year = t.tm_year + 1900;
/* 0-based so add 1 */
dateTime->month = t.tm_mon + 1;
dateTime->dayOfMonth = t.tm_mday;
dateTime->dayOfWeek = t.tm_wday + 1;
dateTime->dayOfYear = t.tm_yday + 1;
dateTime->hour = t.tm_hour;
dateTime->minute = t.tm_min;
dateTime->second = t.tm_sec + millis / 1000.0;
/* Compute the # of milliseconds */
if (!nrt_DateTime_updateMillis(dateTime, error))
{
NRT_FREE(dateTime);
return NULL;
}
return dateTime;
}
NRTAPI(NRT_BOOL) nrt_DLL_unload(nrt_DLL * dll, nrt_Error * error)
{
if (dll->lib)
{
assert(dll->libname);
NRT_FREE(dll->libname);
dll->libname = NULL;
if (dlclose(dll->lib) != 0)
{
nrt_Error_init(error, dlerror(), NRT_CTXT, NRT_ERR_UNLOADING_DLL);
return NRT_FAILURE;
}
dll->lib = NULL;
}
return NRT_SUCCESS;
}
nitf_IOInterface* MemoryIO::create(void* buffer,
size_t size,
bool adopt) throw(nitf::NITFException)
{
nitf_Error error;
nitf_IOInterface* const interface = nitf_BufferAdapter_construct(
static_cast<char*>(buffer), size, adopt, &error);
if (!interface)
{
if (adopt)
{
// It's our job to free this now
NRT_FREE(buffer);
}
throw nitf::NITFException(&error);
}
return interface;
}
NRTAPI(NRT_BOOL) nrt_DLL_load(nrt_DLL * dll, const char *libname,
nrt_Error * error)
{
dll->libname = (char *) NRT_MALLOC(strlen(libname) + 1);
if (!dll->libname)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NRT_FAILURE;
}
strcpy(dll->libname, libname);
dll->lib = dlopen(libname, RTLD_LAZY);
if (!dll->lib)
{
nrt_Error_init(error, dlerror(), NRT_CTXT, NRT_ERR_LOADING_DLL);
NRT_FREE(dll->libname);
dll->libname = NULL;
return NRT_FAILURE;
}
return NRT_SUCCESS;
}
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)
{
int rc = 0;
nrt_Error error;
nrt_IOHandle handle;
j2k_Reader *reader = NULL;
j2k_Container *container = NULL;
int argIt = 0;
char *fname = NULL;
nrt_Uint32 tileX = 0;
nrt_Uint32 tileY = 0;
nrt_Uint32 bufSize;
nrt_Uint8 *buf = NULL;
for (argIt = 1; argIt < argc; ++argIt)
{
if (strcmp(argv[argIt], "--x") == 0)
{
if (argIt >= argc - 1)
goto CATCH_ERROR;
tileX = atoi(argv[++argIt]);
}
else if (strcmp(argv[argIt], "--y") == 0)
{
if (argIt >= argc - 1)
goto CATCH_ERROR;
tileY = atoi(argv[++argIt]);
}
else if (!fname)
{
fname = argv[argIt];
}
}
if (!fname)
{
printf("Usage: %s [--x --y] <j2k-file>\n", argv[0]);
goto CATCH_ERROR;
}
if (!(reader = j2k_Reader_open(fname, &error)))
goto CATCH_ERROR;
if (!(container = j2k_Reader_getContainer(reader, &error)))
goto CATCH_ERROR;
if ((bufSize = j2k_Reader_readTile(reader, tileX, tileY, &buf, &error)) == 0)
{
goto CATCH_ERROR;
}
if (!writeFile(container, tileX, tileY, buf, bufSize, &error))
{
goto CATCH_ERROR;
}
goto CLEANUP;
CATCH_ERROR:
{
nrt_Error_print(&error, stdout, "Exiting...");
rc = 1;
}
CLEANUP:
{
if (reader)
j2k_Reader_destruct(&reader);
if (buf)
NRT_FREE(buf);
}
return rc;
}
NRTAPI(NRT_BOOL) nrt_DateTime_formatMillis(double millis, const char *format,
char *outBuf, size_t maxSize,
nrt_Error * error)
{
time_t timeInSeconds;
double fractSeconds;
struct tm t;
char *newFmtString = NULL;
const char *endString = NULL;
size_t begStringLen = 0;
size_t formatLength;
size_t startIndex = 0;
size_t i, j;
NRT_BOOL found = 0;
timeInSeconds = (time_t) (millis / 1000);
t = *gmtime(&timeInSeconds);
fractSeconds = (millis / 1000.0) - timeInSeconds;
/* Search for "%...S" string */
formatLength = strlen(format);
for (i = 0; i < formatLength && !found; ++i)
{
if (format[i] == '%')
{
startIndex = i;
for (j = startIndex + 1; j < formatLength; ++j)
{
if (format[j] == '%')
{
break;
}
if (format[j] == 'S')
{
found = 1;
formatLength = j - startIndex + 1;
begStringLen = startIndex;
endString = format + j + 1;
}
}
}
}
/* If we found a "%...S" string, parse it */
/* to find out how many decimal places to use */
if (found)
{
int decimalPlaces = 0;
/* Figure out how many decimal places we need... */
for (i = startIndex + 1; i < startIndex + (formatLength - 1); ++i)
{
if (format[i] == '.')
{
/* The digits that follow should be */
/* the number of decimal places */
sscanf(format + i + 1, "%d", &decimalPlaces);
}
}
if (decimalPlaces > 0)
{
char buf[256];
size_t newFmtLen = 0;
size_t bufIdx = 0;
size_t endStringLen = endString ? strlen(endString) : 0;
newFmtLen = begStringLen + 1;
newFmtString = (char *) NRT_MALLOC(newFmtLen);
if (!newFmtString)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(newFmtString, 0, newFmtLen);
if (begStringLen > 0)
{
/* do the first part of the format */
strncpy(newFmtString, format, begStringLen);
if (strftime(outBuf, maxSize, newFmtString, &t) == 0)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Unknown error caused by the call to strftime with format string: [%s]",
format);
goto CATCH_ERROR;
}
bufIdx = strlen(outBuf);
}
/* do the seconds - separately */
memset(buf, 0, 256);
if (strftime(buf, 256, "%S", &t) == 0)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Unknown error caused by the call to strftime with format string: [%s]",
format);
goto CATCH_ERROR;
}
if (strlen(buf) + bufIdx + 1 > maxSize)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Format string will cause buffer to overflow: [%s]",
format);
goto CATCH_ERROR;
}
/* tack it on the end */
strcpy(outBuf + bufIdx, buf);
bufIdx = strlen(outBuf);
memset(buf, 0, 256);
NRT_SNPRINTF(buf, 256, "%.*f", decimalPlaces, fractSeconds);
if (strlen(buf) + bufIdx + 1 > maxSize)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Format string will cause buffer to overflow: [%s]",
format);
goto CATCH_ERROR;
}
/* tack on the fractional seconds - spare the leading 0 */
strcpy(outBuf + bufIdx, buf + 1);
bufIdx = strlen(outBuf);
if (endStringLen > 0)
{
/* tack on the end part */
memset(buf, 0, 256);
if (strftime(buf, 256, endString, &t) == 0)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Unknown error caused by the call to strftime with format string: [%s]",
format);
goto CATCH_ERROR;
}
if (strlen(buf) + bufIdx + 1 > maxSize)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Format string will cause buffer to overflow: [%s]",
format);
goto CATCH_ERROR;
}
strcpy(outBuf + bufIdx, buf);
}
}
}
if (newFmtString == NULL)
{
if (strftime
(outBuf, maxSize, newFmtString != NULL ? newFmtString : format,
&t) == 0)
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Unknown error caused by the call to strftime with format string: [%s]",
newFmtString != NULL ? newFmtString : format);
goto CATCH_ERROR;
}
}
else
NRT_FREE(newFmtString);
return NRT_SUCCESS;
CATCH_ERROR:
if (newFmtString)
NRT_FREE(newFmtString);
return NRT_FAILURE;
}
