* Removing unnecessary C++ wrappers from openjpeg-dotnet

* Added DotNetDecodeWithInfo() to openjpeg-dotnet to decode and gather additional data about the image
* Updating openjpeg.dotnet.dll windows binary. OSX, Linux, and Linux64 compiles needed again

git-svn-id: http://libopenmetaverse.googlecode.com/svn/trunk@2171 52acb1d6-8a22-11de-b505-999d5b087335
This commit is contained in:
John Hurliman
2008-08-27 02:36:28 +00:00
parent 565f604560
commit a14fdabe8b
3 changed files with 97 additions and 113 deletions

View File

@@ -7,102 +7,15 @@ extern "C" {
#include <algorithm>
struct image_wrapper
{
opj_image* image;
image_wrapper(int numcmpts, opj_image_cmptparm_t* cmptparms, OPJ_COLOR_SPACE clrspc)
{
image = opj_image_create(numcmpts, cmptparms, clrspc);
if (image == NULL)
throw "opj_image_create failed";
}
image_wrapper(opj_dinfo* dinfo, opj_cio* cio)
{
image = opj_decode(dinfo,cio);
if (image == NULL)
throw "opj_decode failed";
}
~image_wrapper()
{
opj_image_destroy(image);
}
};
struct cinfo_wrapper
{
opj_cinfo* cinfo;
cinfo_wrapper(CODEC_FORMAT format)
{
cinfo = opj_create_compress(format);
if (cinfo == NULL)
throw "opj_create_compress failed";
}
~cinfo_wrapper()
{
opj_destroy_compress(cinfo);
}
};
struct dinfo_wrapper
{
opj_dinfo* dinfo;
dinfo_wrapper(CODEC_FORMAT format)
{
dinfo = opj_create_decompress(format);
if (dinfo == NULL)
throw "opj_create_decompress failed";
}
~dinfo_wrapper()
{
opj_destroy_decompress(dinfo);
}
};
struct cio_wrapper
{
opj_cio* cio;
cio_wrapper(opj_cinfo* cinfo, unsigned char* buffer, int length)
{
cio = opj_cio_open((opj_common_ptr)cinfo,buffer,length);
if (cio == NULL)
throw "opj_cio_open failed";
}
cio_wrapper(opj_dinfo* dinfo, unsigned char* buffer, int length)
{
cio = opj_cio_open((opj_common_ptr)dinfo,buffer,length);
if (cio == NULL)
throw "opj_cio_open failed";
}
~cio_wrapper()
{
opj_cio_close(cio);
}
};
bool DotNetAllocEncoded(MarshalledImage* image)
{
DotNetFree(image);
try
{
image->encoded = new unsigned char[image->length];
image->decoded = 0;
}
catch (...)
{
return false;
@@ -113,12 +26,13 @@ bool DotNetAllocEncoded(MarshalledImage* image)
bool DotNetAllocDecoded(MarshalledImage* image)
{
DotNetFree(image);
try
{
image->decoded = new unsigned char[image->width * image->height * image->components];
image->encoded = 0;
}
catch (...)
{
return false;
@@ -179,27 +93,36 @@ bool DotNetEncode(MarshalledImage* image, bool lossless)
comptparm[i].h = image->height;
}
image_wrapper cimage(image->components,comptparm,CLRSPC_SRGB);
cimage.image->x0 = 0;
cimage.image->y0 = 0;
cimage.image->x1 = image->width;
cimage.image->y1 = image->height;
opj_image_t* jp2_image = opj_image_create(image->components, comptparm, CLRSPC_SRGB);
if (image == NULL)
throw "opj_image_create failed";
jp2_image->x0 = 0;
jp2_image->y0 = 0;
jp2_image->x1 = image->width;
jp2_image->y1 = image->height;
int n = image->width * image->height;
for (int i = 0; i < image->components; i++)
std::copy(image->decoded+i*n,image->decoded+(i+1)*n,cimage.image->comps[i].data);
std::copy(image->decoded + i * n, image->decoded + (i + 1) * n, jp2_image->comps[i].data);
cinfo_wrapper cinfo(CODEC_J2K);
opj_setup_encoder(cinfo.cinfo,&cparameters,cimage.image);
cio_wrapper cio(cinfo.cinfo,NULL,0);
opj_cinfo* cinfo = opj_create_compress(CODEC_J2K);
opj_setup_encoder(cinfo, &cparameters, jp2_image);
opj_cio* cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
if (cio == NULL)
throw "opj_cio_open failed";
if (!opj_encode(cinfo.cinfo,cio.cio,cimage.image,cparameters.index))
if (!opj_encode(cinfo, cio, jp2_image, cparameters.index))
return false;
image->length = cio_tell(cio.cio);
image->length = cio_tell(cio);
image->encoded = new unsigned char[image->length];
std::copy(cio.cio->buffer,cio.cio->buffer+image->length,image->encoded);
std::copy(cio->buffer, cio->buffer + image->length, image->encoded);
opj_image_destroy(jp2_image);
opj_destroy_compress(cinfo);
opj_cio_close(cio);
return true;
}
@@ -216,23 +139,78 @@ bool DotNetDecode(MarshalledImage* image)
try
{
opj_set_default_decoder_parameters(&dparameters);
dinfo_wrapper dinfo(CODEC_J2K);
opj_setup_decoder(dinfo.dinfo, &dparameters);
cio_wrapper cio(dinfo.dinfo,image->encoded,image->length);
image_wrapper cimage(dinfo.dinfo, cio.cio); // decode happens here
opj_dinfo_t* dinfo = opj_create_decompress(CODEC_J2K);
opj_setup_decoder(dinfo, &dparameters);
opj_cio* cio = opj_cio_open((opj_common_ptr)dinfo, image->encoded, image->length);
image->width = cimage.image->x1 - cimage.image->x0;
image->height = cimage.image->y1 - cimage.image->y0;
image->components = cimage.image->numcomps;
opj_image* jp2_image = opj_decode(dinfo, cio); // decode happens here
if (image == NULL)
throw "opj_decode failed";
image->width = jp2_image->x1 - jp2_image->x0;
image->height = jp2_image->y1 - jp2_image->y0;
image->components = jp2_image->numcomps;
int n = image->width * image->height;
image->decoded = new unsigned char[n*image->components];
image->decoded = new unsigned char[n * image->components];
for (int i = 0; i < image->components; i++)
std::copy(cimage.image->comps[i].data,cimage.image->comps[i].data+n,image->decoded+i*n);
std::copy(jp2_image->comps[i].data, jp2_image->comps[i].data + n, image->decoded + i * n);
opj_image_destroy(jp2_image);
opj_destroy_decompress(dinfo);
opj_cio_close(cio);
return true;
}
catch (...)
{
return false;
}
}
bool DotNetDecodeWithInfo(MarshalledImage* image)
{
opj_dparameters dparameters;
opj_codestream_info_t info;
try
{
opj_set_default_decoder_parameters(&dparameters);
opj_dinfo_t* dinfo = opj_create_decompress(CODEC_J2K);
opj_setup_decoder(dinfo, &dparameters);
opj_cio* cio = opj_cio_open((opj_common_ptr)dinfo, image->encoded, image->length);
opj_image* jp2_image = opj_decode_with_info(dinfo, cio, &info); // decode happens here
if (image == NULL)
throw "opj_decode failed";
// maximum number of decompositions
int max_numdecompos = 0;
for (int compno = 0; compno < info.numcomps; compno++)
{
if (max_numdecompos < info.numdecompos[compno])
max_numdecompos = info.numdecompos[compno];
}
image->width = jp2_image->x1 - jp2_image->x0;
image->height = jp2_image->y1 - jp2_image->y0;
image->layers = info.numlayers;
image->resolutions = max_numdecompos + 1;
image->components = info.numcomps;
image->packet_count = info.packno;
image->packets = info.tile->packet;
int n = image->width * image->height;
image->decoded = new unsigned char[n * image->components];
for (int i = 0; i < image->components; i++)
std::copy(jp2_image->comps[i].data, jp2_image->comps[i].data + n, image->decoded + i * n);
opj_image_destroy(jp2_image);
opj_destroy_decompress(dinfo);
opj_cio_close(cio);
return true;
}
catch (...)
{
return false;