Huff.h

Go to the documentation of this file.

/* Copyright (C) 1998 Oregon Graduate Institute of Science & Technology
 * Copyright (c) 1995 The Regents of the University of California.
 * 
 * See the file COPYRIGHT, which should have been supplied with this
 * package, for licensing details.  We may be contacted through email
 * at <quasar-help@cse.ogi.edu>.
 */

#ifndef HUFF_H
#define HUFF_H

#include "bitwise.h"

#define SPEG_DCT_DC_SIZE(cur, type, totbits) \
    do { \
        SPEG_BW_GETHUFFN(cur, res, Huff::dct_dc_size_##type, .num_bits, 5); \
        if (res != 31) { \
            bits = Huff::dct_dc_size_##type[res].num_bits; \
            val = Huff::dct_dc_size_##type[res].value; \
            res >>= 5 - bits; \
        } \
        else { \
            SPEG_BW_GETHUFFN(cur, res, Huff::dct_dc_size_##type##1, .num_bits, (totbits - 5)); \
            bits = Huff::dct_dc_size_##type##1[res].num_bits + 5; \
            val = Huff::dct_dc_size_##type##1[res].value; \
            if (res == SPEG_ERROR)      goto fail_slice; \
            res |= (31 << (totbits - 5)); \
            res >>= totbits - bits; \
        } \
    } while (0)

#define SPEG_COEFF_RD(cur, dct_coeff, r, l) \
    do { \
        SPEG_BW_GETHUFFN(cur, res, dct_coeff, .num_bits, 8); \
        r = dct_coeff[res].run; \
        l = dct_coeff[res].level; \
        if (!l) { \
            if (r == ESCAPE) { \
                SPEG_BW_GETN(cur, res, 14); \
                r = res >> 8; \
                if (res & 0x7f) \
                    l = (int)((res & 0xff) << 24) >> 24; \
                else { \
                    SPEG_BW_GETN(cur, l, 8); \
                    if (res & 0x80) { \
                        if (!l) \
                            goto fail_slice; \
                        l -= 256; \
                    } \
                } \
            } \
            else if (r == SUBTABLE) { \
                SPEG_BW_GETHUFFN(cur, res, Huff::dct_coeff_sub, .num_bits, 10); \
                r = Huff::dct_coeff_sub[res].run; \
                l = Huff::dct_coeff_sub[res].level; \
                if (r == SPEG_ERROR)    goto fail_slice; \
                SPEG_BW_GETN(cur, res, 1); \
                if (res) \
                    l = -l; \
            } \
        } \
        else if (r != END_OF_BLOCK) { \
            SPEG_BW_GETN(cur, res, 1); \
            if (res) \
                l = -l; \
        } \
    } while (0)

#define SPEG_COEFF_WR(out, r, l) \
    do { \
        int tmp = l; \
        int sign = tmp < 0; \
        if (sign) \
            tmp = -tmp; \
        --tmp; \
        if (tmp < 40 && r < 32) { \
            res = Huff::dct_coeff_encode[tmp][r].data; \
            if (res != SUBTABLE) { \
                bits = Huff::dct_coeff_encode[tmp][r].num_bits; \
                res |= sign; \
                SPEG_BW_PUTN(out, res, bits); \
                break; \
            } \
        } \
        res = 0x40 | r; \
        if (tmp < 127) { \
            res <<= 8; \
            res |= l & 0xff; \
            SPEG_BW_PUTN(out, res, 20); \
        } \
        else { \
            res <<= 16; \
            res |= l & 0xff | (sign << 15); \
            SPEG_BW_PUTN(out, res, 28); \
        } \
    } while (0)

/* Misc DCT definitions */
//#define DCTSIZE               8       /* The basic DCT block is 8x8 samples */
//#define DCTSIZE2      64      /* DCTSIZE squared; # of elements in a block */
const int DCTSIZE = 8;
const int DCTSIZE2 = 64;

/* Structures for an entry in the decoding table of coded_block_pattern */
typedef struct {
  unsigned int cbp;            /* coded_block_pattern */
  int num_bits;                /* length of the Huffman code */
} coded_block_pattern_entry;

/* Structure for an entry in the decoding table of 
 * macroblock_address_increment */
typedef struct {
  int value;       /* value for macroblock_address_increment */
  int num_bits;             /* length of the Huffman code */
} mb_addr_inc_entry;

/* Structure for an entry in the decoding table of macroblock_type */
typedef struct {
  unsigned int mb_quant;              /* macroblock_quant */
  unsigned int mb_motion_forward;     /* macroblock_motion_forward */
  unsigned int mb_motion_backward;    /* macroblock_motion_backward */
  unsigned int mb_pattern;            /* macroblock_pattern */
  unsigned int mb_intra;              /* macroblock_intra */
  int num_bits;                       /* length of the Huffman code */
} mb_type_entry;

/* Structure for an entry in the decoding table of motion vectors */
typedef struct {
  int code;              /* value for motion_horizontal_forward_code,
                          * motion_vertical_forward_code, 
                          * motion_horizontal_backward_code, or
                          * motion_vertical_backward_code.
                          */
  int num_bits;          /* length of the Huffman code */
} motion_vectors_entry;

/* DCT coeff tables. */
typedef struct {
  int run;
  int level;
  int num_bits;
} dct_coeff_tab;

/* Structure for an entry in the decoding table of dct_dc_size */
typedef struct {
  unsigned int value;    /* value of dct_dc_size (luminance or chrominance) */
  int num_bits;          /* length of the Huffman code */
} dct_dc_size_entry;

typedef struct {
  //unsigned int data;
  int data;
  int num_bits;
} dct_coeff_encode_tab;  

typedef short DCTELEM;
typedef DCTELEM DCTBLOCK[DCTSIZE2];
 
/* Code for unbound values in decoding tables */
const int SPEG_ERROR = (-0x7fff);
 
const int SPEG_MACRO_BLOCK_STUFFING = 0;
const int SPEG_MACRO_BLOCK_ESCAPE = 34;

/* Two types of DCT Coefficients */
const int DCT_COEFF_FIRST = 0;
const int DCT_COEFF_NEXT = 1;

/* Special values for DCT Coefficients */
const int END_OF_BLOCK = 64;
const int ESCAPE = 0;
const int SUBTABLE = -1;


class Huff 
{

 public:

/* Decoding table for macroblock_address_increment */
  //extern mb_addr_inc_entry mb_addr_inc[2048];
  static mb_addr_inc_entry mb_addr_inc[];


  /* Decoding table for macroblock_type in I-frame pictures */
  //extern mb_type_entry mb_type_I[4];
  static mb_type_entry mb_type_I[];

  /* Decoding table for macroblock_type in predictive-coded pictures */
  //extern mb_type_entry mb_type_P[64];
  static mb_type_entry mb_type_P[];

  /* Decoding table for macroblock_type in bidirectionally-coded pictures */
  //extern mb_type_entry mb_type_B[64];
  static mb_type_entry mb_type_B[];


  /* External declaration of coded block pattern table. */
  //extern coded_block_pattern_entry coded_block_pattern[512];
  static coded_block_pattern_entry coded_block_pattern[];



  /* Decoding table for motion vectors */
  //extern motion_vectors_entry motion_vectors[2048];
  static motion_vectors_entry motion_vectors[];


  /* External declaration of dct dc size lumiance table. */
  //extern dct_dc_size_entry dct_dc_size_luminance[32];
  //extern dct_dc_size_entry dct_dc_size_luminance1[16];
  static dct_dc_size_entry dct_dc_size_luminance[];
  static dct_dc_size_entry dct_dc_size_luminance1[];

  /* External declaration of dct dc size chrom table. */
  //extern dct_dc_size_entry dct_dc_size_chrominance[32];
  //extern dct_dc_size_entry dct_dc_size_chrominance1[32];
  static dct_dc_size_entry dct_dc_size_chrominance[];
  static dct_dc_size_entry dct_dc_size_chrominance1[];


  //extern dct_coeff_tab dct_coeff_first[256];
  //extern dct_coeff_tab dct_coeff_next[256];
  //extern dct_coeff_tab dct_coeff_sub[1024];
  static dct_coeff_tab dct_coeff_first[];
  static dct_coeff_tab dct_coeff_next[];
  static dct_coeff_tab dct_coeff_sub[];
  
  //extern dct_coeff_encode_tab dct_coeff_encode[40][32];
  static dct_coeff_encode_tab dct_coeff_encode[40][32];


  static void init_tables(void);

 private:

  static void init_mb_addr_inc ();
  static void init_mb_type_I ();
  static void init_mb_type_P ();
  static void init_mb_type_B ();
  static void init_motion_vectors ();

}; // end of class

#endif /* HUFF_H */

---