ebcot_lite_encode_passes.c

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

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

static void /* David T Cvis mod */
  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 int i;
  register ifc_int *dp;
  register std_short ctxt;
  register dst_arith_state_ptr state;
  register dst_context_state_ptr csp;
  register std_int areg, creg;
  std_short ct;
  ifc_int val, symbol, mask, lsb, shift;
  std_byte *zc_lut;
  ifc_int mse_upshift, mse_downshift;
  distortion_cell_ptr cell; /* David T Cvis mod */
  int cell_gap; /* David T Cvis mod */
  std_short *mse_lut, non_causal;
  int eighth_cols, stripe_gap, r, c;
  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->mqe.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;
  mask = (ifc_int)(MAX_IFC_INT & ((-1)<<shift));
  mse_lut = master->initial_mse_lut;
  mse_downshift = shift - (MSE_LUT_BITS-1);
  mse_upshift = (mse_downshift<0)?-mse_downshift:0;
  mse_downshift += mse_upshift;
  areg = state->mqe.areg; creg = state->mqe.creg; ct = state->mqe.ct;
  csp_base = state->contexts;
  zc_lut = master->zc_lut;
  non_causal = 1 - master->causal;
  eighth_cols = (master->width+7) >> 3;
  stripe_gap = master->interleaved_row_gap;
  cell_gap = master->d_cell_row_gap; /* David T Cvis mod */
  cp = master->interleaved_context_buffer;
  dp = master->interleaved_sample_buffer;
  cell = master->d_cells; /* David T Cvis mod */
  for (r=master->stripes; r > 0; r--,
       dp+=stripe_gap-(eighth_cols<<5), cp+=stripe_gap-(eighth_cols<<5),
       cell += ((r&1)?0:cell_gap)-eighth_cols) /* David T Cvis mod */
    for (c=eighth_cols; c > 0; c--, cell++) /* David T Cvis mod */
      {
        for (i=8; i > 0; i--, 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;
                val = dp[0];
                symbol = (val & mask);
                csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
                dst_emit_symbol(areg,creg,ct,state,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));
                    cell->delta_mse += mse_lut[val]; /* David T Cvis mod */
                    symbol = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                    csp = csp_base + SC_OFFSET + (symbol & 0x000F);
                    symbol &= MIN_IFC_INT;
                    symbol ^= sign;
                    dst_emit_symbol(areg,creg,ct,state,symbol,csp);
                    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 (sign)
                      { /* 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;
                      }
                  }
                cp[0] = ctxt;
              }

            ctxt = cp[1];
            if ((ctxt & 0x00FF) &&
                !(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]);
                dst_emit_symbol(areg,creg,ct,state,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));
                    cell->delta_mse += mse_lut[val]; /* David T Cvis mod */
                    symbol = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                    csp = csp_base + SC_OFFSET + (symbol & 0x000F);
                    symbol &= MIN_IFC_INT;
                    symbol ^= sign;
                    dst_emit_symbol(areg,creg,ct,state,symbol,csp);
                    ctxt |= SELF_SIG;
                    cp[0-4]                |= BR_SIG;
                    cp[0+4]                |= BL_SIG;
                    cp[2-4]                |= TR_SIG;
                    cp[2+4]                |= TL_SIG;
                    if (sign)
                      { /* 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;
                      }
                  }
                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;
                val = dp[2];
                symbol = (val & mask);
                csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
                dst_emit_symbol(areg,creg,ct,state,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));
                    cell->delta_mse += mse_lut[val]; /* David T Cvis mod */
                    symbol = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                    csp = csp_base + SC_OFFSET + (symbol & 0x000F);
                    symbol &= MIN_IFC_INT;
                    symbol ^= sign;
                    dst_emit_symbol(areg,creg,ct,state,symbol,csp);
                    ctxt |= SELF_SIG;
                    cp[1-4]                |= BR_SIG;
                    cp[1+4]                |= BL_SIG;
                    cp[3-4]                |= TR_SIG;
                    cp[3+4]                |= TL_SIG;
                    if (sign)
                      { /* 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;
                      }
                  }
                cp[2] = ctxt;
              }

            ctxt = cp[3];
            if ((ctxt & 0x00FF) &&
                !(ctxt & (IS_REFINED|SELF_SIG|OUT_OF_BOUNDS)))
              {
                ctxt |= IS_REFINED;
                val = dp[3];
                symbol = (val & mask);
                csp = csp_base + (ZC_OFFSET + zc_lut[ctxt & ZC_MASK]);
                dst_emit_symbol(areg,creg,ct,state,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));
                    cell->delta_mse += mse_lut[val]; /* David T Cvis mod */
                    symbol = ebcot_sc_lut[(ctxt>>SIGN_POS)&0x00FF];
                    csp = csp_base + SC_OFFSET + (symbol & 0x000F);
                    symbol &= MIN_IFC_INT;
                    symbol ^= sign;
                    dst_emit_symbol(areg,creg,ct,state,symbol,csp);
                    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 (sign)
                      { /* 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;
                      }
                  }
                cp[3] = ctxt;
              }
          }
      }
  state->mqe.areg = areg; state->mqe.creg = creg; state->mqe.ct = ct;
}

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

static void /* David T Cvis mod */
  raw_mag_refinement_pass_func(block_master_ptr master)

 /* Version of `mag_refinement_pass_func' which outputs raw binary digits,
    bypassing the arithmetic coding engine. */

{
  register std_short *cp;
  register std_int d_mask;
  register ifc_int *dp;