ebcot_lite_decode_passes.c

JPEG2000实现的源码

                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;
            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[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;
            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[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;
          }
      }
  areg -= cum_delta; creg -= ((unsigned) cum_delta) << 16;
  state->mqd.areg = areg; state->mqd.creg = creg; state->mqd.ct = ct;
}

/*****************************************************************************/
/* STATIC                raw_mag_refinement_pass_func                        */
/*****************************************************************************/

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

  shift = master->bit_idx - 1;
  half_lsb = (1 << shift) >> 1;
  d_mask = SELF_SIG; d_mask <<= 16; d_mask |= SELF_SIG;
  state = &(master->coder_state);
  current_lsb = state->current_lsb; word = state->word;
  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]) & d_mask) == 0)
          continue;
        if ((((std_int *) cp)[0] & d_mask) == 0)
          goto skip2;
        
        ctxt = cp[0];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[0];
            dst_get_raw_bit(current_lsb,word,symbol,state);
            val ^= ((1-symbol)<<shift);
            val |= half_lsb;
            dp[0] = val; /* Write new non-zero value back to buffer. */
          }

        ctxt = cp[1];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[1];
            dst_get_raw_bit(current_lsb,word,symbol,state);
            val ^= ((1-symbol)<<shift);
            val |= half_lsb;
            dp[1] = val; /* Write new non-zero value back to buffer. */
          }
        if (!(((std_int *) cp)[1] & d_mask))
          continue;
skip2:
        ctxt = cp[2];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[2];
            dst_get_raw_bit(current_lsb,word,symbol,state);
            val ^= ((1-symbol)<<shift);
            val |= half_lsb;
            dp[2] = val; /* Write new non-zero value back to buffer. */
          }

        ctxt = cp[3];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[3];
            dst_get_raw_bit(current_lsb,word,symbol,state);
            val ^= ((1-symbol)<<shift);
            val |= half_lsb;
            dp[3] = val; /* Write new non-zero value back to buffer. */
          }
      }
  state->word = word; state->current_lsb = current_lsb;
}

/*****************************************************************************/
/* STATIC                  mag_refinement_pass_func                          */
/*****************************************************************************/

static void
  mag_refinement_pass_func(block_master_ptr master)

 /* This function refines all samples which have already been found to be
    significant. */

{
  register std_short *cp;
  register std_int d_mask;
  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 unsigned long creg;
  register std_int areg;
  int ct;
  ifc_int val, symbol, half_lsb;
  int cols, stripe_gap, r;
  dst_context_state_ptr csp_base;

  if (master->bit_idx <= (master->first_bit_idx-master->full_effort_msbs))
    { raw_mag_refinement_pass_func(master); return; }

  state = &(master->coder_state);
  if (!state->mqd.active)
    dst_arith_coder__activate(state);

  assert(master->bit_idx > 1);
  shift = master->bit_idx - 1;
  half_lsb = (1 << shift) >> 1;
  d_mask = SELF_SIG; d_mask <<= 16; d_mask |= SELF_SIG;
  areg = state->mqd.areg; creg = state->mqd.creg; ct = state->mqd.ct;
  csp_base = state->contexts;
  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]) & d_mask) == 0)
          continue;
        if ((((std_int *) cp)[0] & d_mask) == 0)
          goto skip2;

        ctxt = cp[0];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[0];
            symbol = (val & MAX_IFC_INT) >> shift;
            csp = csp_base + MAG_OFFSET;
            if (symbol < 4)
              {
                if (ctxt & 0x00FF)
                  csp++;
              }
            else
              csp += 2;
            dst_get_symbol(areg,creg,ct,state,symbol,csp);
            val ^= ((1-symbol)<<shift);
            val |= half_lsb;
            dp[0] = val; /* Write new non-zero value back to buffer. */
          }

        ctxt = cp[1];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[1];
            symbol = (val & MAX_IFC_INT) >> shift;
            csp = csp_base + MAG_OFFSET;
            if (symbol < 4)
              {
                if (ctxt & 0x00FF)
                  csp++;
              }
            else
              csp += 2;
            dst_get_symbol(areg,creg,ct,state,symbol,csp);
            val ^= ((1-symbol)<<shift);
            val |= half_lsb;
            dp[1] = val; /* Write new non-zero value back to buffer. */
          }
        if (!(((std_int *) cp)[1] & d_mask))
          continue;
skip2:
        ctxt = cp[2];
        if ((ctxt & (SELF_SIG | IS_REFINED)) == SELF_SIG)
          {
            val = dp[2];
            symbol = (val & MAX_IFC_INT) >> shift;
            csp = csp_base + MAG_OFFSET;
            if (symbol < 4)
              {
                if (ctxt & 0x00FF)
                  csp++;
              }
            else
              csp += 2;