开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
pngwtran.c
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：17k
源码类别：

界面编程

开发平台：

Visual C++

pngwtran.c：源码内容
  2. /* pngwtran.c - transforms the data in a row for PNG writers
  3.  *
  4.  * Last changed in libpng 1.2.9 April 14, 2006
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2006 Glenn Randers-Pehrson
  7.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  8.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  9.  */
  11. #define PNG_INTERNAL
  12. #include "png.h"
  13. #ifdef PNG_WRITE_SUPPORTED
  15. /* Transform the data according to the user's wishes.  The order of
  16.  * transformations is significant.
  17.  */
  18. void /* PRIVATE */
  19. png_do_write_transformations(png_structp png_ptr)
  20. {
  21.    png_debug(1, "in png_do_write_transformations");
  23.    if (png_ptr == NULL)
  24.       return;
  26. #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
  27.    if (png_ptr->transformations & PNG_USER_TRANSFORM)
  28.       if (png_ptr->write_user_transform_fn != NULL)
  29.         (*(png_ptr->write_user_transform_fn)) /* user write transform function */
  30.           (png_ptr,                    /* png_ptr */
  31.            &(png_ptr->row_info),       /* row_info:     */
  32.              /*  png_uint_32 width;          width of row */
  33.              /*  png_uint_32 rowbytes;       number of bytes in row */
  34.              /*  png_byte color_type;        color type of pixels */
  35.              /*  png_byte bit_depth;         bit depth of samples */
  36.              /*  png_byte channels;          number of channels (1-4) */
  37.              /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
  38.            png_ptr->row_buf + 1);      /* start of pixel data for row */
  39. #endif
  40. #if defined(PNG_WRITE_FILLER_SUPPORTED)
  41.    if (png_ptr->transformations & PNG_FILLER)
  42.       png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
  43.          png_ptr->flags);
  44. #endif
  45. #if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  46.    if (png_ptr->transformations & PNG_PACKSWAP)
  47.       png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
  48. #endif
  49. #if defined(PNG_WRITE_PACK_SUPPORTED)
  50.    if (png_ptr->transformations & PNG_PACK)
  51.       png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
  52.          (png_uint_32)png_ptr->bit_depth);
  53. #endif
  54. #if defined(PNG_WRITE_SWAP_SUPPORTED)
  55.    if (png_ptr->transformations & PNG_SWAP_BYTES)
  56.       png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
  57. #endif
  58. #if defined(PNG_WRITE_SHIFT_SUPPORTED)
  59.    if (png_ptr->transformations & PNG_SHIFT)
  60.       png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
  61.          &(png_ptr->shift));
  62. #endif
  63. #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  64.    if (png_ptr->transformations & PNG_SWAP_ALPHA)
  65.       png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
  66. #endif
  67. #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  68.    if (png_ptr->transformations & PNG_INVERT_ALPHA)
  69.       png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
  70. #endif
  71. #if defined(PNG_WRITE_BGR_SUPPORTED)
  72.    if (png_ptr->transformations & PNG_BGR)
  73.       png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
  74. #endif
  75. #if defined(PNG_WRITE_INVERT_SUPPORTED)
  76.    if (png_ptr->transformations & PNG_INVERT_MONO)
  77.       png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
  78. #endif
  79. }
  81. #if defined(PNG_WRITE_PACK_SUPPORTED)
  82. /* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
  83.  * row_info bit depth should be 8 (one pixel per byte).  The channels
  84.  * should be 1 (this only happens on grayscale and paletted images).
  85.  */
  86. void /* PRIVATE */
  87. png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
  88. {
  89.    png_debug(1, "in png_do_pack");
  90.    if (row_info->bit_depth == 8 &&
  91. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  92.        row != NULL && row_info != NULL &&
  93. #endif
  94.       row_info->channels == 1)
  95.    {
  96.       switch ((int)bit_depth)
  97.       {
  98.          case 1:
  99.          {
  100.             png_bytep sp, dp;
  101.             int mask, v;
  102.             png_uint_32 i;
  103.             png_uint_32 row_width = row_info->width;
  105.             sp = row;
  106.             dp = row;
  107.             mask = 0x80;
  108.             v = 0;
  110.             for (i = 0; i < row_width; i++)
  111.             {
  112.                if (*sp != 0)
  113.                   v |= mask;
  114.                sp++;
  115.                if (mask > 1)
  116.                   mask >>= 1;
  117.                else
  118.                {
  119.                   mask = 0x80;
  120.                   *dp = (png_byte)v;
  121.                   dp++;
  122.                   v = 0;
  123.                }
  124.             }
  125.             if (mask != 0x80)
  126.                *dp = (png_byte)v;
  127.             break;
  128.          }
  129.          case 2:
  130.          {
  131.             png_bytep sp, dp;
  132.             int shift, v;
  133.             png_uint_32 i;
  134.             png_uint_32 row_width = row_info->width;
  136.             sp = row;
  137.             dp = row;
  138.             shift = 6;
  139.             v = 0;
  140.             for (i = 0; i < row_width; i++)
  141.             {
  142.                png_byte value;
  144.                value = (png_byte)(*sp & 0x03);
  145.                v |= (value << shift);
  146.                if (shift == 0)
  147.                {
  148.                   shift = 6;
  149.                   *dp = (png_byte)v;
  150.                   dp++;
  151.                   v = 0;
  152.                }
  153.                else
  154.                   shift -= 2;
  155.                sp++;
  156.             }
  157.             if (shift != 6)
  158.                *dp = (png_byte)v;
  159.             break;
  160.          }
  161.          case 4:
  162.          {
  163.             png_bytep sp, dp;
  164.             int shift, v;
  165.             png_uint_32 i;
  166.             png_uint_32 row_width = row_info->width;
  168.             sp = row;
  169.             dp = row;
  170.             shift = 4;
  171.             v = 0;
  172.             for (i = 0; i < row_width; i++)
  173.             {
  174.                png_byte value;
  176.                value = (png_byte)(*sp & 0x0f);
  177.                v |= (value << shift);
  179.                if (shift == 0)
  180.                {
  181.                   shift = 4;
  182.                   *dp = (png_byte)v;
  183.                   dp++;
  184.                   v = 0;
  185.                }
  186.                else
  187.                   shift -= 4;
  189.                sp++;
  190.             }
  191.             if (shift != 4)
  192.                *dp = (png_byte)v;
  193.             break;
  194.          }
  195.       }
  196.       row_info->bit_depth = (png_byte)bit_depth;
  197.       row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
  198.       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
  199.          row_info->width);
  200.    }
  201. }
  202. #endif
  204. #if defined(PNG_WRITE_SHIFT_SUPPORTED)
  205. /* Shift pixel values to take advantage of whole range.  Pass the
  206.  * true number of bits in bit_depth.  The row should be packed
  207.  * according to row_info->bit_depth.  Thus, if you had a row of
  208.  * bit depth 4, but the pixels only had values from 0 to 7, you
  209.  * would pass 3 as bit_depth, and this routine would translate the
  210.  * data to 0 to 15.
  211.  */
  212. void /* PRIVATE */
  213. png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
  214. {
  215.    png_debug(1, "in png_do_shift");
  216. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  217.    if (row != NULL && row_info != NULL &&
  218. #else
  219.    if (
  220. #endif
  221.       row_info->color_type != PNG_COLOR_TYPE_PALETTE)
  222.    {
  223.       int shift_start[4], shift_dec[4];
  224.       int channels = 0;
  226.       if (row_info->color_type & PNG_COLOR_MASK_COLOR)
  227.       {
  228.          shift_start[channels] = row_info->bit_depth - bit_depth->red;
  229.          shift_dec[channels] = bit_depth->red;
  230.          channels++;
  231.          shift_start[channels] = row_info->bit_depth - bit_depth->green;
  232.          shift_dec[channels] = bit_depth->green;
  233.          channels++;
  234.          shift_start[channels] = row_info->bit_depth - bit_depth->blue;
  235.          shift_dec[channels] = bit_depth->blue;
  236.          channels++;
  237.       }
  238.       else
  239.       {
  240.          shift_start[channels] = row_info->bit_depth - bit_depth->gray;
  241.          shift_dec[channels] = bit_depth->gray;
  242.          channels++;
  243.       }
  244.       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
  245.       {
  246.          shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
  247.          shift_dec[channels] = bit_depth->alpha;
  248.          channels++;
  249.       }
  251.       /* with low row depths, could only be grayscale, so one channel */
  252.       if (row_info->bit_depth < 8)
  253.       {
  254.          png_bytep bp = row;
  255.          png_uint_32 i;
  256.          png_byte mask;
  257.          png_uint_32 row_bytes = row_info->rowbytes;
  259.          if (bit_depth->gray == 1 && row_info->bit_depth == 2)
  260.             mask = 0x55;
  261.          else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
  262.             mask = 0x11;
  263.          else
  264.             mask = 0xff;
  266.          for (i = 0; i < row_bytes; i++, bp++)
  267.          {
  268.             png_uint_16 v;
  269.             int j;
  271.             v = *bp;
  272.             *bp = 0;
  273.             for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
  274.             {
  275.                if (j > 0)
  276.                   *bp |= (png_byte)((v << j) & 0xff);
  277.                else
  278.                   *bp |= (png_byte)((v >> (-j)) & mask);
  279.             }
  280.          }
  281.       }
  282.       else if (row_info->bit_depth == 8)
  283.       {
  284.          png_bytep bp = row;
  285.          png_uint_32 i;
  286.          png_uint_32 istop = channels * row_info->width;
  288.          for (i = 0; i < istop; i++, bp++)
  289.          {
  291.             png_uint_16 v;
  292.             int j;
  293.             int c = (int)(i%channels);
  295.             v = *bp;
  296.             *bp = 0;
  297.             for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
  298.             {
  299.                if (j > 0)
  300.                   *bp |= (png_byte)((v << j) & 0xff);
  301.                else
  302.                   *bp |= (png_byte)((v >> (-j)) & 0xff);
  303.             }
  304.          }
  305.       }
  306.       else
  307.       {
  308.          png_bytep bp;
  309.          png_uint_32 i;
  310.          png_uint_32 istop = channels * row_info->width;
  312.          for (bp = row, i = 0; i < istop; i++)
  313.          {
  314.             int c = (int)(i%channels);
  315.             png_uint_16 value, v;
  316.             int j;
  318.             v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));
  319.             value = 0;
  320.             for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
  321.             {
  322.                if (j > 0)
  323.                   value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
  324.                else
  325.                   value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
  326.             }
  327.             *bp++ = (png_byte)(value >> 8);
  328.             *bp++ = (png_byte)(value & 0xff);
  329.          }
  330.       }
  331.    }
  332. }
  333. #endif
  335. #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  336. void /* PRIVATE */
  337. png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
  338. {
  339.    png_debug(1, "in png_do_write_swap_alpha");
  340. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  341.    if (row != NULL && row_info != NULL)
  342. #endif
  343.    {
  344.       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  345.       {
  346.          /* This converts from ARGB to RGBA */
  347.          if (row_info->bit_depth == 8)
  348.          {
  349.             png_bytep sp, dp;
  350.             png_uint_32 i;
  351.             png_uint_32 row_width = row_info->width;
  352.             for (i = 0, sp = dp = row; i < row_width; i++)
  353.             {
  354.                png_byte save = *(sp++);
  355.                *(dp++) = *(sp++);
  356.                *(dp++) = *(sp++);
  357.                *(dp++) = *(sp++);
  358.                *(dp++) = save;
  359.             }
  360.          }
  361.          /* This converts from AARRGGBB to RRGGBBAA */
  362.          else
  363.          {
  364.             png_bytep sp, dp;
  365.             png_uint_32 i;
  366.             png_uint_32 row_width = row_info->width;
  368.             for (i = 0, sp = dp = row; i < row_width; i++)
  369.             {
  370.                png_byte save[2];
  371.                save[0] = *(sp++);
  372.                save[1] = *(sp++);
  373.                *(dp++) = *(sp++);
  374.                *(dp++) = *(sp++);
  375.                *(dp++) = *(sp++);
  376.                *(dp++) = *(sp++);
  377.                *(dp++) = *(sp++);
  378.                *(dp++) = *(sp++);
  379.                *(dp++) = save[0];
  380.                *(dp++) = save[1];
  381.             }
  382.          }
  383.       }
  384.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  385.       {
  386.          /* This converts from AG to GA */
  387.          if (row_info->bit_depth == 8)
  388.          {
  389.             png_bytep sp, dp;
  390.             png_uint_32 i;
  391.             png_uint_32 row_width = row_info->width;
  393.             for (i = 0, sp = dp = row; i < row_width; i++)
  394.             {
  395.                png_byte save = *(sp++);
  396.                *(dp++) = *(sp++);
  397.                *(dp++) = save;
  398.             }
  399.          }
  400.          /* This converts from AAGG to GGAA */
  401.          else
  402.          {
  403.             png_bytep sp, dp;
  404.             png_uint_32 i;
  405.             png_uint_32 row_width = row_info->width;
  407.             for (i = 0, sp = dp = row; i < row_width; i++)
  408.             {
  409.                png_byte save[2];
  410.                save[0] = *(sp++);
  411.                save[1] = *(sp++);
  412.                *(dp++) = *(sp++);
  413.                *(dp++) = *(sp++);
  414.                *(dp++) = save[0];
  415.                *(dp++) = save[1];
  416.             }
  417.          }
  418.       }
  419.    }
  420. }
  421. #endif
  423. #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  424. void /* PRIVATE */
  425. png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
  426. {
  427.    png_debug(1, "in png_do_write_invert_alpha");
  428. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  429.    if (row != NULL && row_info != NULL)
  430. #endif
  431.    {
  432.       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  433.       {
  434.          /* This inverts the alpha channel in RGBA */
  435.          if (row_info->bit_depth == 8)
  436.          {
  437.             png_bytep sp, dp;
  438.             png_uint_32 i;
  439.             png_uint_32 row_width = row_info->width;
  440.             for (i = 0, sp = dp = row; i < row_width; i++)
  441.             {
  442.                /* does nothing
  443.                *(dp++) = *(sp++);
  444.                *(dp++) = *(sp++);
  445.                *(dp++) = *(sp++);
  446.                */
  447.                sp+=3; dp = sp;
  448.                *(dp++) = (png_byte)(255 - *(sp++));
  449.             }
  450.          }
  451.          /* This inverts the alpha channel in RRGGBBAA */
  452.          else
  453.          {
  454.             png_bytep sp, dp;
  455.             png_uint_32 i;
  456.             png_uint_32 row_width = row_info->width;
  458.             for (i = 0, sp = dp = row; i < row_width; i++)
  459.             {
  460.                /* does nothing
  461.                *(dp++) = *(sp++);
  462.                *(dp++) = *(sp++);
  463.                *(dp++) = *(sp++);
  464.                *(dp++) = *(sp++);
  465.                *(dp++) = *(sp++);
  466.                *(dp++) = *(sp++);
  467.                */
  468.                sp+=6; dp = sp;
  469.                *(dp++) = (png_byte)(255 - *(sp++));
  470.                *(dp++) = (png_byte)(255 - *(sp++));
  471.             }
  472.          }
  473.       }
  474.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  475.       {
  476.          /* This inverts the alpha channel in GA */
  477.          if (row_info->bit_depth == 8)
  478.          {
  479.             png_bytep sp, dp;
  480.             png_uint_32 i;
  481.             png_uint_32 row_width = row_info->width;
  483.             for (i = 0, sp = dp = row; i < row_width; i++)
  484.             {
  485.                *(dp++) = *(sp++);
  486.                *(dp++) = (png_byte)(255 - *(sp++));
  487.             }
  488.          }
  489.          /* This inverts the alpha channel in GGAA */
  490.          else
  491.          {
  492.             png_bytep sp, dp;
  493.             png_uint_32 i;
  494.             png_uint_32 row_width = row_info->width;
  496.             for (i = 0, sp = dp = row; i < row_width; i++)
  497.             {
  498.                /* does nothing
  499.                *(dp++) = *(sp++);
  500.                *(dp++) = *(sp++);
  501.                */
  502.                sp+=2; dp = sp;
  503.                *(dp++) = (png_byte)(255 - *(sp++));
  504.                *(dp++) = (png_byte)(255 - *(sp++));
  505.             }
  506.          }
  507.       }
  508.    }
  509. }
  510. #endif
  512. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  513. /* undoes intrapixel differencing  */
  514. void /* PRIVATE */
  515. png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
  516. {
  517.    png_debug(1, "in png_do_write_intrapixel");
  518.    if (
  519. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  520.        row != NULL && row_info != NULL &&
  521. #endif
  522.        (row_info->color_type & PNG_COLOR_MASK_COLOR))
  523.    {
  524.       int bytes_per_pixel;
  525.       png_uint_32 row_width = row_info->width;
  526.       if (row_info->bit_depth == 8)
  527.       {
  528.          png_bytep rp;
  529.          png_uint_32 i;
  531.          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  532.             bytes_per_pixel = 3;
  533.          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  534.             bytes_per_pixel = 4;
  535.          else
  536.             return;
  538.          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
  539.          {
  540.             *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);
  541.             *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);
  542.          }
  543.       }
  544.       else if (row_info->bit_depth == 16)
  545.       {
  546.          png_bytep rp;
  547.          png_uint_32 i;
  549.          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  550.             bytes_per_pixel = 6;
  551.          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  552.             bytes_per_pixel = 8;
  553.          else
  554.             return;
  556.          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
  557.          {
  558.             png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);
  559.             png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);
  560.             png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);
  561.             png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);
  562.             png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
  563.             *(rp  ) = (png_byte)((red >> 8) & 0xff);
  564.             *(rp+1) = (png_byte)(red & 0xff);
  565.             *(rp+4) = (png_byte)((blue >> 8) & 0xff);
  566.             *(rp+5) = (png_byte)(blue & 0xff);
  567.          }
  568.       }
  569.    }
  570. }
  571. #endif /* PNG_MNG_FEATURES_SUPPORTED */
  572. #endif /* PNG_WRITE_SUPPORTED */