+static void set_default_parameters(opj_decompress_parameters* parameters)
+{
+ if (parameters) {
+ memset(parameters, 0, sizeof(opj_decompress_parameters));
+
+ /* default decoding parameters (command line specific) */
+ parameters->decod_format = -1;
+ parameters->cod_format = -1;
+
+ /* default decoding parameters (core) */
+ opj_set_default_decoder_parameters(&(parameters->core));
+ }
+}
+
+static void destroy_parameters(opj_decompress_parameters* parameters)
+{
+ if (parameters) {
+ if (parameters->precision) {
+ free(parameters->precision);
+ parameters->precision = NULL;
+ }
+ }
+}
+
+/* -------------------------------------------------------------------------- */
+
+static opj_image_t* convert_gray_to_rgb(opj_image_t* original)
+{
+ OPJ_UINT32 compno;
+ opj_image_t* l_new_image = NULL;
+ opj_image_cmptparm_t* l_new_components = NULL;
+
+ l_new_components = (opj_image_cmptparm_t*)malloc((original->numcomps + 2U) * sizeof(opj_image_cmptparm_t));
+ if (l_new_components == NULL) {
+ fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for RGB image!\n");
+ opj_image_destroy(original);
+ return NULL;
+ }
+
+ l_new_components[0].bpp = l_new_components[1].bpp = l_new_components[2].bpp = original->comps[0].bpp;
+ l_new_components[0].dx = l_new_components[1].dx = l_new_components[2].dx = original->comps[0].dx;
+ l_new_components[0].dy = l_new_components[1].dy = l_new_components[2].dy = original->comps[0].dy;
+ l_new_components[0].h = l_new_components[1].h = l_new_components[2].h = original->comps[0].h;
+ l_new_components[0].w = l_new_components[1].w = l_new_components[2].w = original->comps[0].w;
+ l_new_components[0].prec = l_new_components[1].prec = l_new_components[2].prec = original->comps[0].prec;
+ l_new_components[0].sgnd = l_new_components[1].sgnd = l_new_components[2].sgnd = original->comps[0].sgnd;
+ l_new_components[0].x0 = l_new_components[1].x0 = l_new_components[2].x0 = original->comps[0].x0;
+ l_new_components[0].y0 = l_new_components[1].y0 = l_new_components[2].y0 = original->comps[0].y0;
+
+ for(compno = 1U; compno < original->numcomps; ++compno) {
+ l_new_components[compno+2U].bpp = original->comps[compno].bpp;
+ l_new_components[compno+2U].dx = original->comps[compno].dx;
+ l_new_components[compno+2U].dy = original->comps[compno].dy;
+ l_new_components[compno+2U].h = original->comps[compno].h;
+ l_new_components[compno+2U].w = original->comps[compno].w;
+ l_new_components[compno+2U].prec = original->comps[compno].prec;
+ l_new_components[compno+2U].sgnd = original->comps[compno].sgnd;
+ l_new_components[compno+2U].x0 = original->comps[compno].x0;
+ l_new_components[compno+2U].y0 = original->comps[compno].y0;
+ }
+
+ l_new_image = opj_image_create(original->numcomps + 2U, l_new_components, OPJ_CLRSPC_SRGB);
+ free(l_new_components);
+ if (l_new_image == NULL) {
+ fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for RGB image!\n");
+ opj_image_destroy(original);
+ return NULL;
+ }
+
+ l_new_image->x0 = original->x0;
+ l_new_image->x1 = original->x1;
+ l_new_image->y0 = original->y0;
+ l_new_image->y1 = original->y1;
+
+ l_new_image->comps[0].factor = l_new_image->comps[1].factor = l_new_image->comps[2].factor = original->comps[0].factor;
+ l_new_image->comps[0].alpha = l_new_image->comps[1].alpha = l_new_image->comps[2].alpha = original->comps[0].alpha;
+ l_new_image->comps[0].resno_decoded = l_new_image->comps[1].resno_decoded = l_new_image->comps[2].resno_decoded = original->comps[0].resno_decoded;
+
+ memcpy(l_new_image->comps[0].data, original->comps[0].data, original->comps[0].w * original->comps[0].h * sizeof(OPJ_INT32));
+ memcpy(l_new_image->comps[1].data, original->comps[0].data, original->comps[0].w * original->comps[0].h * sizeof(OPJ_INT32));
+ memcpy(l_new_image->comps[2].data, original->comps[0].data, original->comps[0].w * original->comps[0].h * sizeof(OPJ_INT32));
+
+ for(compno = 1U; compno < original->numcomps; ++compno) {
+ l_new_image->comps[compno+2U].factor = original->comps[compno].factor;
+ l_new_image->comps[compno+2U].alpha = original->comps[compno].alpha;
+ l_new_image->comps[compno+2U].resno_decoded = original->comps[compno].resno_decoded;
+ memcpy(l_new_image->comps[compno+2U].data, original->comps[compno].data, original->comps[compno].w * original->comps[compno].h * sizeof(OPJ_INT32));
+ }
+ opj_image_destroy(original);
+ return l_new_image;
+}
+
+/* -------------------------------------------------------------------------- */
+
+static opj_image_t* upsample_image_components(opj_image_t* original)
+{
+ opj_image_t* l_new_image = NULL;
+ opj_image_cmptparm_t* l_new_components = NULL;
+ OPJ_BOOL l_upsample_need = OPJ_FALSE;
+ OPJ_UINT32 compno;
+
+ for (compno = 0U; compno < original->numcomps; ++compno) {
+ if (original->comps[compno].factor > 0U) {
+ fprintf(stderr, "ERROR -> opj_decompress: -upsample not supported with reduction\n");
+ opj_image_destroy(original);
+ return NULL;
+ }
+ if ((original->comps[compno].dx > 1U) || (original->comps[compno].dy > 1U)) {
+ l_upsample_need = OPJ_TRUE;
+ break;
+ }
+ }
+ if (!l_upsample_need) {
+ return original;
+ }
+ /* Upsample is needed */
+ l_new_components = (opj_image_cmptparm_t*)malloc(original->numcomps * sizeof(opj_image_cmptparm_t));
+ if (l_new_components == NULL) {
+ fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for upsampled components!\n");
+ opj_image_destroy(original);
+ return NULL;
+ }
+
+ for (compno = 0U; compno < original->numcomps; ++compno) {
+ opj_image_cmptparm_t* l_new_cmp = &(l_new_components[compno]);
+ opj_image_comp_t* l_org_cmp = &(original->comps[compno]);
+
+ l_new_cmp->bpp = l_org_cmp->bpp;
+ l_new_cmp->prec = l_org_cmp->prec;
+ l_new_cmp->sgnd = l_org_cmp->sgnd;
+ l_new_cmp->x0 = original->x0;
+ l_new_cmp->y0 = original->y0;
+ l_new_cmp->dx = 1;
+ l_new_cmp->dy = 1;
+ l_new_cmp->w = l_org_cmp->w; /* should be original->x1 - original->x0 for dx==1 */
+ l_new_cmp->h = l_org_cmp->h; /* should be original->y1 - original->y0 for dy==0 */
+
+ if (l_org_cmp->dx > 1U) {
+ l_new_cmp->w = original->x1 - original->x0;
+ }
+
+ if (l_org_cmp->dy > 1U) {
+ l_new_cmp->h = original->y1 - original->y0;
+ }
+ }
+
+ l_new_image = opj_image_create(original->numcomps, l_new_components, original->color_space);
+ free(l_new_components);
+ if (l_new_image == NULL) {
+ fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for upsampled components!\n");
+ opj_image_destroy(original);
+ return NULL;
+ }
+
+ l_new_image->x0 = original->x0;
+ l_new_image->x1 = original->x1;
+ l_new_image->y0 = original->y0;
+ l_new_image->y1 = original->y1;
+
+ for (compno = 0U; compno < original->numcomps; ++compno) {
+ opj_image_comp_t* l_new_cmp = &(l_new_image->comps[compno]);
+ opj_image_comp_t* l_org_cmp = &(original->comps[compno]);
+
+ l_new_cmp->factor = l_org_cmp->factor;
+ l_new_cmp->alpha = l_org_cmp->alpha;
+ l_new_cmp->resno_decoded = l_org_cmp->resno_decoded;
+
+ if ((l_org_cmp->dx > 1U) || (l_org_cmp->dy > 1U)) {
+ const OPJ_INT32* l_src = l_org_cmp->data;
+ OPJ_INT32* l_dst = l_new_cmp->data;
+ OPJ_UINT32 y;
+ OPJ_UINT32 xoff, yoff;
+
+ /* need to take into account dx & dy */
+ xoff = l_org_cmp->dx * l_org_cmp->x0 - original->x0;
+ yoff = l_org_cmp->dy * l_org_cmp->y0 - original->y0;
+ if ((xoff >= l_org_cmp->dx) || (yoff >= l_org_cmp->dy)) {
+ fprintf(stderr, "ERROR -> opj_decompress: Invalid image/component parameters found when upsampling\n");
+ opj_image_destroy(original);
+ opj_image_destroy(l_new_image);
+ return NULL;
+ }
+
+ for (y = 0U; y < yoff; ++y) {
+ memset(l_dst, 0U, l_new_cmp->w * sizeof(OPJ_INT32));
+ l_dst += l_new_cmp->w;
+ }
+
+ if(l_new_cmp->h > (l_org_cmp->dy - 1U)) { /* check subtraction overflow for really small images */
+ for (; y < l_new_cmp->h - (l_org_cmp->dy - 1U); y += l_org_cmp->dy) {
+ OPJ_UINT32 x, dy;
+ OPJ_UINT32 xorg;
+
+ xorg = 0U;
+ for (x = 0U; x < xoff; ++x) {
+ l_dst[x] = 0;
+ }
+ if (l_new_cmp->w > (l_org_cmp->dx - 1U)) { /* check subtraction overflow for really small images */
+ for (; x < l_new_cmp->w - (l_org_cmp->dx - 1U); x += l_org_cmp->dx, ++xorg) {
+ OPJ_UINT32 dx;
+ for (dx = 0U; dx < l_org_cmp->dx; ++dx) {
+ l_dst[x + dx] = l_src[xorg];
+ }
+ }
+ }
+ for (; x < l_new_cmp->w; ++x) {
+ l_dst[x] = l_src[xorg];
+ }
+ l_dst += l_new_cmp->w;
+
+ for (dy = 1U; dy < l_org_cmp->dy; ++dy) {
+ memcpy(l_dst, l_dst - l_new_cmp->w, l_new_cmp->w * sizeof(OPJ_INT32));
+ l_dst += l_new_cmp->w;
+ }
+ l_src += l_org_cmp->w;
+ }
+ }
+ if (y < l_new_cmp->h) {
+ OPJ_UINT32 x;
+ OPJ_UINT32 xorg;
+
+ xorg = 0U;
+ for (x = 0U; x < xoff; ++x) {
+ l_dst[x] = 0;
+ }
+ if (l_new_cmp->w > (l_org_cmp->dx - 1U)) { /* check subtraction overflow for really small images */
+ for (; x < l_new_cmp->w - (l_org_cmp->dx - 1U); x += l_org_cmp->dx, ++xorg) {
+ OPJ_UINT32 dx;
+ for (dx = 0U; dx < l_org_cmp->dx; ++dx) {
+ l_dst[x + dx] = l_src[xorg];
+ }
+ }
+ }
+ for (; x < l_new_cmp->w; ++x) {
+ l_dst[x] = l_src[xorg];
+ }
+ l_dst += l_new_cmp->w;
+ ++y;
+ for (; y < l_new_cmp->h; ++y) {
+ memcpy(l_dst, l_dst - l_new_cmp->w, l_new_cmp->w * sizeof(OPJ_INT32));
+ l_dst += l_new_cmp->w;
+ }
+ }
+ }
+ else {
+ memcpy(l_new_cmp->data, l_org_cmp->data, l_org_cmp->w * l_org_cmp->h * sizeof(OPJ_INT32));
+ }
+ }
+ opj_image_destroy(original);
+ return l_new_image;
+}
+