| |
| /* pngwtran.c - transforms the data in a row for PNG writers |
| * |
| * Last changed in libpng 1.6.17 [(PENDING RELEASE)] |
| * Copyright (c) 1998-2015 Glenn Randers-Pehrson |
| * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
| * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
| * |
| * This code is released under the libpng license. |
| * For conditions of distribution and use, see the disclaimer |
| * and license in png.h |
| */ |
| |
| #include "pngpriv.h" |
| #define PNG_SRC_FILE PNG_SRC_FILE_pngwtran |
| |
| #ifdef PNG_WRITE_INTERLACING_SUPPORTED |
| /* Pick out the correct pixels for the interlace pass. |
| * The basic idea here is to go through the row with a source |
| * pointer and a destination pointer (sp and dp), and copy the |
| * correct pixels for the pass. As the row gets compacted, |
| * sp will always be >= dp, so we should never overwrite anything. |
| * See the default: case for the easiest code to understand. |
| */ |
| static void |
| png_do_write_interlace_lbd(png_transformp *transform, png_transform_controlp tc) |
| { |
| const png_const_structrp png_ptr = tc->png_ptr; |
| const unsigned int pass = png_ptr->pass; |
| const png_uint_32 row_width = tc->width; |
| const png_uint_32 output_width = PNG_PASS_COLS(row_width, pass); |
| png_uint_32 i = PNG_PASS_START_COL(pass); |
| |
| |
| png_debug(1, "in png_do_write_interlace"); |
| debug(!tc->init); |
| |
| /* The data can be used in place (tc->sp) if the width isn't changed or |
| * the first pixel in the output is the first in the input and there is |
| * only one pixel in the output; this covers the last pass (PNG pass 7, |
| * libpng 6) and PNG passes 1, 3 and 5 with narrow images. |
| */ |
| tc->width = output_width; |
| |
| if (row_width != output_width && (output_width != 1 || i > 0)) |
| { |
| /* For passes before the last the pixels must be picked from the input |
| * row (tc->sp) and placed into the output row (tc->dp). |
| */ |
| png_const_bytep sp = png_voidcast(png_const_bytep, tc->sp); |
| png_bytep dp = png_voidcast(png_bytep, tc->dp); |
| const unsigned int inc = PNG_PASS_COL_OFFSET(pass); |
| unsigned int B = (*transform)->args & 0x3; /* 0, 1 or 2 */ |
| |
| /* The row data will be moved, so do this now before 'dp' is advanced: |
| */ |
| tc->sp = dp; |
| |
| /* For pixels less than one byte wide the correct pixels have to be |
| * extracted from the input bytes. Because we are reading data in |
| * the application memory format we cannot rely on the PNG big |
| * endian order. Notice that this was apparently broken before |
| * 1.7.0. |
| * |
| * In libpng 1.7.0 libpng uses a classic bit-pump to optimize the |
| * extraction. In all passes before the last (6/7) no two pixels |
| * are adjacent in the input, so we are always extracting 1 bit. |
| * At present the code uses an 8-bit buffer to avoid coding for |
| * different byte sexes, but this could easily be changed. |
| * |
| * 'i' is the bit-index of bit in the input (sp[]), so, |
| * considering the 1-bit per pixel case, sp[i>>3] is the byte |
| * and the bit is bit (i&7) (0 lowest) on swapped (little endian) |
| * data or 7-(i&7) on PNG default (big-endian) data. |
| * |
| * Define these macros, where: |
| * |
| * B: the log2 bit depth (0, 1, 2 for 1bpp, 2bpp or 4bpp) of |
| * the data; this should be a constant. |
| * sp: the source pointer (sp) (a png_const_bytep) |
| * i: the pixel index in the input (png_uint_32) |
| * j: the bit index in the output (unsigned int) |
| * |
| * Unlike 'i', 'j' is interpreted directly; for LSB bytes it counts |
| * up, for MSB it counts down. |
| * |
| * NOTE: this could all be expanded to eliminate the code below by |
| * the time honoured copy'n'paste into three separate functions. This |
| * might be worth doing in the future. |
| */ |
| # define PIXEL_MASK ((1U << (1<<B))-1U) |
| # define BIT_MASK ((1U << (3-(B)))-1U) /* within a byte */ |
| # define SP_BYTE (sp[i>>(3-(B))]) /* byte to use */ |
| # define SP_OFFSET_LSB ((BIT_MASK & i) << (B)) |
| # define SP_OFFSET_MSB ((BIT_MASK & ~i) << (B)) |
| # define SP_PIXEL(sex) ((SP_BYTE >> SP_OFFSET_ ## sex) & PIXEL_MASK) |
| { |
| unsigned int j; |
| unsigned int d; |
| |
| # ifdef PNG_WRITE_PACKSWAP_SUPPORTED |
| if (tc->format & PNG_FORMAT_FLAG_SWAPPED) |
| for (j = 0, d = 0; i < row_width; i += inc) |
| { /* little-endian */ |
| d |= SP_PIXEL(LSB) << j; |
| j += 1<<B; |
| if (j == 8) *dp++ = png_check_byte(png_ptr, d), j = 0, d = 0; |
| } |
| |
| else |
| # endif /* WRITE_PACKSWAP */ |
| for (j = 8, d = 0; i < row_width; i += inc) |
| { /* big-endian */ |
| j -= 1<<B; |
| d |= SP_PIXEL(MSB) << j; |
| if (j == 0) *dp++ = png_check_byte(png_ptr, d), j = 8, d = 0; |
| } |
| |
| /* The end condition: if j is not 0 the last byte was not |
| * written: |
| */ |
| if (j != 0) *dp = png_check_byte(png_ptr, d); |
| } |
| # undef PIXEL_MASK |
| # undef BIT_MASK |
| # undef SP_BYTE |
| # undef SP_OFFSET_MSB |
| # undef SP_OFFSET_LSB |
| # undef SP_PIXEL |
| } |
| |
| /* The transform is removed on the last pass. It can be removed earlier |
| * in other cases if the row width (the image width) is only 1, however |
| * this does not seem worth the overhead to check; PNG pass 5(4) happens |
| * if there are just three rows. |
| */ |
| else /* the source can be used in place */ if (pass == 6) |
| (*transform)->fn = NULL; /* remove me to caller */ |
| } |
| |
| static void |
| png_do_write_interlace_byte(png_transformp *transform, |
| png_transform_controlp tc) |
| { |
| const png_const_structrp png_ptr = tc->png_ptr; |
| const unsigned int pass = png_ptr->pass; |
| const png_uint_32 row_width = tc->width; |
| const png_uint_32 output_width = PNG_PASS_COLS(row_width, pass); |
| png_uint_32 i = PNG_PASS_START_COL(pass); |
| |
| png_debug(1, "in png_do_write_interlace"); |
| debug(!tc->init); |
| |
| /* The data can be used in place (tc->sp) if the width isn't changed or |
| * the first pixel in the output is the first in the input and there is |
| * only one pixel in the output; this covers the last pass (PNG pass 7, |
| * libpng 6) and PNG passes 1, 3 and 5 with narrow images. |
| */ |
| tc->width = output_width; |
| |
| if (row_width != output_width && (output_width != 1 || i > 0)) |
| { |
| /* For passes before the last the pixels must be picked from the input |
| * row (tc->sp) and placed into the output row (tc->dp). |
| */ |
| png_const_bytep sp = png_voidcast(png_const_bytep, tc->sp); |
| png_bytep dp = png_voidcast(png_bytep, tc->dp); |
| const unsigned int inc = PNG_PASS_COL_OFFSET(pass); |
| unsigned int cbytes = (*transform)->args; |
| |
| /* The row data will be moved, so do this now before 'dp' is advanced: |
| */ |
| tc->sp = dp; |
| |
| /* Loop through the input copying each pixel to the correct place |
| * in the output. Note that the loop may be executed 0 times if |
| * this is called on a narrow image that does not contain this |
| * pass. |
| */ |
| for (sp += i * cbytes; i < row_width; |
| i += inc, sp += inc * cbytes, dp += cbytes) |
| if (dp != sp) /* cannot happen in practice */ |
| memcpy(dp, sp, cbytes); |
| } |
| |
| /* The transform is removed on the last pass. It can be removed earlier |
| * in other cases if the row width (the image width) is only 1, however |
| * this does not seem worth the overhead to check; PNG pass 5(4) happens |
| * if there are just three rows. |
| */ |
| else /* the source can be used in place */ if (pass == 6) |
| (*transform)->fn = NULL; /* remove me to caller */ |
| } |
| |
| static void |
| png_init_write_interlace(png_transformp *transform, png_transform_controlp tc) |
| { |
| # define png_ptr (tc->png_ptr) |
| |
| png_debug(1, "in png_do_write_interlace"); |
| debug(tc->init); |
| |
| /* Do nothing on PNG_TC_INIT_FORMAT because we don't change the format, bit |
| * depth or gamma of the data. |
| */ |
| if (tc->init == PNG_TC_INIT_FINAL) |
| { |
| png_transformp tf = *transform; |
| unsigned int pixel_depth = PNG_TC_PIXEL_DEPTH(*tc); |
| png_uint_16 B = 0; |
| |
| switch (pixel_depth) |
| { |
| case 4: /* B == 2 */ |
| ++B; |
| /* FALL THROUGH */ |
| case 2: /* B == 1 */ |
| ++B; |
| /* FALL THROUGH */ |
| case 1: /* B == 0 */ |
| /* This is the low bit depth case: */ |
| tf->args = B; |
| tf->fn = png_do_write_interlace_lbd; |
| break; |
| |
| default: |
| affirm((pixel_depth & 7) == 0); |
| pixel_depth >>= 3; |
| affirm(pixel_depth > 0 && pixel_depth <= 8); |
| tf->args = pixel_depth & 0xf; |
| tf->fn = png_do_write_interlace_byte; |
| break; |
| } |
| } |
| # undef png_ptr |
| } |
| |
| void /* PRIVATE */ |
| png_set_write_interlace(png_structrp png_ptr) |
| { |
| /* This is checked in the caller: */ |
| debug(png_ptr->interlaced == PNG_INTERLACE_ADAM7); |
| png_add_transform(png_ptr, 0, png_init_write_interlace, PNG_TR_INTERLACE); |
| } |
| #endif /* WRITE_INTERLACING */ |
| |
| #ifdef PNG_WRITE_PACK_SUPPORTED |
| /* Pack pixels into bytes. */ |
| static void |
| png_do_write_pack(png_transformp *transform, png_transform_controlp tc) |
| { |
| png_alloc_size_t rowbytes = PNG_TC_ROWBYTES(*tc); |
| png_const_bytep sp = png_voidcast(png_const_bytep, tc->sp); |
| png_const_bytep ep = png_upcast(png_const_bytep, tc->sp) + rowbytes; |
| png_bytep dp = png_voidcast(png_bytep, tc->dp); |
| |
| png_debug(1, "in png_do_pack"); |
| |
| # define png_ptr tc->png_ptr |
| |
| switch ((*transform)->args) |
| { |
| case 1: |
| { |
| unsigned int mask = 0x80, v = 0; |
| |
| while (sp < ep) |
| { |
| if (*sp++ != 0) |
| v |= mask; |
| |
| mask >>= 1; |
| |
| if (mask == 0) |
| { |
| mask = 0x80; |
| *dp++ = PNG_BYTE(v); |
| v = 0; |
| } |
| } |
| |
| if (mask != 0x80) |
| *dp++ = PNG_BYTE(v); |
| break; |
| } |
| |
| case 2: |
| { |
| unsigned int shift = 8, v = 0; |
| |
| while (sp < ep) |
| { |
| shift -= 2; |
| v |= (*sp++ & 0x3) << shift; |
| |
| if (shift == 0) |
| { |
| shift = 8; |
| *dp++ = PNG_BYTE(v); |
| v = 0; |
| } |
| } |
| |
| if (shift != 8) |
| *dp++ = PNG_BYTE(v); |
| break; |
| } |
| |
| case 4: |
| { |
| unsigned int shift = 8, v = 0; |
| |
| while (sp < ep) |
| { |
| shift -= 4; |
| v |= ((*sp++ & 0xf) << shift); |
| |
| if (shift == 0) |
| { |
| shift = 8; |
| *dp++ = PNG_BYTE(v); |
| v = 0; |
| } |
| } |
| |
| if (shift != 8) |
| *dp++ = PNG_BYTE(v); |
| break; |
| } |
| |
| default: |
| impossible("bit depth"); |
| } |
| |
| if ((tc->format & PNG_FORMAT_FLAG_COLORMAP) == 0 && |
| --(tc->range) == 0) |
| tc->format &= PNG_BIC_MASK(PNG_FORMAT_FLAG_RANGE); |
| |
| tc->bit_depth = (*transform)->args; |
| tc->sp = tc->dp; |
| # undef png_ptr |
| } |
| |
| void /* PRIVATE */ |
| png_init_write_pack(png_transformp *transform, png_transform_controlp tc) |
| { |
| # define png_ptr tc->png_ptr |
| debug(tc->init); |
| # undef png_ptr |
| |
| /* The init routine is called *forward* so the transform control we get has |
| * the required bit depth and the transform routine will increase it to 8 |
| * bits per channel. The code doesn't really care how many channels there |
| * are, but the only way to get a channel depth of less than 8 is to have |
| * just one channel. |
| */ |
| if (tc->bit_depth < 8) /* else no packing/unpacking */ |
| { |
| if (tc->init == PNG_TC_INIT_FINAL) |
| { |
| (*transform)->fn = png_do_write_pack; |
| /* Record this for the backwards run: */ |
| (*transform)->args = tc->bit_depth & 0xf; |
| } |
| |
| if ((tc->format & PNG_FORMAT_FLAG_COLORMAP) == 0) |
| { |
| tc->range++; |
| tc->format |= PNG_FORMAT_FLAG_RANGE; /* forwards: backwards cancels */ |
| } |
| |
| tc->bit_depth = 8; |
| } |
| |
| else /* the transform is not applicable */ |
| (*transform)->fn = NULL; |
| } |
| #endif /* WRITE_PACK */ |
