src/bin/jp2/convertpng.c

   1 /*
   2  * The copyright in this software is being made available under the 2-clauses
   3  * BSD License, included below. This software may be subject to other third
   4  * party and contributor rights, including patent rights, and no such rights
   5  * are granted under this license.
   6  *
   7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   8  * Copyright (c) 2002-2014, Professor Benoit Macq
   9  * Copyright (c) 2001-2003, David Janssens
  10  * Copyright (c) 2002-2003, Yannick Verschueren
  11  * Copyright (c) 2003-2007, Francois-Olivier Devaux
  12  * Copyright (c) 2003-2014, Antonin Descampe
  13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  14  * Copyright (c) 2006-2007, Parvatha Elangovan
  15  * Copyright (c) 2015, Matthieu Darbois
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  */
  39 #include "opj_apps_config.h"
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45
  46 #include <zlib.h>
  47 #include <png.h>
  48
  49 #include "openjpeg.h"
  50 #include "convert.h"
  51
  52 #define PNG_MAGIC "\x89PNG\x0d\x0a\x1a\x0a"
  53 #define MAGIC_SIZE 8
  54 /* PNG allows bits per sample: 1, 2, 4, 8, 16 */
  55
  56
  57 static void convert_16u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
  58                                OPJ_SIZE_T length)
  59 {
  60     OPJ_SIZE_T i;
  61     for (i = 0; i < length; i++) {
  62         OPJ_INT32 val0 = *pSrc++;
  63         OPJ_INT32 val1 = *pSrc++;
  64         pDst[i] = val0 << 8 | val1;
  65     }
  66 }
  67
  68 opj_image_t *pngtoimage(const char *read_idf, opj_cparameters_t * params)
  69 {
  70     png_structp  png = NULL;
  71     png_infop    info = NULL;
  72     double gamma;
  73     int bit_depth, interlace_type, compression_type, filter_type;
  74     OPJ_UINT32 i;
  75     png_uint_32  width, height = 0U;
  76     int color_type;
  77     FILE *reader = NULL;
  78     OPJ_BYTE** rows = NULL;
  79     OPJ_INT32* row32s = NULL;
  80     /* j2k: */
  81     opj_image_t *image = NULL;
  82     opj_image_cmptparm_t cmptparm[4];
  83     OPJ_UINT32 nr_comp;
  84     OPJ_BYTE sigbuf[8];
  85     convert_XXx32s_C1R cvtXXTo32s = NULL;
  86     convert_32s_CXPX cvtCxToPx = NULL;
  87     OPJ_INT32* planes[4];
  88
  89     if ((reader = fopen(read_idf, "rb")) == NULL) {
  90         fprintf(stderr, "pngtoimage: can not open %s\n", read_idf);
  91         return NULL;
  92     }
  93
  94     if (fread(sigbuf, 1, MAGIC_SIZE, reader) != MAGIC_SIZE
  95             || memcmp(sigbuf, PNG_MAGIC, MAGIC_SIZE) != 0) {
  96         fprintf(stderr, "pngtoimage: %s is no valid PNG file\n", read_idf);
  97         goto fin;
  98     }
  99
 100     if ((png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
 101                                       NULL, NULL, NULL)) == NULL) {
 102         goto fin;
 103     }
 104     if ((info = png_create_info_struct(png)) == NULL) {
 105         goto fin;
 106     }
 107
 108     if (setjmp(png_jmpbuf(png))) {
 109         goto fin;
 110     }
 111
 112     png_init_io(png, reader);
 113     png_set_sig_bytes(png, MAGIC_SIZE);
 114
 115     png_read_info(png, info);
 116
 117     if (png_get_IHDR(png, info, &width, &height,
 118                      &bit_depth, &color_type, &interlace_type,
 119                      &compression_type, &filter_type) == 0) {
 120         goto fin;
 121     }
 122
 123     /* png_set_expand():
 124      * expand paletted images to RGB, expand grayscale images of
 125      * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
 126      * to alpha channels.
 127      */
 128     if (color_type == PNG_COLOR_TYPE_PALETTE) {
 129         png_set_expand(png);
 130     }
 131
 132     if (png_get_valid(png, info, PNG_INFO_tRNS)) {
 133         png_set_expand(png);
 134     }
 135     /* We might wan't to expand background */
 136     /*
 137     if(png_get_valid(png, info, PNG_INFO_bKGD)) {
 138         png_color_16p bgnd;
 139         png_get_bKGD(png, info, &bgnd);
 140         png_set_background(png, bgnd, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 141     }
 142     */
 143
 144     if (!png_get_gAMA(png, info, &gamma)) {
 145         gamma = 1.0;
 146     }
 147
 148     /* we're not displaying but converting, screen gamma == 1.0 */
 149     png_set_gamma(png, 1.0, gamma);
 150
 151     png_read_update_info(png, info);
 152
 153     color_type = png_get_color_type(png, info);
 154
 155     switch (color_type) {
 156     case PNG_COLOR_TYPE_GRAY:
 157         nr_comp = 1;
 158         break;
 159     case PNG_COLOR_TYPE_GRAY_ALPHA:
 160         nr_comp = 2;
 161         break;
 162     case PNG_COLOR_TYPE_RGB:
 163         nr_comp = 3;
 164         break;
 165     case PNG_COLOR_TYPE_RGB_ALPHA:
 166         nr_comp = 4;
 167         break;
 168     default:
 169         fprintf(stderr, "pngtoimage: colortype %d is not supported\n", color_type);
 170         goto fin;
 171     }
 172     cvtCxToPx = convert_32s_CXPX_LUT[nr_comp];
 173     bit_depth = png_get_bit_depth(png, info);
 174
 175     switch (bit_depth) {
 176     case 1:
 177     case 2:
 178     case 4:
 179     case 8:
 180         cvtXXTo32s = convert_XXu32s_C1R_LUT[bit_depth];
 181         break;
 182     case 16: /* 16 bpp is specific to PNG */
 183         cvtXXTo32s = convert_16u32s_C1R;
 184         break;
 185     default:
 186         fprintf(stderr, "pngtoimage: bit depth %d is not supported\n", bit_depth);
 187         goto fin;
 188     }
 189
 190
 191     rows = (OPJ_BYTE**)calloc(height + 1, sizeof(OPJ_BYTE*));
 192     if (rows == NULL) {
 193         fprintf(stderr, "pngtoimage: memory out\n");
 194         goto fin;
 195     }
 196     for (i = 0; i < height; ++i) {
 197         rows[i] = (OPJ_BYTE*)malloc(png_get_rowbytes(png, info));
 198         if (rows[i] == NULL) {
 199             fprintf(stderr, "pngtoimage: memory out\n");
 200             goto fin;
 201         }
 202     }
 203     png_read_image(png, rows);
 204
 205     /* Create image */
 206     memset(cmptparm, 0, sizeof(cmptparm));
 207     for (i = 0; i < nr_comp; ++i) {
 208         cmptparm[i].prec = (OPJ_UINT32)bit_depth;
 209         /* bits_per_pixel: 8 or 16 */
 210         cmptparm[i].bpp = (OPJ_UINT32)bit_depth;
 211         cmptparm[i].sgnd = 0;
 212         cmptparm[i].dx = (OPJ_UINT32)params->subsampling_dx;
 213         cmptparm[i].dy = (OPJ_UINT32)params->subsampling_dy;
 214         cmptparm[i].w = (OPJ_UINT32)width;
 215         cmptparm[i].h = (OPJ_UINT32)height;
 216     }
 217
 218     image = opj_image_create(nr_comp, &cmptparm[0],
 219                              (nr_comp > 2U) ? OPJ_CLRSPC_SRGB : OPJ_CLRSPC_GRAY);
 220     if (image == NULL) {
 221         goto fin;
 222     }
 223     image->x0 = (OPJ_UINT32)params->image_offset_x0;
 224     image->y0 = (OPJ_UINT32)params->image_offset_y0;
 225     image->x1 = (OPJ_UINT32)(image->x0 + (width  - 1) * (OPJ_UINT32)
 226                              params->subsampling_dx + 1 + image->x0);
 227     image->y1 = (OPJ_UINT32)(image->y0 + (height - 1) * (OPJ_UINT32)
 228                              params->subsampling_dy + 1 + image->y0);
 229
 230     row32s = (OPJ_INT32 *)malloc((size_t)width * nr_comp * sizeof(OPJ_INT32));
 231     if (row32s == NULL) {
 232         goto fin;
 233     }
 234
 235     /* Set alpha channel */
 236     image->comps[nr_comp - 1U].alpha = 1U - (nr_comp & 1U);
 237
 238     for (i = 0; i < nr_comp; i++) {
 239         planes[i] = image->comps[i].data;
 240     }
 241
 242     for (i = 0; i < height; ++i) {
 243         cvtXXTo32s(rows[i], row32s, (OPJ_SIZE_T)width * nr_comp);
 244         cvtCxToPx(row32s, planes, width);
 245         planes[0] += width;
 246         planes[1] += width;
 247         planes[2] += width;
 248         planes[3] += width;
 249     }
 250 fin:
 251     if (rows) {
 252         for (i = 0; i < height; ++i)
 253             if (rows[i]) {
 254                 free(rows[i]);
 255             }
 256         free(rows);
 257     }
 258     if (row32s) {
 259         free(row32s);
 260     }
 261     if (png) {
 262         png_destroy_read_struct(&png, &info, NULL);
 263     }
 264
 265     fclose(reader);
 266
 267     return image;
 268
 269 }/* pngtoimage() */
 270
 271
 272 static void convert_32s16u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 273                                OPJ_SIZE_T length)
 274 {
 275     OPJ_SIZE_T i;
 276     for (i = 0; i < length; i++) {
 277         OPJ_UINT32 val = (OPJ_UINT32)pSrc[i];
 278         *pDst++ = (OPJ_BYTE)(val >> 8);
 279         *pDst++ = (OPJ_BYTE)val;
 280     }
 281 }
 282 int imagetopng(opj_image_t * image, const char *write_idf)
 283 {
 284     FILE * volatile writer = NULL;
 285     png_structp png = NULL;
 286     png_infop info = NULL;
 287     png_bytep volatile row_buf = NULL;
 288     int nr_comp, color_type;
 289     volatile int prec;
 290     png_color_8 sig_bit;
 291     OPJ_INT32 const* planes[4];
 292     int i;
 293     OPJ_INT32* volatile buffer32s = NULL;
 294
 295     volatile int fails = 1;
 296
 297     memset(&sig_bit, 0, sizeof(sig_bit));
 298     prec = (int)image->comps[0].prec;
 299     planes[0] = image->comps[0].data;
 300     nr_comp = (int)image->numcomps;
 301
 302     if (nr_comp > 4) {
 303         nr_comp = 4;
 304     }
 305     for (i = 1; i < nr_comp; ++i) {
 306         if (image->comps[0].dx != image->comps[i].dx) {
 307             break;
 308         }
 309         if (image->comps[0].dy != image->comps[i].dy) {
 310             break;
 311         }
 312         if (image->comps[0].prec != image->comps[i].prec) {
 313             break;
 314         }
 315         if (image->comps[0].sgnd != image->comps[i].sgnd) {
 316             break;
 317         }
 318         planes[i] = image->comps[i].data;
 319     }
 320     if (i != nr_comp) {
 321         fprintf(stderr,
 322                 "imagetopng: All components shall have the same subsampling, same bit depth, same sign.\n");
 323         fprintf(stderr, "\tAborting\n");
 324         return 1;
 325     }
 326     for (i = 0; i < nr_comp; ++i) {
 327         clip_component(&(image->comps[i]), image->comps[0].prec);
 328     }
 329     if (prec > 8 && prec < 16) {
 330         for (i = 0; i < nr_comp; ++i) {
 331             scale_component(&(image->comps[i]), 16);
 332         }
 333         prec = 16;
 334     } else if (prec < 8 && nr_comp > 1) { /* GRAY_ALPHA, RGB, RGB_ALPHA */
 335         for (i = 0; i < nr_comp; ++i) {
 336             scale_component(&(image->comps[i]), 8);
 337         }
 338         prec = 8;
 339     } else if ((prec > 1) && (prec < 8) && ((prec == 6) ||
 340                                             ((prec & 1) == 1))) { /* GRAY with non native precision */
 341         if ((prec == 5) || (prec == 6)) {
 342             prec = 8;
 343         } else {
 344             prec++;
 345         }
 346         for (i = 0; i < nr_comp; ++i) {
 347             scale_component(&(image->comps[i]), (OPJ_UINT32)prec);
 348         }
 349     }
 350
 351     if (prec != 1 && prec != 2 && prec != 4 && prec != 8 && prec != 16) {
 352         fprintf(stderr, "imagetopng: can not create %s\n\twrong bit_depth %d\n",
 353                 write_idf, prec);
 354         return fails;
 355     }
 356
 357     writer = fopen(write_idf, "wb");
 358
 359     if (writer == NULL) {
 360         return fails;
 361     }
 362
 363     /* Create and initialize the png_struct with the desired error handler
 364      * functions.  If you want to use the default stderr and longjump method,
 365      * you can supply NULL for the last three parameters.  We also check that
 366      * the library version is compatible with the one used at compile time,
 367      * in case we are using dynamically linked libraries.  REQUIRED.
 368      */
 369     png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
 370                                   NULL, NULL, NULL);
 371     /*png_voidp user_error_ptr, user_error_fn, user_warning_fn); */
 372
 373     if (png == NULL) {
 374         goto fin;
 375     }
 376
 377     /* Allocate/initialize the image information data.  REQUIRED
 378      */
 379     info = png_create_info_struct(png);
 380
 381     if (info == NULL) {
 382         goto fin;
 383     }
 384
 385     /* Set error handling.  REQUIRED if you are not supplying your own
 386      * error handling functions in the png_create_write_struct() call.
 387      */
 388     if (setjmp(png_jmpbuf(png))) {
 389         goto fin;
 390     }
 391
 392     /* I/O initialization functions is REQUIRED
 393      */
 394     png_init_io(png, writer);
 395
 396     /* Set the image information here.  Width and height are up to 2^31,
 397      * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
 398      * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
 399      * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
 400      * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
 401      * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
 402      * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE.
 403      * REQUIRED
 404      *
 405      * ERRORS:
 406      *
 407      * color_type == PNG_COLOR_TYPE_PALETTE && bit_depth > 8
 408      * color_type == PNG_COLOR_TYPE_RGB && bit_depth < 8
 409      * color_type == PNG_COLOR_TYPE_GRAY_ALPHA && bit_depth < 8
 410      * color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8
 411      *
 412      */
 413     png_set_compression_level(png, Z_BEST_COMPRESSION);
 414
 415     if (nr_comp >= 3) { /* RGB(A) */
 416         color_type = PNG_COLOR_TYPE_RGB;
 417         sig_bit.red = sig_bit.green = sig_bit.blue = (png_byte)prec;
 418     } else { /* GRAY(A) */
 419         color_type = PNG_COLOR_TYPE_GRAY;
 420         sig_bit.gray = (png_byte)prec;
 421     }
 422     if ((nr_comp & 1) == 0) { /* ALPHA */
 423         color_type |= PNG_COLOR_MASK_ALPHA;
 424         sig_bit.alpha = (png_byte)prec;
 425     }
 426
 427     png_set_IHDR(png, info, image->comps[0].w, image->comps[0].h, prec, color_type,
 428                  PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,  PNG_FILTER_TYPE_BASE);
 429
 430     png_set_sBIT(png, info, &sig_bit);
 431     /* png_set_gamma(png, 2.2, 1./2.2); */
 432     /* png_set_sRGB(png, info, PNG_sRGB_INTENT_PERCEPTUAL); */
 433     png_write_info(png, info);
 434
 435     /* setup conversion */
 436     {
 437         OPJ_SIZE_T rowStride;
 438         png_size_t png_row_size;
 439
 440         png_row_size = png_get_rowbytes(png, info);
 441         rowStride = ((OPJ_SIZE_T)image->comps[0].w * (OPJ_SIZE_T)nr_comp *
 442                      (OPJ_SIZE_T)prec + 7U) / 8U;
 443         if (rowStride != (OPJ_SIZE_T)png_row_size) {
 444             fprintf(stderr, "Invalid PNG row size\n");
 445             goto fin;
 446         }
 447         row_buf = (png_bytep)malloc(png_row_size);
 448         if (row_buf == NULL) {
 449             fprintf(stderr, "Can't allocate memory for PNG row\n");
 450             goto fin;
 451         }
 452         buffer32s = (OPJ_INT32*)malloc((OPJ_SIZE_T)image->comps[0].w *
 453                                        (OPJ_SIZE_T)nr_comp * sizeof(OPJ_INT32));
 454         if (buffer32s == NULL) {
 455             fprintf(stderr, "Can't allocate memory for interleaved 32s row\n");
 456             goto fin;
 457         }
 458     }
 459
 460     /* convert */
 461     {
 462         OPJ_SIZE_T width = image->comps[0].w;
 463         OPJ_UINT32 y;
 464         convert_32s_PXCX cvtPxToCx = convert_32s_PXCX_LUT[nr_comp];
 465         convert_32sXXx_C1R cvt32sToPack = NULL;
 466         OPJ_INT32 adjust = image->comps[0].sgnd ? 1 << (prec - 1) : 0;
 467         png_bytep row_buf_cpy = row_buf;
 468         OPJ_INT32* buffer32s_cpy = buffer32s;
 469
 470         switch (prec) {
 471         case 1:
 472         case 2:
 473         case 4:
 474         case 8:
 475             cvt32sToPack = convert_32sXXu_C1R_LUT[prec];
 476             break;
 477         case 16:
 478             cvt32sToPack = convert_32s16u_C1R;
 479             break;
 480         default:
 481             /* never here */
 482             break;
 483         }
 484
 485         for (y = 0; y < image->comps[0].h; ++y) {
 486             cvtPxToCx(planes, buffer32s_cpy, width, adjust);
 487             cvt32sToPack(buffer32s_cpy, row_buf_cpy, width * (OPJ_SIZE_T)nr_comp);
 488             png_write_row(png, row_buf_cpy);
 489             planes[0] += width;
 490             planes[1] += width;
 491             planes[2] += width;
 492             planes[3] += width;
 493         }
 494     }
 495
 496     png_write_end(png, info);
 497
 498     fails = 0;
 499
 500 fin:
 501     if (png) {
 502         png_destroy_write_struct(&png, &info);
 503     }
 504     if (row_buf) {
 505         free(row_buf);
 506     }
 507     if (buffer32s) {
 508         free(buffer32s);
 509     }
 510     fclose(writer);
 511
 512     if (fails) {
 513         (void)remove(write_idf);    /* ignore return value */
 514     }
 515
 516     return fails;
 517 }/* imagetopng() */