ebcot_lite_decode_passes.c

关于视频压缩的jpeg2000压缩算法,C编写

                  if (cum_delta <= thresh)
                    {
                      _addto_symbol_count(1);
#ifdef DST_LOG_SYMBOLS
                      dst_arith_coder__check_logged_symbol(state,csp,0);
#endif
                      goto skip3;
                    }
                  dst_get_symbol_skewed_failed(areg,creg,thresh,cum_delta,
                                               ct,state,symbol,csp);
                  if (!symbol)
                    goto skip3;
new_sig3:         /* New significant value; update contexts & get sign. */
                  val = ebcot_sc_lut[(d_ctxt_1>>SIGN_POS_1)&0x000F];
                  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));
                  su_flags |= 0x100;
                  sup[sup_gap-2] |= 1<<(16-i);
                  if (val)
                    { /* Negative sample. */
                      d_ctxt_1     |= SELF_SIG_1 | BC_SIG_0 | V_NVE_SIG_0;
                      d_cp[-1]     |= BR_SIG_0 | CR_SIG_1 | H_NVE_SIG_1;
                      d_cp[3]      |= BL_SIG_0 | CL_SIG_1 | H_NVE_SIG_1;
                      d_cp[d_stripe_gap-2]     |= TR_SIG_0;
                      d_cp[d_stripe_gap]       |= TC_SIG_0 | V_NVE_SIG_0;
                      d_cp[d_stripe_gap+2]     |= TL_SIG_0;
                    }
                  else
                    { /* Positive sample. */
                      d_ctxt_1     |= SELF_SIG_1 | BC_SIG_0 | V_PVE_SIG_0;
                      d_cp[-1]     |= BR_SIG_0 | CR_SIG_1 | H_PVE_SIG_1;
                      d_cp[3]      |= BL_SIG_0 | CL_SIG_1 | H_PVE_SIG_1;
                      d_cp[d_stripe_gap-2]     |= TR_SIG_0;
                      d_cp[d_stripe_gap]       |= TC_SIG_0 | V_PVE_SIG_0;
                      d_cp[d_stripe_gap+2]     |= TL_SIG_0;
                    }
                  val |= lsb + (lsb>>1);
                  dp[3] = val; /* Write new non-zero value to buffer. */
                }
skip3:
              d_ctxt_1 &= ~(IS_REFINED_0 | IS_REFINED_1);
              d_cp[0] = d_ctxt_0; d_cp[1] = d_ctxt_1;
            }
          sup[-2] = (su_flags & 0x00FF) << 8;
        }
    }
  areg -= cum_delta; creg -= ((unsigned) cum_delta) << 16;
  state->mqd.areg = areg; state->mqd.creg = creg; state->mqd.ct = ct;
}

/*****************************************************************************/
/* STATIC               su_raw_zero_refinement_pass_func                     */
/*****************************************************************************/

static void
  su_raw_zero_refinement_pass_func(block_master_ptr master)
{
  register std_int su_flags;
  register int i;
  register std_int d_ctxt_0, d_ctxt_1;
  register std_int *d_cp;
      /* Note: it is most beneficial if the above five variables are
         held in registers. */
  register ifc_int *dp;
  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_int *supp, *sup;
  std_int non_causal;
  int eighth_cols, d_stripe_gap, sup_gap, r, c;

  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;
  eighth_cols = (master->width+7)>>3;
  d_stripe_gap = (master->interleaved_row_gap >> 1);
  sup_gap = master->speed_up_row_gap;
  d_cp = (std_int *)(master->interleaved_context_buffer);
  dp = master->interleaved_sample_buffer;
  supp = master->speed_up_buffer;
  for (r=master->stripes; r > 0; r--,
       dp+=(d_stripe_gap<<1)-(eighth_cols<<5),
       d_cp+=d_stripe_gap-(eighth_cols<<4),
       supp+=sup_gap)
    {
      sup = supp;
      su_flags = *(sup++);
      for (c=eighth_cols; c > 0; c--)
        {
          su_flags |= *(sup++) << 8;
          for (i=8; i > 0; i--, dp+=4, d_cp+=2, su_flags>>=1)
            {
              if ((su_flags & 0x00000380) == 0)
                continue; /* Whole column has insignificant neighbours. */
              d_ctxt_0 = d_cp[0]; d_ctxt_1 = d_cp[1];
              if ((d_ctxt_0 & ZC_MASK_0) &&
                  !(d_ctxt_0 & (IS_REFINED_0|SELF_SIG_0|OUT_OF_BOUNDS_0)))
                {
                  d_ctxt_0 |= IS_REFINED_0;
                  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);
                      su_flags |= 0x100;
                      if (val)
                        { /* Negative sample. */
                          d_ctxt_0     |= SELF_SIG_0 | TC_SIG_1 | V_NVE_SIG_1;
                          d_cp[-2]     |= TR_SIG_1 | CR_SIG_0 | H_NVE_SIG_0;
                          d_cp[2]      |= TL_SIG_1 | CL_SIG_0 | H_NVE_SIG_0;
                          if (non_causal)
                            {
                              d_cp[-d_stripe_gap-1] |= BR_SIG_1;
                              d_cp[-d_stripe_gap+1] |= BC_SIG_1 | V_NVE_SIG_1;
                              d_cp[-d_stripe_gap+3] |= BL_SIG_1;
                              sup[-sup_gap-2] |= 1<<(16-i);
                            }
                        }
                      else
                        { /* Positive sample. */
                          d_ctxt_0     |= SELF_SIG_0 | TC_SIG_1 | V_PVE_SIG_1;
                          d_cp[-2]     |= TR_SIG_1 | CR_SIG_0 | H_PVE_SIG_0;
                          d_cp[2]      |= TL_SIG_1 | CL_SIG_0 | H_PVE_SIG_0;
                          if (non_causal)
                            {
                              d_cp[-d_stripe_gap-1] |= BR_SIG_1;
                              d_cp[-d_stripe_gap+1] |= BC_SIG_1 | V_PVE_SIG_1;
                              d_cp[-d_stripe_gap+3] |= BL_SIG_1;
                              sup[-sup_gap-2] |= 1<<(16-i);
                            }
                        }
                      val |= lsb + (lsb>>1);
                      dp[0] = val;
                    }
                }

              if ((d_ctxt_0 & ZC_MASK_1) &&
                  !(d_ctxt_0 & (IS_REFINED_1|SELF_SIG_1|OUT_OF_BOUNDS_1)))
                {
                  d_ctxt_0 |= IS_REFINED_1;
                  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);
                      su_flags |= 0x100;
                      if (val)
                        { /* Negative sample. */
                          d_ctxt_0     |= SELF_SIG_1 | BC_SIG_0 | V_NVE_SIG_0;
                          d_ctxt_1     |= TC_SIG_0 | V_NVE_SIG_0;
                          d_cp[-2]     |= BR_SIG_0 | CR_SIG_1 | H_NVE_SIG_1;
                          d_cp[-1]     |= TR_SIG_0;
                          d_cp[2]      |= BL_SIG_0 | CL_SIG_1 | H_NVE_SIG_1;
                          d_cp[3]      |= TL_SIG_0;
                        }
                      else
                        { /* Positive sample. */
                          d_ctxt_0     |= SELF_SIG_1 | BC_SIG_0 | V_PVE_SIG_0;
                          d_ctxt_1     |= TC_SIG_0 | V_PVE_SIG_0;
                          d_cp[-2]     |= BR_SIG_0 | CR_SIG_1 | H_PVE_SIG_1;
                          d_cp[-1]     |= TR_SIG_0;
                          d_cp[2]      |= BL_SIG_0 | CL_SIG_1 | H_PVE_SIG_1;
                          d_cp[3]      |= TL_SIG_0;
                        }
                      val |= lsb + (lsb>>1);
                      dp[1] = val;
                    }
                }

              if ((d_ctxt_1 & ZC_MASK_0) &&
                  !(d_ctxt_1 & (IS_REFINED_0|SELF_SIG_0|OUT_OF_BOUNDS_0)))
                {
                  d_ctxt_1 |= IS_REFINED_0;
                  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);
                      su_flags |= 0x100;
                      if (val)
                        { /* Negative sample. */
                          d_ctxt_0     |= BC_SIG_1 | V_NVE_SIG_1;
                          d_ctxt_1     |= SELF_SIG_0 | TC_SIG_1 | V_NVE_SIG_1;
                          d_cp[-2]     |= BR_SIG_1;
                          d_cp[-1]     |= TR_SIG_1 | CR_SIG_0 | H_NVE_SIG_0;
                          d_cp[2]      |= BL_SIG_1;
                          d_cp[3]      |= TL_SIG_1 | CL_SIG_0 | H_NVE_SIG_0;
                        }
                      else
                        { /* Positive sample. */
                          d_ctxt_0     |= BC_SIG_1 | V_PVE_SIG_1;
                          d_ctxt_1     |= SELF_SIG_0 | TC_SIG_1 | V_PVE_SIG_1;
                          d_cp[-2]     |= BR_SIG_1;
                          d_cp[-1]     |= TR_SIG_1 | CR_SIG_0 | H_PVE_SIG_0;
                          d_cp[2]      |= BL_SIG_1;
                          d_cp[3]      |= TL_SIG_1 | CL_SIG_0 | H_PVE_SIG_0;
                        }
                      val |= lsb + (lsb>>1);
                      dp[2] = val;
                    }
                }

              if ((d_ctxt_1 & ZC_MASK_1) &&
                  !(d_ctxt_1 & (IS_REFINED_1|SELF_SIG_1|OUT_OF_BOUNDS_1)))
                {
                  d_ctxt_1 |= IS_REFINED_1;
                  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);
                      su_flags |= 0x100;
                      sup[sup_gap-2] |= 1<<(16-i);
                      if (val)
                        { /* Negative sample. */
                          d_ctxt_1     |= SELF_SIG_1 | BC_SIG_0 | V_NVE_SIG_0;
                          d_cp[-1]     |= BR_SIG_0 | CR_SIG_1 | H_NVE_SIG_1;
                          d_cp[3]      |= BL_SIG_0 | CL_SIG_1 | H_NVE_SIG_1;
                          d_cp[d_stripe_gap-2]     |= TR_SIG_0;
                          d_cp[d_stripe_gap]       |= TC_SIG_0 | V_NVE_SIG_0;
                          d_cp[d_stripe_gap+2]     |= TL_SIG_0;
                        }
                      else
                        { /* Positive sample. */
                          d_ctxt_1     |= SELF_SIG_1 | BC_SIG_0 | V_PVE_SIG_0;
                          d_cp[-1]     |= BR_SIG_0 | CR_SIG_1 | H_PVE_SIG_1;
                          d_cp[3]      |= BL_SIG_0 | CL_SIG_1 | H_PVE_SIG_1;
                          d_cp[d_stripe_gap-2]     |= TR_SIG_0;
                          d_cp[d_stripe_gap]       |= TC_SIG_0 | V_PVE_SIG_0;
                          d_cp[d_stripe_gap+2]     |= TL_SIG_0;
                        }
                      val |= lsb + (lsb>>1);
                      dp[3] = val;
                    }
                }
              d_cp[0] = d_ctxt_0; d_cp[1] = d_ctxt_1;
            }
          sup[-2] = (su_flags & 0x00FF) << 8;
        }
    }
  state->current_lsb = current_lsb; state->word = word;
}

/*****************************************************************************/
/* STATIC                  su_zero_refinement_pass_func                      */
/*****************************************************************************/

static void
  su_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 su_flags;
  register int i;
  register std_int cum_delta, thresh;
  register std_int d_ctxt_0, d_ctxt_1; /* Merge these if you have 64-bits. */
  register std_int *d_cp;
      /* Note: it is most beneficial if the above seven variables are
         held in registers. */
  register ifc_int *dp;
  register ifc_int shift;
  register dst_arith_state_ptr state;
  register dst_context_state_ptr csp;
  register ifc_int val, symbol;
  unsigned long creg;
  std_int areg;
  int ct;
  ifc_int lsb;
  std_int *supp, *sup;
  std_int non_causal;
  std_byte *zc_lut;
  int eighth_cols, d_stripe_gap, sup_gap, r, c;
  dst_context_state_ptr csp_base;

  if (master->bit_idx <= (master->first_bit_idx-master->full_effort_msbs))
    { su_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;
  eighth_cols = (master->width+7)>>3;
  d_st