reactos/dll/3rdparty/libpng/new_push_process_row.c

   1 void /* PRIVATE */
   2 png_push_process_row(png_structp png_ptr)
   3 {
   4    png_ptr->row_info.color_type = png_ptr->color_type;
   5    png_ptr->row_info.width = png_ptr->iwidth;
   6    png_ptr->row_info.channels = png_ptr->channels;
   7    png_ptr->row_info.bit_depth = png_ptr->bit_depth;
   8    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
   9
  10    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
  11        png_ptr->row_info.width);
  12
  13    png_read_filter_row(png_ptr, &(png_ptr->row_info),
  14        png_ptr->row_buf + 1, png_ptr->prev_row + 1,
  15        (int)(png_ptr->row_buf[0]));
  16
  17    png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
  18
  19    if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
  20       png_do_read_transformations(png_ptr);
  21
  22 #ifdef PNG_READ_INTERLACING_SUPPORTED
  23    /* Blow up interlaced rows to full size */
  24    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
  25    {
  26       if (png_ptr->pass < 6)
  27 /*       old interface (pre-1.0.9):
  28          png_do_read_interlace(&(png_ptr->row_info),
  29              png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
  30  */
  31          png_do_read_interlace(png_ptr);
  32
  33     switch (png_ptr->pass)
  34     {
  35          case 0:
  36          {
  37             int i;
  38             for (i = 0; i < 8 && png_ptr->pass == 0; i++)
  39             {
  40                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  41                png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
  42             }
  43
  44             if (png_ptr->pass == 2) /* Pass 1 might be empty */
  45             {
  46                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  47                {
  48                   png_push_have_row(png_ptr, NULL);
  49                   png_read_push_finish_row(png_ptr);
  50                }
  51             }
  52
  53             if (png_ptr->pass == 4 && png_ptr->height <= 4)
  54             {
  55                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  56                {
  57                   png_push_have_row(png_ptr, NULL);
  58                   png_read_push_finish_row(png_ptr);
  59                }
  60             }
  61
  62             if (png_ptr->pass == 6 && png_ptr->height <= 4)
  63             {
  64                   png_push_have_row(png_ptr, NULL);
  65                 png_read_push_finish_row(png_ptr);
  66             }
  67
  68             break;
  69          }
  70
  71          case 1:
  72          {
  73             int i;
  74             for (i = 0; i < 8 && png_ptr->pass == 1; i++)
  75             {
  76                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  77                png_read_push_finish_row(png_ptr);
  78             }
  79
  80             if (png_ptr->pass == 2) /* Skip top 4 generated rows */
  81             {
  82                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  83                {
  84                   png_push_have_row(png_ptr, NULL);
  85                   png_read_push_finish_row(png_ptr);
  86                }
  87             }
  88
  89             break;
  90          }
  91
  92          case 2:
  93          {
  94             int i;
  95
  96             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  97             {
  98                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  99                png_read_push_finish_row(png_ptr);
 100             }
 101
 102             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 103             {
 104                   png_push_have_row(png_ptr, NULL);
 105                png_read_push_finish_row(png_ptr);
 106             }
 107
 108             if (png_ptr->pass == 4) /* Pass 3 might be empty */
 109             {
 110                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 111                {
 112                   png_push_have_row(png_ptr, NULL);
 113                   png_read_push_finish_row(png_ptr);
 114                }
 115             }
 116
 117             break;
 118          }
 119
 120          case 3:
 121          {
 122             int i;
 123
 124             for (i = 0; i < 4 && png_ptr->pass == 3; i++)
 125             {
 126                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 127                png_read_push_finish_row(png_ptr);
 128             }
 129
 130             if (png_ptr->pass == 4) /* Skip top two generated rows */
 131             {
 132                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 133                {
 134                   png_push_have_row(png_ptr, NULL);
 135                   png_read_push_finish_row(png_ptr);
 136                }
 137             }
 138
 139             break;
 140          }
 141
 142          case 4:
 143          {
 144             int i;
 145
 146             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 147             {
 148                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 149                png_read_push_finish_row(png_ptr);
 150             }
 151
 152             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 153             {
 154                   png_push_have_row(png_ptr, NULL);
 155                png_read_push_finish_row(png_ptr);
 156             }
 157
 158             if (png_ptr->pass == 6) /* Pass 5 might be empty */
 159             {
 160                   png_push_have_row(png_ptr, NULL);
 161                png_read_push_finish_row(png_ptr);
 162             }
 163
 164             break;
 165          }
 166
 167          case 5:
 168          {
 169             int i;
 170
 171             for (i = 0; i < 2 && png_ptr->pass == 5; i++)
 172             {
 173                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 174                png_read_push_finish_row(png_ptr);
 175             }
 176
 177             if (png_ptr->pass == 6) /* Skip top generated row */
 178             {
 179                   png_push_have_row(png_ptr, NULL);
 180                png_read_push_finish_row(png_ptr);
 181             }
 182
 183             break;
 184          }
 185          case 6:
 186          {
 187             png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 188             png_read_push_finish_row(png_ptr);
 189
 190             if (png_ptr->pass != 6)
 191                break;
 192
 193                   png_push_have_row(png_ptr, NULL);
 194             png_read_push_finish_row(png_ptr);
 195          }
 196       }
 197    }
 198    else
 199 #endif
 200    {
 201       png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 202       png_read_push_finish_row(png_ptr);
 203    }
 204 }