ebcot_lite_encode_passes.c

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

  register int i;
  register std_short ctxt;
  register dst_arith_state_ptr state;
  ifc_int val, symbol, mask, lsb, shift;
  std_int word;
  std_short current_lsb;
  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;
  int eighth_cols, stripe_gap, r, c;

  shift = master->bit_idx - 1;
  lsb = 1 << shift;
  mask = (ifc_int)(MAX_IFC_INT & ((-1)<<shift));
  mse_lut = master->refinement_mse_lut;
  d_mask = SELF_SIG; d_mask <<= 16; d_mask |= SELF_SIG;
  mse_downshift = shift - (MSE_LUT_BITS-1);
  mse_upshift = (mse_downshift<0)?-mse_downshift:0;
  mse_downshift += mse_upshift;
  state = &(master->coder_state);
  current_lsb = state->current_lsb; word = state->word;
  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]) & d_mask) == 0)
              continue;
            if ((((std_int *) cp)[0] & d_mask) == 0)
              goto skip2;

            ctxt = cp[0];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[0];
                val &= MAX_IFC_INT;
                symbol = (val >> shift) & 1;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                dst_emit_raw_bit(current_lsb,word,symbol,state);
              }

            ctxt = cp[1];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[1];
                val &= MAX_IFC_INT;
                symbol = (val >> shift) & 1;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                dst_emit_raw_bit(current_lsb,word,symbol,state);
              }
            if (!(((std_int *) cp)[1] & d_mask))
              continue;
skip2:
            ctxt = cp[2];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[2];
                val &= MAX_IFC_INT;
                symbol = (val >> shift) & 1;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                dst_emit_raw_bit(current_lsb,word,symbol,state);
              }
            
            ctxt = cp[3];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[3];
                val &= MAX_IFC_INT;
                symbol = (val >> shift) & 1;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                dst_emit_raw_bit(current_lsb,word,symbol,state);
              }
          }
      }
  state->current_lsb = current_lsb; state->word = word;
}

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

static void /* David T Cvis mod */
  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 i;
  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;
  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;
  dst_context_state_ptr csp_base;
  int eighth_cols, stripe_gap, r, c;

  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->mqe.active)
    dst_arith_coder__activate(state);

  assert(master->bit_idx > 1);
  shift = master->bit_idx - 1;
  lsb = 1 << shift;
  mask = (ifc_int)(MAX_IFC_INT & ((-1)<<shift));
  mse_lut = master->refinement_mse_lut;
  d_mask = SELF_SIG; d_mask <<= 16; d_mask |= SELF_SIG;
  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;
  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]) & d_mask) == 0)
              continue;
            if ((((std_int *) cp)[0] & d_mask) == 0)
              goto skip2;

            ctxt = cp[0];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[0];
                val &= MAX_IFC_INT;
                symbol = val >> shift;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                csp = csp_base + MAG_OFFSET;
                if (symbol < 4)
                  {
                    if (ctxt & 0x00FF)
                      csp++;
                  }
                else
                  csp += 2;
                symbol &= 1; /* New magnitude bit. */
                dst_emit_symbol(areg,creg,ct,state,symbol,csp);
              }

            ctxt = cp[1];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[1];
                val &= MAX_IFC_INT;
                symbol = val >> shift;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                csp = csp_base + MAG_OFFSET;
                if (symbol < 4)
                  {
                    if (ctxt & 0x00FF)
                      csp++;
                  }
                else
                  csp += 2;
                symbol &= 1; /* New magnitude bit. */
                dst_emit_symbol(areg,creg,ct,state,symbol,csp);
              }
            if (!(((std_int *) cp)[1] & d_mask))
              continue;
skip2:
            ctxt = cp[2];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[2];
                val &= MAX_IFC_INT;
                symbol = val >> shift;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                csp = csp_base + MAG_OFFSET;
                if (symbol < 4)
                  {
                    if (ctxt & 0x00FF)
                      csp++;
                  }
                else
                  csp += 2;
                symbol &= 1; /* New magnitude bit. */
                dst_emit_symbol(areg,creg,ct,state,symbol,csp);
              }

            ctxt = cp[3];
            if ((ctxt & SELF_SIG) && !(ctxt & IS_REFINED))
              {
                val = dp[3];
                val &= MAX_IFC_INT;
                symbol = val >> shift;
                val >>= mse_downshift; val <<= mse_upshift;
                cell->delta_mse +=
                  mse_lut[val & MSE_LUT_MASK]; /* David T Cvis mod */
                csp = csp_base + MAG_OFFSET;
                if (symbol < 4)
                  {
                    if (ctxt & 0x00FF)
                      csp++;
                  }
                else
                  csp += 2;
                symbol &= 1; /* New magnitude bit. */
                dst_emit_symbol(areg,creg,ct,state,symbol,csp);
              }
          }
      }
  state->mqe.areg = areg; state->mqe.creg = creg; state->mqe.ct = ct;
}


/* ========================================================================= */
/* --------------------------- External Functions -------------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* EXTERN                      ebcot_set_pass_funcs                          */
/*****************************************************************************/

void
  ebcot_set_pass_funcs(ebcot_band_info_ptr band,
                       block_master_ptr master)
{
  int p;

  for (p=0; p < PASSES_PER_BITPLANE; p++)
    if (p == 0)
      band->pass_funcs[0] = first_pass_func;
    else if (p == 1)
      band->pass_funcs[p] = zero_refinement_pass_func;
    else if (p == 2)
      band->pass_funcs[p] = mag_refinement_pass_func;
    else
      assert(0);
}