decoder.cpp

JPEG2000压缩解压图像源码

    }
  assert((next_buffered_row == 0) && (current_block_height > 0) &&
         (block_indices.size.y > 0));

  int offset=0;
  kdu_coords idx = block_indices.pos;
  int blocks_remaining = block_indices.size.x;
  kdu_coords xfer_size;
  kdu_block *block;

  for (; blocks_remaining > 0; blocks_remaining--,
       idx.x++, offset+=xfer_size.x)
    {
      block = band.open_block(idx);
      block_decoder.decode(block);
      xfer_size = block->region.size;
      if (block->transpose)
        xfer_size.transpose();
      assert(xfer_size.y == current_block_height);
      assert((xfer_size.x+offset) <= subband_cols);
      int m, n;
      if (block->num_passes == 0)
        { /* Fill block region with 0's.  Note the unrolled loops and the
             fact that there is no need to worry if the code zeros out as
             many as 3 samples beyond the end of each block line, since the
             buffers were allocated with a bit of extra space at the end. */
          if (lines32 != NULL)
            { // 32-bit samples
              kdu_sample32 *dp;
              for (m=0; m < xfer_size.y; m++)
                if (reversible)
                  for (dp=lines32[m]+offset, n=xfer_size.x; n>0; n-=4, dp+=4)
                    { dp[0].ival=0; dp[1].ival=0; dp[2].ival=0; dp[3].ival=0;}
                else
                  for (dp=lines32[m]+offset, n=xfer_size.x; n>0; n-=4, dp+=4)
                    { dp[0].fval = 0.0F; dp[1].fval = 0.0F;
                      dp[2].fval = 0.0F; dp[3].fval = 0.0F; }
            }
          else
            { // 16-bit samples
              kdu_sample16 *dp;
              for (m=0; m < xfer_size.y; m++)
                for (dp=lines16[m]+offset, n=xfer_size.x; n>0; n-=4, dp+=4)
                  { dp[0].ival=0; dp[1].ival=0; dp[2].ival=0; dp[3].ival=0;}
            }
        }
      else
        { // Need to dequantize and/or convert quantization indices.
          if (K_max_prime > K_max)
            adjust_roi_background(block);
          kdu_int32 *sp, *spp = block->sample_buffer;
          int row_gap = block->size.x;
          spp += block->region.pos.y * row_gap + block->region.pos.x;
          int m_start = 0, m_inc = 1, n_start=offset, n_inc = 1;
          if (block->vflip)
            { m_start += xfer_size.y-1; m_inc = -1; }
          if (block->hflip)
            { n_start += xfer_size.x-1; n_inc = -1; }
          if (lines32 != NULL)
            { // Need to generate 32-bit dequantized values.
              kdu_sample32 *dp, **dpp = lines32+m_start;        
              if (reversible)
                { // Output is 32-bit absolute integers.
                  kdu_int32 val;
                  kdu_int32 downshift = 31-K_max;
                  if (downshift < 0)
                    { kdu_error e; e << "Insufficient implementation "
                      "precision available for true reversible processing!"; }
                  if (!block->transpose)
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp+=row_gap)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp++, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            dp->ival = -((val & KDU_INT32_MAX) >> downshift);
                          else
                            dp->ival = val >> downshift;
                        }
                  else
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp++)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp+=row_gap, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            dp->ival = -((val & KDU_INT32_MAX) >> downshift);
                          else
                            dp->ival = val >> downshift;
                        }
                }
              else
                { // Output is true floating point values.
                  kdu_int32 val;
                  float scale = delta;
                  if (K_max <= 31)
                    scale /= (float)(1<<(31-K_max));
                  else
                    scale *= (float)(1<<(K_max-31)); // Can't decode all planes
                  if (!block->transpose)
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp+=row_gap)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp++, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            val = -(val & KDU_INT32_MAX);
                          dp->fval = scale * val;
                        }
                  else
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp++)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp+=row_gap, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            val = -(val & KDU_INT32_MAX);
                          dp->fval = scale * val;
                        }
                }
            }
          else
            { // Need to produce 16-bit dequantized values.
              kdu_sample16 *dp, **dpp = lines16+m_start;        
              if (reversible)
                { // Output is 16-bit absolute integers.
                  kdu_int32 val;
                  kdu_int32 downshift = 31-K_max;
                  assert(downshift >= 0); // Otherwise should be using 32 bits.
                  if (!block->transpose)
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp+=row_gap)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp++, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            dp->ival = (kdu_int16)
                              -((val & KDU_INT32_MAX) >> downshift);
                          else
                            dp->ival = (kdu_int16)(val >> downshift);
                        }
                  else
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp++)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp+=row_gap, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            dp->ival = (kdu_int16)
                              -((val & KDU_INT32_MAX) >> downshift);
                          else
                            dp->ival = (kdu_int16)(val >> downshift);
                        }
                }
              else
                { // Output is 16-bit fixed point values.
                  float fscale = delta * (float)(1<<KDU_FIX_POINT);
                  if (K_max <= 31)
                    fscale /= (float)(1<<(31-K_max));
                  else
                    fscale *= (float)(1<<(K_max-31));
                  fscale *= (float)(1<<16) * (float)(1<<16);
                  kdu_int32 val, scale = ((kdu_int32)(fscale+0.5F));
                  if (!block->transpose)
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp+=row_gap)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp++, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            val = -(val & KDU_INT32_MAX);
                          val = (val+(1<<15))>>16; val *= scale;
                          dp->ival = (kdu_int16)((val+(1<<15))>>16);
                        }
                  else
                    for (m=xfer_size.y; m--; dpp+=m_inc, spp++)
                      for (dp=(*dpp)+n_start, sp=spp,
                           n=xfer_size.x; n--; sp+=row_gap, dp+=n_inc)
                        {
                          val = *sp;
                          if (val < 0)
                            val = -(val & KDU_INT32_MAX);
                          val = (val+(1<<15))>>16; val *= scale;
                          dp->ival = (kdu_int16)((val+(1<<15))>>16);
                        }
                }
            }
        }
      band.close_block(block);
    }

  block_indices.pos.y++;
  block_indices.size.y--;
}

/*****************************************************************************/
/*                     kd_decoder::adjust_roi_background                     */
/*****************************************************************************/

void
  kd_decoder::adjust_roi_background(kdu_block *block)
{
  kdu_int32 upshift = K_max_prime - K_max;
  kdu_int32 mask = (-1)<<(31-K_max); mask &= KDU_INT32_MAX;
  kdu_int32 *sp = block->sample_buffer;
  kdu_int32 val;
  int num_samples = ((block->size.y+3)>>2) * (block->size.x<<2);

  for (int n=num_samples; n--; sp++)
    if ((((val=*sp) & mask) == 0) && (val != 0))
      {
        if (val < 0)
          *sp = (val << upshift) | KDU_INT32_MIN;
        else
          *sp <<= upshift;
      }
}