corrade-vassal – Rev 1

?pathlinks?

Blame – Last modification – View Log – Download

// This is the main DLL file.

#include "dotnet.h"
extern "C" {
#include "../libopenjpeg/openjpeg.h"
}
#include <algorithm>

bool DotNetAllocEncoded64(MarshalledImage* image)
{
        return DotNetAllocEncoded(image);
}

bool DotNetAllocEncoded(MarshalledImage* image)
{
        DotNetFree(image);

        try
        {
                image->encoded = new unsigned char[image->length];
                image->decoded = 0;
        }
        catch (...)
        {
                return false;
        }

        return true;
}
bool DotNetAllocDecoded64(MarshalledImage* image)
{
        return DotNetAllocDecoded(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;
        }

        return true;
}
void DotNetFree64(MarshalledImage* image)
{
        DotNetFree(image);
}

void DotNetFree(MarshalledImage* image)
{
        if (image->encoded != 0) delete[] image->encoded;
        if (image->decoded != 0) delete[] image->decoded;
}

bool DotNetEncode64(MarshalledImage* image, bool lossless)
{
        return DotNetEncode(image, lossless);
}

bool DotNetEncode(MarshalledImage* image, bool lossless)
{
        try
        {
                opj_cparameters cparameters;
                opj_set_default_encoder_parameters(&cparameters);
                cparameters.cp_disto_alloc = 1;

                if (lossless)
                {
                        cparameters.tcp_numlayers = 1;
                        cparameters.tcp_rates[0] = 0;
                }
                else
                {
                        cparameters.tcp_numlayers = 5;
                        cparameters.tcp_rates[0] = 1920;
                        cparameters.tcp_rates[1] = 480;
                        cparameters.tcp_rates[2] = 120;
                        cparameters.tcp_rates[3] = 30;
                        cparameters.tcp_rates[4] = 10;
                        cparameters.irreversible = 1;
                        if (image->components >= 3)
                        {
                                cparameters.tcp_mct = 1;
                        }
                }

                cparameters.cp_comment = (char*)"";

                opj_image_comptparm comptparm[5];

                for (int i = 0; i < image->components; i++)
                {
                        comptparm[i].bpp = 8;
                        comptparm[i].prec = 8;
                        comptparm[i].sgnd = 0;
                        comptparm[i].dx = 1;
                        comptparm[i].dy = 1;
                        comptparm[i].x0 = 0;
                        comptparm[i].y0 = 0;
                        comptparm[i].w = image->width;
                        comptparm[i].h = image->height;
                }

                opj_image_t* jp2_image = opj_image_create(image->components, comptparm, CLRSPC_SRGB);
                if (jp2_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, jp2_image->comps[i].data);
                
                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, cio, jp2_image, cparameters.index))
                        return false;

                image->length = cio_tell(cio);
                image->encoded = new unsigned char[image->length];
                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;
        }

        catch (...)
        {
                return false;
        }
}

bool DotNetDecode64(MarshalledImage* image)
{
        return DotNetDecode(image);
}

bool DotNetDecode(MarshalledImage* image)
{
        opj_dparameters dparameters;
        
        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(dinfo, cio); // decode happens here
                if (jp2_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];
                
                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;
        }
}
bool DotNetDecodeWithInfo64(MarshalledImage* image)
{
        return DotNetDecodeWithInfo(image);
}

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