ebcot_lite_encode_passes.c

JPEG2000 EBCOT算法源码

}

/*****************************************************************************/
/* STATIC                  zero_refinement_pass_func                         */
/*****************************************************************************/

static std_int
  zero_refinement_pass_func(block_master_ptr master)

 /* This function refines all samples which have not yet been found to be
    significant and whose context word matches that supplied by the
    `context_mask' field in `master', setting the IS_REFINED flag in the
    cntext word for all samples which are refined in this way.  The function
    ignores all samples for which the IS_REFINED flag is already set. */

{
  register std_int *d_cp;
  register std_int d_mask;
  register int c;
  register std_short *cp;
  register ifc_int *dp;
  register std_short ctxt, context_mask;
  register arith_state_ptr state;
  register std_int A, C, word, rho;
  register context_state_ptr csp;
  std_short avail;
  ifc_int val, symbol, mask, lsb, shift;
  std_byte *zc_lut;
  ifc_int mse_upshift, mse_downshift;
  std_int delta_mse_acc;
  int rows, cols, row_gap, half_inter_row, r;
  std_short *context;
  ifc_int *data;
  context_state_ptr csp_base;
  code_subblock_ptr subblock, last_subblock;

  shift = master->bit_idx - 1;
  assert(shift > 0);
  lsb = 1 << shift;
  mask = (ifc_int)(MAX_IFC_INT & ((-1)<<shift));
  context_mask = master->context_mask;
  d_mask = context_mask; d_mask <<= 16; d_mask |= context_mask;
  data = master->sample_buffer;
  context = master->context_buffer;
  row_gap = master->row_gap;
  assert(!(row_gap & 1));
  delta_mse_acc = 0;
  mse_downshift = shift - (MSE_LUT_BITS-1);
  mse_upshift = (mse_downshift<0)?-mse_downshift:0;
  mse_downshift += mse_upshift;
  state = &(master->coder_state);
  A=state->A; C=state->C; word=state->word; rho=state->rho;
  avail=state->available_bits; csp_base = state->contexts;
  zc_lut = master->zc_lut;
  last_subblock = master->last_subblock;
  for (subblock=master->first_subblock; subblock <= last_subblock; subblock++)
    if (subblock->significant)
      {
        rows = subblock->rows;
        cols = subblock->cols;
        half_inter_row = (row_gap-cols)>>1;
        dp = data + subblock->offset;
        cp = context + subblock->offset;
        d_cp = (std_int *) cp;
        for (r=rows; r > 0; r--, dp+=half_inter_row<<1, cp+=half_inter_row<<1,
             d_cp+=half_inter_row)
          for (c=cols; c > 0; c-=2, dp+=2, cp+=2, d_cp++)
            {
              if (((*d_cp) & d_mask) == 0)
                continue;
              ctxt = cp[0];
              if ((ctxt & context_mask) &&
                  !(ctxt & (IS_REFINED | SELF_SIG | OUT_OF_BOUNDS)))
                {
                  ctxt |= IS_REFINED;
                  val = dp[0];
                  symbol = (val & mask);
                  csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
                  emit_symbol(state,A,C,word,avail,rho,symbol,csp);
                  if (symbol)
                    { /* New significant value; update contexts & code sign */
                      ifc_int sign;

                      sign = val & MIN_IFC_INT; /* Save sign bit. */
                      val &= MAX_IFC_INT;
                      val >>= mse_downshift; val <<= mse_upshift;
                      assert(val == (val & MSE_LUT_MASK));
                      delta_mse_acc += ebcot_initial_mse_lut[val];
                      symbol = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                      csp = csp_base + SC_OFFSET + (symbol & 0x000F);
                      symbol &= MIN_IFC_INT;
                      symbol ^= sign;
                      emit_symbol(state,A,C,word,avail,rho,symbol,csp);
                      ctxt           |= SELF_SIG;
                      cp[-row_gap-2] |= FAR_SIG;
                      cp[-row_gap-1] |= BR_SIG;
                      cp[-row_gap+1] |= BL_SIG;
                      cp[-row_gap+2] |= FAR_SIG;
                      cp[row_gap-2]  |= FAR_SIG;
                      cp[row_gap-1]  |= TR_SIG;
                      cp[row_gap+1]  |= TL_SIG;
                      cp[row_gap+2]  |= FAR_SIG;
                      cp[-2]         |= FAR_SIG;
                      cp[2]          |= FAR_SIG;
                      if (sign)
                        { /* Negative sample. */
                          cp[-1]         |= CR_SIG | H_NVE_SIG;
                          cp[1]          |= CL_SIG | H_NVE_SIG;
                          cp[-row_gap]   |= BC_SIG | V_NVE_SIG;
                          cp[row_gap]    |= TC_SIG | V_NVE_SIG;
                        }
                      else
                        { /* Positive sample. */
                          cp[-1]         |= CR_SIG | H_PVE_SIG;
                          cp[1]          |= CL_SIG | H_PVE_SIG;
                          cp[-row_gap]   |= BC_SIG | V_PVE_SIG;
                          cp[row_gap]    |= TC_SIG | V_PVE_SIG;
                        }
                    }
                  cp[0] = ctxt;
                }
              ctxt = cp[1];
              if ((ctxt & context_mask) &&
                  !(ctxt & (IS_REFINED | SELF_SIG | OUT_OF_BOUNDS)))
                {
                  ctxt |= IS_REFINED;
                  val = dp[1];
                  symbol = (val & mask);
                  csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
                  emit_symbol(state,A,C,word,avail,rho,symbol,csp);
                  if (symbol)
                    { /* New significant value; update contexts & code sign */
                      std_short sign;

                      sign = val & MIN_IFC_INT; /* Save sign bit. */
                      val &= MAX_IFC_INT;
                      val >>= mse_downshift; val <<= mse_upshift;
                      assert(val == (val & MSE_LUT_MASK));
                      delta_mse_acc += ebcot_initial_mse_lut[val];
                      symbol = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                      csp = csp_base + SC_OFFSET + (symbol & 0x000F);
                      symbol &= MIN_IFC_INT;
                      symbol ^= sign;
                      emit_symbol(state,A,C,word,avail,rho,symbol,csp);
                      ctxt           |= SELF_SIG;
                      cp[-row_gap-2+1] |= FAR_SIG;
                      cp[-row_gap-1+1] |= BR_SIG;
                      cp[-row_gap+1+1] |= BL_SIG;
                      cp[-row_gap+2+1] |= FAR_SIG;
                      cp[row_gap-2+1]  |= FAR_SIG;
                      cp[row_gap-1+1]  |= TR_SIG;
                      cp[row_gap+1+1]  |= TL_SIG;
                      cp[row_gap+2+1]  |= FAR_SIG;
                      cp[-2+1]         |= FAR_SIG;
                      cp[2+1]          |= FAR_SIG;
                      if (sign)
                        { /* Negative sample. */
                          cp[-1+1]         |= CR_SIG | H_NVE_SIG;
                          cp[1+1]          |= CL_SIG | H_NVE_SIG;
                          cp[-row_gap+1]   |= BC_SIG | V_NVE_SIG;
                          cp[row_gap+1]    |= TC_SIG | V_NVE_SIG;
                        }
                      else
                        { /* Positive sample. */
                          cp[-1+1]         |= CR_SIG | H_PVE_SIG;
                          cp[1+1]          |= CL_SIG | H_PVE_SIG;
                          cp[-row_gap+1]   |= BC_SIG | V_PVE_SIG;
                          cp[row_gap+1]    |= TC_SIG | V_PVE_SIG;
                        }
                    }
                  cp[1] = ctxt;
                }
            }
      }
  state->A=A; state->C=C; state->word=word; state->rho=rho;
  state->available_bits=avail;
  return((delta_mse_acc+2)>>2);
}

/*****************************************************************************/
/* STATIC               reverse_zero_refinement_pass_func                    */
/*****************************************************************************/

static std_int
  reverse_zero_refinement_pass_func(block_master_ptr master)

 /* This function is identical to `zero_refinement_pass_func', except that it
    passes through the list of significant subblocks and the samples within
    each subblock in reverse order, from bottom right to top left. */

{
  register std_int *d_cp;
  register std_int d_mask;
  register int c;
  register std_short *cp;
  register ifc_int *dp;
  register std_short ctxt, context_mask;
  register arith_state_ptr state;
  register std_int A, C, word, rho;
  register context_state_ptr csp;
  std_short avail;
  ifc_int val, symbol, mask, lsb, shift;
  std_byte *zc_lut;
  ifc_int mse_upshift, mse_downshift;
  std_int delta_mse_acc;
  int rows, cols, row_gap, half_inter_row, r;
  std_short *context;
  ifc_int *data;
  context_state_ptr csp_base;
  code_subblock_ptr subblock, first_subblock;

  shift = master->bit_idx - 1;
  assert(shift > 0);
  lsb = 1 << shift;
  mask = (ifc_int)(MAX_IFC_INT & ((-1)<<shift));
  context_mask = master->context_mask;
  d_mask = context_mask; d_mask <<= 16; d_mask |= context_mask;
  data = master->sample_buffer;
  context = master->context_buffer;
  row_gap = master->row_gap;
  assert(!(row_gap & 1));
  delta_mse_acc = 0;
  mse_downshift = shift - (MSE_LUT_BITS-1);
  mse_upshift = (mse_downshift<0)?-mse_downshift:0;
  mse_downshift += mse_upshift;
  state = &(master->coder_state);
  A=state->A; C=state->C; word=state->word; rho=state->rho;
  avail=state->available_bits; csp_base = state->contexts;
  zc_lut = master->zc_lut;
  first_subblock = master->first_subblock;
  for (subblock=master->last_subblock; subblock >= first_subblock; subblock--)
    if (subblock->significant)
      {
        rows = subblock->rows;
        cols = subblock->cols;
        half_inter_row = (row_gap-cols)>>1;
        dp = data + subblock->offset + row_gap*(rows-1) + ((cols-1) & ~1);
        cp = context + subblock->offset + row_gap*(rows-1) + ((cols-1) & ~1);
        d_cp = (std_int *) cp;
        for (r=rows; r > 0; r--, dp-=half_inter_row<<1, cp-=half_inter_row<<1,
             d_cp-=half_inter_row)
          for (c=cols; c > 0; c-=2, dp-=2, cp-=2, d_cp--)
            {
              if (((*d_cp) & d_mask) == 0)
                continue;
              ctxt = cp[1];
              if ((ctxt & context_mask) &&
                  !(ctxt & (IS_REFINED | SELF_SIG | OUT_OF_BOUNDS)))
                {
                  ctxt |= IS_REFINED;
                  val = dp[1];
                  symbol = (val & mask);
                  csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
                  emit_symbol(state,A,C,word,avail,rho,symbol,csp);
                  if (symbol)
                    { /* New significant value; update contexts & code sign */
                      ifc_int sign;

                      sign = val & MIN_IFC_INT; /* Save sign bit. */
                      val &= MAX_IFC_INT;
                      val >>= mse_downshift; val <<= mse_upshift;