getblk.c

H.263的压缩算法

/************************************************************************
 *
 *  getblk.c, DCT block decoding for tmndecode (H.263 decoder)
 *  Copyright (C) 1995, 1996  Telenor R&D, Norway
 *
 *  Contacts:
 *  Robert Danielsen                  <[e-mail]>
 *
 *  Telenor Research and Development  http://www.nta.no/brukere/DVC/
 *  P.O.Box 83                        tel.:   [phone]
 *  N-2007 Kjeller, Norway            fax.:   [phone]
 *
 *  Copyright (C) 1997  University of BC, Canada
 *  Modified by: Michael Gallant <[e-mail]>
 *               Guy Cote <[e-mail]>
 *               Berna Erol <[e-mail]>
 *
 *  Contacts:
 *  Michael Gallant                   <[e-mail]>
 *
 *  UBC Image Processing Laboratory   http://www.ee.ubc.ca/image
 *  2356 Main Mall                    tel.: [phone]
 *  Vancouver BC Canada V6T1Z4        fax.: [phone]
 *
 ************************************************************************/

/* Disclaimer of Warranty
 * 
 * These software programs are available to the user without any license fee
 * or royalty on an "as is" basis. The University of British Columbia
 * disclaims any and all warranties, whether express, implied, or
 * statuary, including any implied warranties or merchantability or of
 * fitness for a particular purpose.  In no event shall the
 * copyright-holder be liable for any incidental, punitive, or
 * consequential damages of any kind whatsoever arising from the use of
 * these programs.
 * 
 * This disclaimer of warranty extends to the user of these programs and
 * user's customers, employees, agents, transferees, successors, and
 * assigns.
 * 
 * The University of British Columbia does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any
 * third-party patents.
 * 
 * Commercial implementations of H.263, including shareware, are subject to
 * royalty fees to patent holders.  Many of these patents are general
 * enough such that they are unavoidable regardless of implementation
 * design.
 * 
 */


/* based on mpeg2decode, (C) 1994, MPEG Software Simulation Group and
 * mpeg2play, (C) 1994 Stefan Eckart <[e-mail]>
 * 
 */


#include <stdio.h>
#include <stdlib.h>

#include "config.h"
#include "tmndec.h"
#include "global.h"

#define INDICES
#include "indices.h"

#define SACTABLES
#include "sactbls.h"


typedef struct
{
  char run, level, len;
} DCTtab;
typedef struct
{
  int val, len;
} VLCtabI;
typedef struct
{
  int val, run, sign;
} RunCoef;

typedef struct
{
  int code, level, last, run, sign, extended_level;
} CodeCoeff;



/* local prototypes */
RunCoef vlc_word_decode _ANSI_ARGS_ ((int symbol_word, int *last));
RunCoef Decode_Escape_Char _ANSI_ARGS_ ((int intra, int *last));
int DecodeTCoef _ANSI_ARGS_ ((int position, int intra));



extern VLCtabI DCT3Dtab0[], DCT3Dtab1[], DCT3Dtab2[];

/* Tables used in advanced intra coding mode */
extern VLCtabI INTRA_DCT3Dtab0[], INTRA_DCT3Dtab1[], INTRA_DCT3Dtab2[];

extern MQ_chroma_QP_table[];

void getblock (int comp, int mode, int INTRA_AC_DC, int Mode)
{
  int val, i, j, sign;
  unsigned int code;
  VLCtabI *tab;
  short *bp;
  int run, last, level, QP;
  short *qval;


  /* store_code used in alternative inter VLC mode */
  int use_intra = 0;
  CodeCoeff store_code[64];
  int coeff_ind;

  bp = ld->block[comp];

  /* decode AC coefficients (or all coefficients in advanced intra coding
   * mode) */
  if (trace)
    fprintf (trace_file, "block: %i\n", comp);

  if (alternative_inter_VLC_mode && !(Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
  {
    coeff_ind = 0;
    use_intra = 0;
    for (i = (mode == 0);; i++)
    {
      code = showbits (12);
      store_code[coeff_ind].code = code;
      if (code >= 512)
        tab = &DCT3Dtab0[(code >> 5) - 16];
      else if (code >= 128)
        tab = &DCT3Dtab1[(code >> 2) - 32];
      else if (code >= 8)
        tab = &DCT3Dtab2[(code >> 0) - 8];
      else
      {
        if (!quiet)
          fprintf (stderr, "invalid Huffman code in getblock()\n");
        fault = 1;
        return;
      }

      run = (tab->val >> 4) & 255;
      last = (tab->val >> 12) & 1;
      flushbits (tab->len);
      if (tab->val == ESCAPE)
      {
        last = getbits1 ();
        store_code[coeff_ind].last = last;

        i += run = getbits (6);
        store_code[coeff_ind].run = run;

        level = getbits (8);
        store_code[coeff_ind].level = level;


        if (level == 128 && modified_quantization_mode)
        {
          level = getbits (11);
          store_code[coeff_ind].extended_level = level;
        }
      } else
      {
        store_code[coeff_ind].sign = getbits (1);
        i += run;
      }
      coeff_ind += 1;

      if (i >= 64)
        use_intra = 1;
      if (last)
        break;
    }
    if (trace)
      fprintf (trace_file, "inter VLC Table: %s\n", (use_intra ? "Intra" : "Inter"));
  }
  coeff_ind = 0;

  for (i = (mode == 0);; i++)
  {
    if ((alternative_inter_VLC_mode) && !(Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
    {
      if (use_intra)
      {
        if ((store_code[coeff_ind].code) >= 512)
          tab = &INTRA_DCT3Dtab0[((store_code[coeff_ind].code) >> 5) - 16];
        else if ((store_code[coeff_ind].code) >= 128)
          tab = &INTRA_DCT3Dtab1[((store_code[coeff_ind].code) >> 2) - 32];
        else if ((store_code[coeff_ind].code) >= 8)
          tab = &INTRA_DCT3Dtab2[((store_code[coeff_ind].code) >> 0) - 8];
        else
        {
          if (!quiet)
            fprintf (stderr, "invalid Huffman code in getblock()\n");
          fault = 1;
          return;
        }
        run = (tab->val >> 6) & 63;
        level = tab->val & 63;
        last = (tab->val >> 12) & 1;
      } else
      {
        if (store_code[coeff_ind].code >= 512)
          tab = &DCT3Dtab0[(store_code[coeff_ind].code >> 5) - 16];
        else if (store_code[coeff_ind].code >= 128)
          tab = &DCT3Dtab1[(store_code[coeff_ind].code >> 2) - 32];
        else if (store_code[coeff_ind].code >= 8)
          tab = &DCT3Dtab2[(store_code[coeff_ind].code >> 0) - 8];
        else
        {
          if (!quiet)
            fprintf (stderr, "invalid Huffman code in getblock()\n");
          fault = 1;
          return;
        }

        run = (tab->val >> 4) & 255;
        level = tab->val & 15;
        last = (tab->val >> 12) & 1;
      }

      if (trace)
      {
        fprintf (trace_file, " (");
        printbits (store_code[coeff_ind].code, 12, tab->len);
      }
      if (tab->val == ESCAPE)
      {                         /* escape */
        if (trace)
        {
          fprintf (trace_file, " ");
          printbits (store_code[coeff_ind].last, 1, 1);
        }
        last = store_code[coeff_ind].last;
        if (trace)
        {
          fprintf (trace_file, " ");
          printbits (store_code[coeff_ind].run, 6, 6);
        }
        i += run = store_code[coeff_ind].run;
        if (trace)
        {
          fprintf (trace_file, " ");
          printbits (store_code[coeff_ind].level, 8, 8);
        }
        level = store_code[coeff_ind].level;

        if ((sign = (level >= 128)))
          val = 256 - level;
        else
          val = level;

        if (level == 128 && modified_quantization_mode)
        {
          level = store_code[coeff_ind].extended_level;
          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
      {
        sign = store_code[coeff_ind].sign;
        i += run;
        val = level;

        if (trace)
          fprintf (trace_file, "%d", sign);
      }
      coeff_ind += 1;

    } else
    {
      code = showbits (12);
      if ((advanced_intra_coding) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
      {
        if (code >= 512)
          tab = &INTRA_DCT3Dtab0[(code >> 5) - 16];
        else if (code >= 128)
          tab = &INTRA_DCT3Dtab1[(code >> 2) - 32];
        else if (code >= 8)
          tab = &INTRA_DCT3Dtab2[(code >> 0) - 8];
        else
        {
          if (!quiet)
            fprintf (stderr, "invalid Huffman code in getblock()\n");
          fault = 1;
          return;
        }
        run = (tab->val >> 6) & 63;
        level = tab->val & 63;
        last = (tab->val >> 12) & 1;
      } else
      {

        if (code >= 512)
          tab = &DCT3Dtab0[(code >> 5) - 16];
        else if (code >= 128)
          tab = &DCT3Dtab1[(code >> 2) - 32];
        else if (code >= 8)
          tab = &DCT3Dtab2[(code >> 0) - 8];
        else
        {
          if (!quiet)
            fprintf (stderr, "invalid Huffman code in getblock()\n");
          fault = 1;
          return;
        }

        run = (tab->val >> 4) & 255;
        level = tab->val & 15;
        last = (tab->val >> 12) & 1;
      }
      flushbits (tab->len);
      if (trace)
      {
        fprintf (trace_file, " (");
        printbits (code, 12, tab->len);
      }
      if (tab->val == ESCAPE)
      {                         /* escape */
        if (trace)
        {
          fprintf (trace_file, " ");
          printbits (showbits (1), 1, 1);
        }
        last = getbits1 ();
        if (trace)
        {
          fprintf (trace_file, " ");
          printbits (showbits (6), 6, 6);
        }
        i += run = getbits (6);
        if (trace)
        {
          fprintf (trace_file, " ");
          printbits (showbits (8), 8, 8);
        }
        level = getbits (8);

        if ((sign = (level >= 128)))
          val = 256 - level;
        else
          val = level;

        if (level == 128 && modified_quantization_mode)
        {
          /* extended escape code was received */
          level = getbits (11);