ebcot_lite_decode_passes.c

JPEG2000实现的源码

/* STATIC                 raw_zero_refinement_pass_func                      */
/*****************************************************************************/

static void
  raw_zero_refinement_pass_func(block_master_ptr master)
{
  register std_short *cp;
  register ifc_int *dp;
  register int c;
  register std_short ctxt;
  register ifc_int shift;
  register ifc_int symbol, val;
  register dst_arith_state_ptr state;
  register std_int word;
  register int current_lsb;
  ifc_int lsb;
  std_short non_causal;
  int cols, stripe_gap, r;

  shift = master->bit_idx - 1;
  lsb = 1 << shift;
  state = &(master->coder_state);
  word = state->word; current_lsb = state->current_lsb;
  non_causal = 1 - master->causal;
  cols = master->width;
  stripe_gap = master->interleaved_row_gap;
  cp = master->interleaved_context_buffer;
  dp = master->interleaved_sample_buffer;
  for (r=master->stripes; r > 0; r--,
       dp+=stripe_gap-(cols<<2), cp+=stripe_gap-(cols<<2))
    for (c=cols; c > 0; c--, dp+=4, cp+=4)
      {
        if (((((std_int *) cp)[0] | ((std_int *) cp)[1]) & 0x00FF00FF) == 0)
          continue;
        if ((((std_int *) cp)[0] & 0x00FF00FF) == 0)
          goto skip2;

        ctxt = cp[0];
        if ((ctxt & 0x00FF) && !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
          {
            ctxt |= IS_REFINED;
            dst_get_raw_bit(current_lsb,word,symbol,state);
            if (symbol)
              { /* New significant value; update contexts & code sign */
                dst_get_raw_bit(current_lsb,word,symbol,state);
                val = symbol << (IMPLEMENTATION_PRECISION-1);
                ctxt |= SELF_SIG;
                cp[(-stripe_gap+3)-4]  |= (non_causal << BR_POS);
                cp[(-stripe_gap+3)+4]  |= (non_causal << BL_POS);
                cp[1-4]                |= TR_SIG;
                cp[1+4]                |= TL_SIG;
                if (val)
                  { /* Negative sample. */
                    cp[4]              |= CL_SIG | H_NVE_SIG;
                    cp[-4]             |= CR_SIG | H_NVE_SIG;
                    cp[(-stripe_gap+3)]|= (non_causal << BC_POS) |
                                          (non_causal << V_NVE_POS);
                    cp[1]              |= TC_SIG | V_NVE_SIG;
                  }
                else
                  { /* Positive sample. */
                    cp[4]              |= CL_SIG | H_PVE_SIG;
                    cp[-4]             |= CR_SIG | H_PVE_SIG;
                    cp[(-stripe_gap+3)]|= (non_causal << BC_POS) |
                                          (non_causal << V_PVE_POS);
                    cp[1]              |= TC_SIG | V_PVE_SIG;
                  }
                val |= lsb + (lsb>>1);
                dp[0] = val;
              }
            cp[0] = ctxt;
          }

        ctxt = cp[1];
        if ((ctxt & 0x00FF) && !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
          {
            ctxt |= IS_REFINED;
            dst_get_raw_bit(current_lsb,word,symbol,state);
            if (symbol)
              { /* New significant value; update contexts & code sign */
                dst_get_raw_bit(current_lsb,word,symbol,state);
                val = symbol << (IMPLEMENTATION_PRECISION-1);
                ctxt |= SELF_SIG;
                cp[0-4]                |= BR_SIG;
                cp[0+4]                |= BL_SIG;
                cp[2-4]                |= TR_SIG;
                cp[2+4]                |= TL_SIG;
                if (val)
                  { /* Negative sample. */
                    cp[1+4]            |= CL_SIG | H_NVE_SIG;
                    cp[1-4]            |= CR_SIG | H_NVE_SIG;
                    cp[0]              |= BC_SIG | V_NVE_SIG;
                    cp[2]              |= TC_SIG | V_NVE_SIG;
                  }
                else
                  { /* Positive sample. */
                    cp[1+4]            |= CL_SIG | H_PVE_SIG;
                    cp[1-4]            |= CR_SIG | H_PVE_SIG;
                    cp[0]              |= BC_SIG | V_PVE_SIG;
                    cp[2]              |= TC_SIG | V_PVE_SIG;
                  }
                val |= lsb + (lsb>>1);
                dp[1] = val;
              }
            cp[1] = ctxt;
          }
        if ((((std_int *) cp)[1]  & 0x00FF00FF) == 0)
          continue;
skip2:
        ctxt = cp[2];
        if ((ctxt & 0x00FF) && !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
          {
            ctxt |= IS_REFINED;
            dst_get_raw_bit(current_lsb,word,symbol,state);
            if (symbol)
              { /* New significant value; update contexts & code sign */
                dst_get_raw_bit(current_lsb,word,symbol,state);
                val = symbol << (IMPLEMENTATION_PRECISION-1);
                ctxt |= SELF_SIG;
                cp[1-4]                |= BR_SIG;
                cp[1+4]                |= BL_SIG;
                cp[3-4]                |= TR_SIG;
                cp[3+4]                |= TL_SIG;
                if (val)
                  { /* Negative sample. */
                    cp[2+4]            |= CL_SIG | H_NVE_SIG;
                    cp[2-4]            |= CR_SIG | H_NVE_SIG;
                    cp[1]              |= BC_SIG | V_NVE_SIG;
                    cp[3]              |= TC_SIG | V_NVE_SIG;
                  }
                else
                  { /* Positive sample. */
                    cp[2+4]            |= CL_SIG | H_PVE_SIG;
                    cp[2-4]            |= CR_SIG | H_PVE_SIG;
                    cp[1]              |= BC_SIG | V_PVE_SIG;
                    cp[3]              |= TC_SIG | V_PVE_SIG;
                  }
                val |= lsb + (lsb>>1);
                dp[2] = val;
              }
            cp[2] = ctxt;
          }

        ctxt = cp[3];
        if ((ctxt & 0x00FF) && !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
          {
            ctxt |= IS_REFINED;
            dst_get_raw_bit(current_lsb,word,symbol,state);
            if (symbol)
              { /* New significant value; update contexts & code sign */
                dst_get_raw_bit(current_lsb,word,symbol,state);
                val = symbol << (IMPLEMENTATION_PRECISION-1);
                ctxt |= SELF_SIG;
                cp[2-4]                |= BR_SIG;
                cp[2+4]                |= BL_SIG;
                cp[stripe_gap-4]       |= TR_SIG;
                cp[stripe_gap+4]       |= TL_SIG;
                if (val)
                  { /* Negative sample. */
                    cp[3+4]            |= CL_SIG | H_NVE_SIG;
                    cp[3-4]            |= CR_SIG | H_NVE_SIG;
                    cp[2]              |= BC_SIG | V_NVE_SIG;
                    cp[stripe_gap]     |= TC_SIG | V_NVE_SIG;
                  }
                else
                  { /* Positive sample. */
                    cp[3+4]            |= CL_SIG | H_PVE_SIG;
                    cp[3-4]            |= CR_SIG | H_PVE_SIG;
                    cp[2]              |= BC_SIG | V_PVE_SIG;
                    cp[stripe_gap]     |= TC_SIG | V_PVE_SIG;
                  }
                val |= lsb + (lsb>>1);
                dp[3] = val;
              }
            cp[3] = ctxt;
          }
      }
  state->current_lsb = current_lsb; state->word = word;
}

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

static void
  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_short *cp;
  register std_int cum_delta, thresh;
  register ifc_int *dp;
  register int c;
  register std_short ctxt;
  register ifc_int shift;
  register dst_arith_state_ptr state;
  register dst_context_state_ptr csp;
  register ifc_int val, symbol;
  register unsigned long creg;
  register std_int areg;
  int ct;
  ifc_int lsb;
  std_short non_causal;
  std_byte *zc_lut;
  int cols, stripe_gap, r;
  dst_context_state_ptr csp_base;

  if (master->bit_idx <= (master->first_bit_idx-master->full_effort_msbs))
    { raw_zero_refinement_pass_func(master); return; }
  
  state = &(master->coder_state);
  if (!state->mqd.active)
    dst_arith_coder__activate(state);

  assert((master->bit_idx > 1) &&
         ((master->interleaved_row_gap & 3) == 0));
  shift = master->bit_idx - 1;
  lsb = 1 << shift;
  areg = state->mqd.areg; creg = state->mqd.creg; ct = state->mqd.ct;
  dst_compute_ac_thresh(areg,creg,thresh); cum_delta = 0;
  csp_base = state->contexts;
  zc_lut = master->zc_lut;
  non_causal = 1 - master->causal;
  cols = master->width;
  stripe_gap = master->interleaved_row_gap;
  cp = master->interleaved_context_buffer;
  dp = master->interleaved_sample_buffer;
  for (r=master->stripes; r > 0; r--,
       dp+=stripe_gap-(cols<<2), cp+=stripe_gap-(cols<<2))
    for (c=cols; c > 0; c--, dp+=4, cp+=4)
      {
        if (((((std_int *) cp)[0] | ((std_int *) cp)[1]) & 0x00FF00FF) == 0)
          continue;
        if ((((std_int *) cp)[0] & 0x00FF00FF) == 0)
          goto skip2;

        ctxt = cp[0];
        if ((ctxt & 0x00FF) && !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
          {
            ctxt |= IS_REFINED;
            csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
            dst_get_symbol_skewed(areg,creg,thresh,cum_delta,
                                  ct,state,symbol,csp);
            if (symbol)
              { /* New significant value; update contexts & code sign */
                val = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                csp = csp_base + SC_OFFSET + (val & 0x000F);
                val &= MIN_IFC_INT;
                dst_get_symbol_skewed(areg,creg,thresh,cum_delta,
                                      ct,state,symbol,csp);
                val ^= (symbol << (IMPLEMENTATION_PRECISION-1));
                ctxt |= SELF_SIG;
                cp[(-stripe_gap+3)-4]  |= (non_causal << BR_POS);
                cp[(-stripe_gap+3)+4]  |= (non_causal << BL_POS);
                cp[1-4]                |= TR_SIG;
                cp[1+4]                |= TL_SIG;
                if (val)
                  { /* Negative sample. */
                    cp[4]              |= CL_SIG | H_NVE_SIG;
                    cp[-4]             |= CR_SIG | H_NVE_SIG;
                    cp[(-stripe_gap+3)]|= (non_causal << BC_POS) |
                                          (non_causal << V_NVE_POS);
                    cp[1]              |= TC_SIG | V_NVE_SIG;
                  }
                else
                  { /* Positive sample. */
                    cp[4]              |= CL_SIG | H_PVE_SIG;
                    cp[-4]             |= CR_SIG | H_PVE_SIG;
                    cp[(-stripe_gap+3)]|= (non_causal << BC_POS) |
                                          (non_causal << V_PVE_POS);
                    cp[1]              |= TC_SIG | V_PVE_SIG;
                  }
                val |= lsb + (lsb>>1);
                dp[0] = val;
              }
            cp[0] = ctxt;
          }

        ctxt = cp[1];
        if ((ctxt & 0x00FF) && !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
          {
            ctxt |= IS_REFINED;
            csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
            dst_get_symbol_skewed(areg,creg,thresh,cum_delta,
                                  ct,state,symbol,csp);
            if (symbol)
              { /* New significant value; update contexts & code sign */
                val = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                csp = csp_base + SC_OFFSET + (val & 0x000F);
                val &= MIN_IFC_INT;
                dst_get_symbol_skewed(areg,creg,thresh,cum_delta,
                                      ct,state,symbol,csp);
                val ^= (symbol << (IMPLEMENTATION_PRECISION-1));