getblk.c

H.263的压缩算法

          level = (level >> 6 & 0x001F) | level << 5;
          /* correctly set the sign */
          level = (level << (sizeof (int) * 8 - 11)) >> (sizeof (int) * 8 - 11);
          if (level >= 0)
            sign = 0;
          else
            sign = 1;
          val = abs (level);
        }
      } else
      {
        i += run;
        val = level;
        sign = getbits (1);
        if (trace)
          fprintf (trace_file, "%d", sign);
      }
    }

    if (i >= 64)
    {
      if (!quiet)
        fprintf (stderr, "DCT coeff index (i) out of bounds\n");
      fault = 1;
      return;
    }
    if (trace)
      fprintf (trace_file, "): %d/%d\n", run, sign ? -val : val);

    /* Descan in the proper order in advanced intra coding mode */

    if (advanced_intra_coding && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
    {
      switch (INTRA_AC_DC)
      {
        case INTRA_MODE_DC:
          j = zig_zag_scan[i];
          break;
        case INTRA_MODE_VERT_AC:
          j = alternate_horizontal_scan[i];
          break;
        case INTRA_MODE_HORI_AC:
          j = alternate_vertical_scan[i];
          break;
        default:
          printf ("Invalid Intra_Mode in Advanced Intra Coding\n");
          exit (-1);
          break;
      }
    } else
    {
      j = zig_zag_scan[i];
    }
    qval = &bp[j];
    if (comp >= 6)
      QP = mmax (1, mmin (31, (bquant_tab[bquant] * quant) >> 2));
    else
      QP = quant;

    if (modified_quantization_mode && (comp == 4 || comp == 5 || comp == 10 || comp == 11))
    {
      /* when modified quantization mode is on, use modified quantizer for
       * chorominance coefficients */

      QP = MQ_chroma_QP_table[QP];
    }
    if ((advanced_intra_coding) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
    {
      /* Advanced intra coding dequantization */
      *qval = (sign ? -(QP * (2 * val)) : QP * (2 * val));
    } else
    {
      /* TMN3 dequantization */
      if ((QP % 2) == 1)
        *qval = (sign ? -(QP * (2 * val + 1)) : QP * (2 * val + 1));
      else
        *qval = (sign ? -(QP * (2 * val + 1) - 1) : QP * (2 * val + 1) - 1);
    }
    if (last)
    {                           /* That's it */
      if (trace)
        fprintf (trace_file, "last\n------------------------------------------------------------------\n");
      return;
    }
  }
}



/*********************************************************************
 *
 *        Name:        get_sac_block
 *
 *	Description:	Decodes blocks of Arithmetic Encoded DCT Coeffs.
 *        and performs Run Length Decoding and Coefficient
 *        Dequantisation.
 *
 *	Input:        Picture block type and number.
 *
 *	Returns:	Nothing.
 *
 *	Side Effects:
 *
 *	Author:        Wayne Ellis <[e-mail]>
 *
 *********************************************************************/


void get_sac_block (int comp, int ptype, int INTRA_AC_DC, int Mode)
{
  int position = 0;
  int TCOEF_index, symbol_word;
  int last = 0, QP, i, j;
  short *qval;
  short *bp;
  RunCoef DCTcoef;
  int intra;


  bp = ld->block[comp];

  i = (ptype == 0);
  intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);

  while (!last)
  {                             /* while there are DCT coefficients
                                 * remaining */
    position++;                 /* coefficient counter relates to Coeff.
                                 * model */
    TCOEF_index = DecodeTCoef (position, intra);

    if (TCOEF_index == ESCAPE_INDEX)
    {                           /* ESCAPE code encountered */
      DCTcoef = Decode_Escape_Char (intra, &last);
      if (trace)
        fprintf (trace_file, "ESC: ");
    } else
    {
      symbol_word = tcoeftab[TCOEF_index];

      DCTcoef = vlc_word_decode (symbol_word, &last);
    }

    if (trace)
    {
      fprintf (trace_file, "val: %d, run: %d, sign: %d, last: %d\n",
               DCTcoef.val, DCTcoef.run, DCTcoef.sign, last);
    }
    i += DCTcoef.run;
    if (advanced_intra_coding && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
    {
      switch (INTRA_AC_DC)
      {
        case INTRA_MODE_DC:
          j = zig_zag_scan[i];
          break;
        case INTRA_MODE_VERT_AC:
          j = alternate_horizontal_scan[i];
          break;
        case INTRA_MODE_HORI_AC:
          j = alternate_vertical_scan[i];
          break;
        default:
          printf ("Invalid Intra_Mode in Advanced Intra Coding");
          exit (-1);
          break;
      }
    } else
    {
      j = zig_zag_scan[i];
    }

    qval = &bp[j];

    i++;

    if (comp >= 6)
      QP = mmax (1, mmin (31, (bquant_tab[bquant] * quant) >> 2));
    else
      QP = quant;
    if ((advanced_intra_coding) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
    {
      /* Advanced intra coding dequantization */
      *qval = (DCTcoef.sign ? -(QP * (2 * DCTcoef.val)) : QP * (2 * DCTcoef.val));
    } else
    {

      if ((QP % 2) == 1)
        *qval = ((DCTcoef.sign) ? -(QP * (2 * (DCTcoef.val) + 1)) :
                 QP * (2 * (DCTcoef.val) + 1));
      else
        *qval = ((DCTcoef.sign) ? -(QP * (2 * (DCTcoef.val) + 1) - 1) :
                 QP * (2 * (DCTcoef.val) + 1) - 1);
    }
  }
  return;
}

/*********************************************************************
 *
 *        Name:        vlc_word_decode
 *
 *	Description:	Fills Decoder FIFO after a fixed word length
 *        string has been detected.
 *
 *	Input:        Symbol to be decoded, last data flag.
 *
 *	Returns:	Decoded Symbol via the structure DCTcoeff.
 *
 *	Side Effects:	Updates last flag.
 *
 *	Author:        Wayne Ellis <[e-mail]>
 *
 *********************************************************************/

RunCoef vlc_word_decode (int symbol_word, int *last)
{
  int sign_index;
  RunCoef DCTcoef;

  *last = (symbol_word >> 12) & 01;

  DCTcoef.run = (symbol_word >> 4) & 255;

  DCTcoef.val = (symbol_word) & 15;

  sign_index = decode_a_symbol (cumf_SIGN);

  DCTcoef.sign = signtab[sign_index];

  return (DCTcoef);
}

/*********************************************************************
 *
 *        Name:        Decode_Escape_Char
 *
 *	Description:	Decodes all components for a Symbol when an
 *        ESCAPE character has been detected.
 *
 *	Input:        Picture Type and last data flag.
 *
 *	Returns:	Decoded Symbol via the structure DCTcoeff.
 *
 *	Side Effects:	Modifies last data flag.
 *
 *	Author:        Wayne Ellis <[e-mail]>
 *
 *********************************************************************/

RunCoef Decode_Escape_Char (int intra, int *last)
{
  int last_index, run, run_index, level, level_index;
  RunCoef DCTcoef;

  if (intra)
  {
    last_index = decode_a_symbol (cumf_LAST_intra);
    *last = last_intratab[last_index];
  } else
  {
    last_index = decode_a_symbol (cumf_LAST);
    *last = lasttab[last_index];
  }

  if (intra)
    run_index = decode_a_symbol (cumf_RUN_intra);
  else
    run_index = decode_a_symbol (cumf_RUN);

  run = runtab[run_index];

  /* $if (mrun) run|=64;$ */

  DCTcoef.run = run;

  if (intra)
    level_index = decode_a_symbol (cumf_LEVEL_intra);
  else
    level_index = decode_a_symbol (cumf_LEVEL);

  if (trace)
    fprintf (trace_file, "level_idx: %d ", level_index);

  level = leveltab[level_index];

  if (level > 128)
    level -= 256;

  if (level < 0)
  {
    DCTcoef.sign = 1;
    DCTcoef.val = abs (level);
  } else
  {
    DCTcoef.sign = 0;
    DCTcoef.val = level;
  }

  return (DCTcoef);

}
/*********************************************************************
 *
 *        Name:        DecodeTCoef
 *
 *	Description:	Decodes a.c DCT Coefficients using the
 *        relevant arithmetic decoding model.
 *
 *	Input:        DCT Coeff count and Picture Type.
 *
 *	Returns:	Index to LUT
 *
 *	Side Effects:	None
 *
 *	Author:        Wayne Ellis <[e-mail]>
 *
 *********************************************************************/

int DecodeTCoef (int position, int intra)
{
  int index;

  switch (position)
  {
    case 1:
      {
        if (intra)
          index = decode_a_symbol (cumf_TCOEF1_intra);
        else
          index = decode_a_symbol (cumf_TCOEF1);
        break;
      }
    case 2:
      {
        if (intra)
          index = decode_a_symbol (cumf_TCOEF2_intra);
        else
          index = decode_a_symbol (cumf_TCOEF2);
        break;
      }
    case 3:
      {
        if (intra)
          index = decode_a_symbol (cumf_TCOEF3_intra);
        else
          index = decode_a_symbol (cumf_TCOEF3);
        break;
      }
    default:
      {
        if (intra)
          index = decode_a_symbol (cumf_TCOEFr_intra);
        else
          index = decode_a_symbol (cumf_TCOEFr);
        break;
      }
  }

  return (index);
}