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.
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.
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
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.
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.
39 #include "opj_apps_config.h"
52 #define PNG_MAGIC "\x89PNG\x0d\x0a\x1a\x0a"
54 /* PNG allows bits per sample: 1, 2, 4, 8, 16 */
57 static void convert_16u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
60 for (i = 0; i < length; i++) {
61 OPJ_INT32 val0 = *pSrc++;
62 OPJ_INT32 val1 = *pSrc++;
63 pDst[i] = val0 << 8 | val1;
67 opj_image_t *pngtoimage(const char *read_idf, opj_cparameters_t * params)
69 png_structp png = NULL;
70 png_infop info = NULL;
72 int bit_depth, interlace_type,compression_type, filter_type;
74 png_uint_32 width, height = 0U;
77 OPJ_BYTE** rows = NULL;
78 OPJ_INT32* row32s = NULL;
80 opj_image_t *image = NULL;
81 opj_image_cmptparm_t cmptparm[4];
84 convert_XXx32s_C1R cvtXXTo32s = NULL;
85 convert_32s_CXPX cvtCxToPx = NULL;
88 if((reader = fopen(read_idf, "rb")) == NULL)
90 fprintf(stderr,"pngtoimage: can not open %s\n",read_idf);
94 if(fread(sigbuf, 1, MAGIC_SIZE, reader) != MAGIC_SIZE
95 || memcmp(sigbuf, PNG_MAGIC, MAGIC_SIZE) != 0)
97 fprintf(stderr,"pngtoimage: %s is no valid PNG file\n",read_idf);
101 if((png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
102 NULL, NULL, NULL)) == NULL)
104 if((info = png_create_info_struct(png)) == NULL)
107 if(setjmp(png_jmpbuf(png)))
110 png_init_io(png, reader);
111 png_set_sig_bytes(png, MAGIC_SIZE);
113 png_read_info(png, info);
115 if(png_get_IHDR(png, info, &width, &height,
116 &bit_depth, &color_type, &interlace_type,
117 &compression_type, &filter_type) == 0)
121 * expand paletted images to RGB, expand grayscale images of
122 * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
125 if(color_type == PNG_COLOR_TYPE_PALETTE) {
129 if(png_get_valid(png, info, PNG_INFO_tRNS)) {
132 /* We might wan't to expand background */
134 if(png_get_valid(png, info, PNG_INFO_bKGD)) {
136 png_get_bKGD(png, info, &bgnd);
137 png_set_background(png, bgnd, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
141 if( !png_get_gAMA(png, info, &gamma))
144 /* we're not displaying but converting, screen gamma == 1.0 */
145 png_set_gamma(png, 1.0, gamma);
147 png_read_update_info(png, info);
149 color_type = png_get_color_type(png, info);
151 switch (color_type) {
152 case PNG_COLOR_TYPE_GRAY:
155 case PNG_COLOR_TYPE_GRAY_ALPHA:
158 case PNG_COLOR_TYPE_RGB:
161 case PNG_COLOR_TYPE_RGB_ALPHA:
165 fprintf(stderr,"pngtoimage: colortype %d is not supported\n", color_type);
168 cvtCxToPx = convert_32s_CXPX_LUT[nr_comp];
169 bit_depth = png_get_bit_depth(png, info);
176 cvtXXTo32s = convert_XXu32s_C1R_LUT[bit_depth];
178 case 16: /* 16 bpp is specific to PNG */
179 cvtXXTo32s = convert_16u32s_C1R;
182 fprintf(stderr,"pngtoimage: bit depth %d is not supported\n", bit_depth);
187 rows = (OPJ_BYTE**)calloc(height+1, sizeof(OPJ_BYTE*));
188 for(i = 0; i < height; ++i)
189 rows[i] = (OPJ_BYTE*)malloc(png_get_rowbytes(png,info));
191 png_read_image(png, rows);
194 memset(cmptparm, 0, sizeof(cmptparm));
195 for(i = 0; i < nr_comp; ++i)
197 cmptparm[i].prec = (OPJ_UINT32)bit_depth;
198 /* bits_per_pixel: 8 or 16 */
199 cmptparm[i].bpp = (OPJ_UINT32)bit_depth;
200 cmptparm[i].sgnd = 0;
201 cmptparm[i].dx = (OPJ_UINT32)params->subsampling_dx;
202 cmptparm[i].dy = (OPJ_UINT32)params->subsampling_dy;
203 cmptparm[i].w = (OPJ_UINT32)width;
204 cmptparm[i].h = (OPJ_UINT32)height;
207 image = opj_image_create(nr_comp, &cmptparm[0], (nr_comp > 2U) ? OPJ_CLRSPC_SRGB : OPJ_CLRSPC_GRAY);
208 if(image == NULL) goto fin;
209 image->x0 = (OPJ_UINT32)params->image_offset_x0;
210 image->y0 = (OPJ_UINT32)params->image_offset_y0;
211 image->x1 = (OPJ_UINT32)(image->x0 + (width - 1) * (OPJ_UINT32)params->subsampling_dx + 1 + image->x0);
212 image->y1 = (OPJ_UINT32)(image->y0 + (height - 1) * (OPJ_UINT32)params->subsampling_dy + 1 + image->y0);
214 row32s = malloc((size_t)width * nr_comp * sizeof(OPJ_INT32));
215 if(row32s == NULL) goto fin;
217 /* Set alpha channel */
218 image->comps[nr_comp-1U].alpha = 1U - (nr_comp & 1U);
220 for(i = 0; i < nr_comp; i++)
222 planes[i] = image->comps[i].data;
225 for(i = 0; i < height; ++i)
227 cvtXXTo32s(rows[i], row32s, (OPJ_SIZE_T)width * nr_comp);
228 cvtCxToPx(row32s, planes, width);
237 for(i = 0; i < height; ++i)
245 png_destroy_read_struct(&png, &info, NULL);
254 static void convert_32s16u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
257 for (i = 0; i < length; i++) {
258 OPJ_UINT32 val = (OPJ_UINT32)pSrc[i];
259 *pDst++ = (OPJ_BYTE)(val >> 8);
260 *pDst++ = (OPJ_BYTE)val;
263 int imagetopng(opj_image_t * image, const char *write_idf)
265 FILE * volatile writer = NULL;
266 png_structp png = NULL;
267 png_infop info = NULL;
268 png_bytep volatile row_buf = NULL;
269 int nr_comp, color_type;
272 OPJ_INT32 const* planes[4];
274 OPJ_INT32* volatile buffer32s = NULL;
276 volatile int fails = 1;
278 memset(&sig_bit, 0, sizeof(sig_bit));
279 prec = (int)image->comps[0].prec;
280 planes[0] = image->comps[0].data;
281 nr_comp = (int)image->numcomps;
286 for (i = 1; i < nr_comp; ++i) {
287 if (image->comps[0].dx != image->comps[i].dx) {
290 if (image->comps[0].dy != image->comps[i].dy) {
293 if (image->comps[0].prec != image->comps[i].prec) {
296 if (image->comps[0].sgnd != image->comps[i].sgnd) {
299 planes[i] = image->comps[i].data;
302 fprintf(stderr,"imagetopng: All components shall have the same subsampling, same bit depth, same sign.\n");
303 fprintf(stderr,"\tAborting\n");
306 for (i = 0; i < nr_comp; ++i) {
307 clip_component(&(image->comps[i]), image->comps[0].prec);
309 if(prec > 8 && prec < 16)
311 for (i = 0; i < nr_comp; ++i) {
312 scale_component(&(image->comps[i]), 16);
316 else if(prec < 8 && nr_comp > 1)/* GRAY_ALPHA, RGB, RGB_ALPHA */
318 for (i = 0; i < nr_comp; ++i) {
319 scale_component(&(image->comps[i]), 8);
322 } else if((prec > 1) && (prec < 8) && ((prec == 6) || ((prec & 1)==1))) { /* GRAY with non native precision */
323 if ((prec == 5) || (prec == 6)) {
328 for (i = 0; i < nr_comp; ++i) {
329 scale_component(&(image->comps[i]), (OPJ_UINT32)prec);
333 if(prec != 1 && prec != 2 && prec != 4 && prec != 8 && prec != 16)
335 fprintf(stderr,"imagetopng: can not create %s\n\twrong bit_depth %d\n", write_idf, prec);
339 writer = fopen(write_idf, "wb");
341 if(writer == NULL) return fails;
343 /* Create and initialize the png_struct with the desired error handler
344 * functions. If you want to use the default stderr and longjump method,
345 * you can supply NULL for the last three parameters. We also check that
346 * the library version is compatible with the one used at compile time,
347 * in case we are using dynamically linked libraries. REQUIRED.
349 png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
351 /*png_voidp user_error_ptr, user_error_fn, user_warning_fn); */
353 if(png == NULL) goto fin;
355 /* Allocate/initialize the image information data. REQUIRED
357 info = png_create_info_struct(png);
359 if(info == NULL) goto fin;
361 /* Set error handling. REQUIRED if you are not supplying your own
362 * error handling functions in the png_create_write_struct() call.
364 if(setjmp(png_jmpbuf(png))) goto fin;
366 /* I/O initialization functions is REQUIRED
368 png_init_io(png, writer);
370 /* Set the image information here. Width and height are up to 2^31,
371 * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
372 * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
373 * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
374 * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
375 * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
376 * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE.
381 * color_type == PNG_COLOR_TYPE_PALETTE && bit_depth > 8
382 * color_type == PNG_COLOR_TYPE_RGB && bit_depth < 8
383 * color_type == PNG_COLOR_TYPE_GRAY_ALPHA && bit_depth < 8
384 * color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8
387 png_set_compression_level(png, Z_BEST_COMPRESSION);
389 if(nr_comp >= 3) /* RGB(A) */
391 color_type = PNG_COLOR_TYPE_RGB;
392 sig_bit.red = sig_bit.green = sig_bit.blue = (png_byte)prec;
396 color_type = PNG_COLOR_TYPE_GRAY;
397 sig_bit.gray = (png_byte)prec;
399 if((nr_comp & 1) == 0) /* ALPHA */
401 color_type |= PNG_COLOR_MASK_ALPHA;
402 sig_bit.alpha = (png_byte)prec;
405 png_set_IHDR(png, info, image->comps[0].w, image->comps[0].h, prec, color_type,
406 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
408 png_set_sBIT(png, info, &sig_bit);
409 /* png_set_gamma(png, 2.2, 1./2.2); */
410 /* png_set_sRGB(png, info, PNG_sRGB_INTENT_PERCEPTUAL); */
411 png_write_info(png, info);
413 /* setup conversion */
415 OPJ_SIZE_T rowStride;
416 png_size_t png_row_size;
418 png_row_size = png_get_rowbytes(png, info);
419 rowStride = ((OPJ_SIZE_T)image->comps[0].w * (OPJ_SIZE_T)nr_comp * (OPJ_SIZE_T)prec + 7U) / 8U;
420 if (rowStride != (OPJ_SIZE_T)png_row_size) {
421 fprintf(stderr, "Invalid PNG row size\n");
424 row_buf = (png_bytep)malloc(png_row_size);
425 if (row_buf == NULL) {
426 fprintf(stderr, "Can't allocate memory for PNG row\n");
429 buffer32s = (OPJ_INT32*)malloc((OPJ_SIZE_T)image->comps[0].w * (OPJ_SIZE_T)nr_comp * sizeof(OPJ_INT32));
430 if (buffer32s == NULL) {
431 fprintf(stderr, "Can't allocate memory for interleaved 32s row\n");
438 OPJ_SIZE_T width= image->comps[0].w;
440 convert_32s_PXCX cvtPxToCx = convert_32s_PXCX_LUT[nr_comp];
441 convert_32sXXx_C1R cvt32sToPack = NULL;
442 OPJ_INT32 adjust = image->comps[0].sgnd ? 1 << (prec - 1) : 0;
443 png_bytep row_buf_cpy = row_buf;
444 OPJ_INT32* buffer32s_cpy = buffer32s;
451 cvt32sToPack = convert_32sXXu_C1R_LUT[prec];
454 cvt32sToPack = convert_32s16u_C1R;
461 for(y = 0; y < image->comps[0].h; ++y)
463 cvtPxToCx(planes, buffer32s_cpy, width, adjust);
464 cvt32sToPack(buffer32s_cpy, row_buf_cpy, width * (OPJ_SIZE_T)nr_comp);
465 png_write_row(png, row_buf_cpy);
473 png_write_end(png, info);
479 png_destroy_write_struct(&png, &info);
489 if(fails) (void)remove(write_idf); /* ignore return value */