Subversion Repositories mpeg2fpga

/*

 * vld.v

 *

 * Copyright (c) 2007 Koen De Vleeschauwer.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/*

 * vld - Variable Length Decoder. Scalability not implemented. Maximum vertical size of image in pixels: 2800.

 */

`include "timescale.v"

`undef DEBUG

//`define DEBUG 1

//`define DEBUG_VLC 1

/*

 * video decoding process as specified in 13818-2, par. 7.1 through 7.6

 */

module vld(clk, clk_en, rst,

  getbits, signbit, advance, align, wait_state,                                             // interface with getbits

  quant_wr_data, quant_wr_addr, quant_rst,                                                  // interface with quantizer rams via rld_fifo

  wr_intra_quant, wr_non_intra_quant, wr_chroma_intra_quant, wr_chroma_non_intra_quant,     // interface with quantizer rams via rld_fifo

  rld_wr_en, rld_cmd, dct_coeff_run, dct_coeff_signed_level, dct_coeff_end,                 // interface with rld_fifo

  quantiser_scale_code, alternate_scan, q_scale_type, macroblock_intra, intra_dc_precision, // interface with rld_fifo

  picture_coding_type, picture_structure, motion_type, dct_type,                            // interface with motcomp

  motion_vert_field_select_0_0, motion_vert_field_select_0_1,                               // interface with motcomp

  motion_vert_field_select_1_0, motion_vert_field_select_1_1,                               // interface with motcomp

  second_field, update_picture_buffers, last_frame, mb_width, mb_height, chroma_format,     // interface with motcomp

  macroblock_address, macroblock_motion_forward, macroblock_motion_backward,                // interface with motcomp

  motion_vector_valid,                                                                      // interface with motcomp - motion vectors

  pmv_0_0_0, pmv_0_0_1, pmv_1_0_0, pmv_1_0_1, pmv_0_1_0, pmv_0_1_1, pmv_1_1_0, pmv_1_1_1,   // interface with motcomp - motion vectors

  dmv_0_0, dmv_0_1, dmv_1_0, dmv_1_1,                                                       // interface with motcomp - dual prime motion vectors

  horizontal_size, vertical_size, display_horizontal_size, display_vertical_size,           // interface with syncgen

  matrix_coefficients,                                                                      // interface with yuv2rgb

  frame_rate_code, frame_rate_extension_n, frame_rate_extension_d,                          // interface with regfile

  aspect_ratio_information,

  progressive_sequence, progressive_frame, repeat_first_field, top_field_first,             // interface with resample

  vld_err                                                                                   // asserted when vld code parse error

  );

  input            clk;                           // clock

  input            clk_en;                        // clock enable

  input            rst;                           // synchronous active low reset

  input      [23:0]getbits;                       // bit-aligned slice data. 16 bits long as longest variable length code is 16 bits.

  input            signbit;                       // sign bit of dct coefficient

  output reg  [4:0]advance;                       // number of bits to advance the bitstream (advance <= 24)

  output reg       align;                         // byte-align getbits and move forward one byte.

  output reg  [7:0]quant_wr_data;                 // data bus for quantizer matrix rams

  output reg  [5:0]quant_wr_addr;                 // address bus for quantizer matrix rams

  output reg       quant_rst;                     // reset quant matrices to default values

  output reg       wr_intra_quant;                // write enable for intra quantiser matrix

  output reg       wr_non_intra_quant;            // write enable for non intra quantiser matrix

  output reg       wr_chroma_intra_quant;         // write enable for chroma intra quantiser matrix

  output reg       wr_chroma_non_intra_quant;     // write enable for chroma non intra quantiser matrix

  output reg       vld_err;                       // vld_err is asserted when a slice parsing error has occurred. self-repairing.

  parameter [7:0]

    STATE_NEXT_START_CODE             = 8'h00,

    STATE_START_CODE                  = 8'h01,

    STATE_PICTURE_HEADER              = 8'h02,

    STATE_PICTURE_HEADER0             = 8'h03,

    STATE_PICTURE_HEADER1             = 8'h04,

    STATE_PICTURE_HEADER2             = 8'h05,

    STATE_SEQUENCE_HEADER             = 8'h06,

    STATE_SEQUENCE_HEADER0            = 8'h07,

    STATE_SEQUENCE_HEADER1            = 8'h08,

    STATE_SEQUENCE_HEADER2            = 8'h09,

    STATE_SEQUENCE_HEADER3            = 8'h0a,

    STATE_GROUP_HEADER                = 8'h0b,

    STATE_GROUP_HEADER0               = 8'h0c,

    STATE_EXTENSION_START_CODE        = 8'h10,

    STATE_SEQUENCE_EXT                = 8'h11,

    STATE_SEQUENCE_EXT0               = 8'h12,

    STATE_SEQUENCE_EXT1               = 8'h13,

    STATE_SEQUENCE_DISPLAY_EXT        = 8'h14,

    STATE_SEQUENCE_DISPLAY_EXT0       = 8'h15,

    STATE_SEQUENCE_DISPLAY_EXT1       = 8'h16,

    STATE_SEQUENCE_DISPLAY_EXT2       = 8'h17,

    STATE_QUANT_MATRIX_EXT            = 8'h18,

    STATE_PICTURE_CODING_EXT          = 8'h19,

    STATE_PICTURE_CODING_EXT0         = 8'h1a,

    STATE_PICTURE_CODING_EXT1         = 8'h1b,

    STATE_LD_INTRA_QUANT0             = 8'h20,

    STATE_LD_INTRA_QUANT1             = 8'h21,

    STATE_LD_NON_INTRA_QUANT0         = 8'h22,

    STATE_LD_NON_INTRA_QUANT1         = 8'h23,

    STATE_LD_CHROMA_INTRA_QUANT1      = 8'h24,

    STATE_LD_CHROMA_NON_INTRA_QUANT1  = 8'h25,

    STATE_SLICE                       = 8'h31,

    STATE_SLICE_EXTENSION             = 8'h32,

    STATE_SLICE_EXTRA_INFORMATION     = 8'h33,

    STATE_NEXT_MACROBLOCK             = 8'h34,

    STATE_MACROBLOCK_SKIP             = 8'h35,

    STATE_DELAY_EMPTY_BLOCK           = 8'h36,

    STATE_EMIT_EMPTY_BLOCK            = 8'h37,

    STATE_MACROBLOCK_TYPE             = 8'h38,

    STATE_MOTION_TYPE                 = 8'h39,

    STATE_DCT_TYPE                    = 8'h3a,

    STATE_MACROBLOCK_QUANT            = 8'h3b,

    STATE_NEXT_MOTION_VECTOR          = 8'h40,

    STATE_MOTION_VERT_FLD_SEL         = 8'h41, // motion_vectors: motion_vertical_field_select

    STATE_MOTION_CODE                 = 8'h42, // motion_vector: motion_code

    STATE_MOTION_RESIDUAL             = 8'h43, // motion_vector: motion_residual

    STATE_MOTION_DMVECTOR             = 8'h44, // motion_vector: dmvector

    STATE_MOTION_PREDICT              = 8'h45, // motion_vector: prediction pipeline begin

    STATE_MOTION_PIPELINE_FLUSH       = 8'h46, // motion_vector: prediction pipeline end

    STATE_MARKER_BIT_0                = 8'h60,

    STATE_CODED_BLOCK_PATTERN         = 8'h61,

    STATE_CODED_BLOCK_PATTERN_1       = 8'h62,

    STATE_CODED_BLOCK_PATTERN_2       = 8'h63,

    STATE_BLOCK                       = 8'h70,

    STATE_NEXT_BLOCK                  = 8'h71,

    STATE_DCT_DC_LUMI_SIZE            = 8'h72,

    STATE_DCT_DC_CHROMI_SIZE          = 8'h73,

    STATE_DCT_DC_DIFF                 = 8'h74,

    STATE_DCT_DC_DIFF_0               = 8'h75,

    STATE_DCT_SUBS_B15                = 8'h76,

    STATE_DCT_ESCAPE_B15              = 8'h77,

    STATE_DCT_SUBS_B14                = 8'h78,

    STATE_DCT_ESCAPE_B14              = 8'h79,

    STATE_DCT_NON_INTRA_FIRST         = 8'h7a,

    STATE_NON_CODED_BLOCK             = 8'h7b,

    STATE_DCT_ERROR                   = 8'h7c,

    STATE_SEQUENCE_END                = 8'h80,

    STATE_ERROR                       = 8'hff;

  /* start codes */

  parameter [7:0]

    CODE_PICTURE_START                = 8'h00,

    CODE_USER_DATA_START              = 8'hb2,

    CODE_SEQUENCE_HEADER              = 8'hb3,

    CODE_SEQUENCE_ERROR               = 8'hb4,

    CODE_EXTENSION_START              = 8'hb5,

    CODE_SEQUENCE_END                 = 8'hb7,

    CODE_GROUP_START                  = 8'hb8;

  /* extension start codes */

  parameter [3:0]

    EXT_SEQUENCE                      = 4'b0001,

    EXT_SEQUENCE_DISPLAY              = 4'b0010,

    EXT_QUANT_MATRIX                  = 4'b0011,

    EXT_COPYRIGHT                     = 4'b0100,

    EXT_SEQUENCE_SCALABLE             = 4'b0101,

    EXT_PICTURE_DISPLAY               = 4'b0111,

    EXT_PICTURE_CODING                = 4'b1000,

    EXT_PICTURE_SPATIAL_SCALABLE      = 4'b1001,

    EXT_PICTURE_TEMPORAL_SCALABLE     = 4'b1010,

    EXT_CAMERA_PARAMETERS             = 4'b1011,

    EXT_ITU_T                         = 4'b1100;

`include "vld_codes.v"

  parameter

    STRICT_MARKER_BIT = 1'b0;  /* set to 1 to check marker bits are 1. May break some streams. */

  /*

   *  Table 7-7 Meaning of indices in PMV[r][s][t], vector[r][s][t] and vector'[r][s][t]

   *

   *    0                                 1

   *  r First motion vector in Macroblock Second motion vector in Macroblock

   *  s Forward motion Vector             Backwards motion Vector

   *  t Horizontal Component              Vertical Component

   *

   *  NOTE r also takes the values 2 and 3 for derived motion vectors used with dual-prime prediction.

   *  Since these motion vectors are derived they do not themselves have motion vector predictors.

   */

  parameter [2:0] /* motion vector codes */

    MOTION_VECTOR_0_0_0 = 3'd0,

    MOTION_VECTOR_0_0_1 = 3'd1,

    MOTION_VECTOR_1_0_0 = 3'd2,

    MOTION_VECTOR_1_0_1 = 3'd3,

    MOTION_VECTOR_0_1_0 = 3'd4,

    MOTION_VECTOR_0_1_1 = 3'd5,

    MOTION_VECTOR_1_1_0 = 3'd6,

    MOTION_VECTOR_1_1_1 = 3'd7;

  reg         [7:0]state;

  reg         [7:0]next;

  reg         [4:0]next_advance;

  reg         [5:0]cnt; // counter used when loading quant matrices

  /* in start code */

  wire        [7:0]start_code;

  /* position in video stream */

  reg              sequence_header_seen;    /* set when sequence header encountered, cleared when sequence end encountered  */

  reg              sequence_extension_seen; /* set when sequence extension encountered, cleared when sequence end encountered  */

  reg              picture_header_seen;     /* set when picture header encountered, cleared when sequence end encountered  */

  /* in sequence header */

  output wire[13:0]horizontal_size;

  output wire[13:0]vertical_size;

  output reg  [7:0]mb_width;   /* par. 6.3.3. width of the encoded luminance component of pictures in macroblocks */

  output reg  [7:0]mb_height;  /* par. 6.3.3. height of the encoded luminance component of frame pictures in macroblocks */

  output wire [3:0]aspect_ratio_information;

  output wire [3:0]frame_rate_code;

  wire       [29:0]bit_rate;

  wire       [17:0]vbv_buffer_size;

  wire             constrained_parameters_flag;

  /* in sequence header extension */

  wire        [7:0]profile_and_level_indication;

  output wire      progressive_sequence;

  output wire [1:0]chroma_format;

  wire             low_delay;

  output wire [1:0]frame_rate_extension_n;

  output wire [4:0]frame_rate_extension_d;

  /* in sequence display extension */

  wire        [2:0]video_format;

  wire        [7:0]colour_primaries;

  wire        [7:0]transfer_characteristics;

  output wire [7:0]matrix_coefficients;

  output wire[13:0]display_horizontal_size;

  output wire[13:0]display_vertical_size;

  /* in picture coding extension */

  wire        [3:0]f_code_00;

  wire        [3:0]f_code_01;

  wire        [3:0]f_code_10;

  wire        [3:0]f_code_11;

  output wire [1:0]intra_dc_precision;

  output wire [1:0]picture_structure;

  output wire      top_field_first;

  wire             frame_pred_frame_dct;

  wire             concealment_motion_vectors;

  output wire      q_scale_type;

  wire             intra_vlc_format;

  output wire      alternate_scan;

  output wire      repeat_first_field;

  wire             chroma_420_type;

  output wire      progressive_frame;

  wire             composite_display_flag;

  wire             v_axis;

  wire        [2:0]field_sequence;

  wire             sub_carrier;

  wire        [6:0]burst_amplitude;

  wire        [7:0]sub_carrier_phase;

  /* in group of pictures header */

  wire             drop_flag;

  wire        [4:0]time_code_hours;

  wire        [5:0]time_code_minutes;

  wire        [5:0]time_code_seconds;

  wire        [5:0]time_code_pictures;

  wire             closed_gop;

  wire             broken_link;

  /* in picture header */

  wire        [9:0]temporal_reference;

  output wire [2:0]picture_coding_type;

  wire       [15:0]vbv_delay;

  wire             full_pel_forward_vector;

  wire        [2:0]forward_f_code;

  wire             full_pel_backward_vector;

  wire        [2:0]backward_f_code;

  /* in slice */

  output reg  [4:0]quantiser_scale_code;

  reg              slice_extension_flag;

  reg              intra_slice;

  reg              slice_picture_id_enable;

  reg         [5:0]slice_picture_id;

  reg         [7:0]slice_vertical_position;

  reg              first_macroblock_of_slice;

  /* macroblock address increment */

  wire        [3:0]macroblock_addr_inc_length;

  wire        [5:0]macroblock_addr_inc_value;

  wire        [6:0]macroblock_addr_inc_value_ext = macroblock_addr_inc_value;

  wire             macroblock_addr_inc_escape;

  reg         [6:0]macroblock_address_increment;

  /*

   * macroblock address is valid after STATE_MACROBLOCK_TYPE and before STATE_NEXT_BLOCK.

   * In particular: In the first slice of a picture, macroblock_address may be 0xffff after STATE_SLICE up to STATE_MACROBLOCK_TYPE.

   */

  output reg [12:0]macroblock_address; // High Level: macroblock_address is 13 bits, 0..8159, 8160..8191 unused.

  reg        [10:0]empty_blocks;

  /* macroblock type */

  wire        [3:0]macroblock_type_length;

  wire        [5:0]macroblock_type_value;

  reg              macroblock_quant;

  output reg       macroblock_motion_forward;

  output reg       macroblock_motion_backward;

  reg              macroblock_pattern;

  output reg       macroblock_intra;

  reg              macroblock_type_intra;

  reg              spatial_temporal_weight_code_flag; // ought always to be zero, as we don't do scaleability

  output reg  [1:0]motion_type; // one reg for both frame_motion_type and field_motion_type

  output reg       dct_type; // dct_type == 1 : field dct coded; dct_type == 0 : frame dct coded

  /* derived variables (par. 6.3.17.1, tables 6.17 and 6.18) */

  wire             motion_vector_count_is_one;

  reg         [1:0]mv_format;

  reg              dmv;

  /* motion vectors */

  reg         [2:0]motion_vector;  // current motion vector

  reg         [7:0]motion_vector_reg;  // bitmask of motion vectors present

  reg         [3:0]r_size; // f_code_xx  - 4'd1;

  wire             vertical_field_select_present;

  reg         [4:0]motion_code;

  reg              motion_code_neg;

  reg         [7:0]motion_code_residual; // motion_code_residual has up to r_size = f_code_xx - 1 bits. (par. 6.3.17.3) with f_code = 1..9 (Table E-8, high level)

  reg signed  [1:0]dmvector;

  /*

   * par. 7.6.3.1, if f_code_xx = 15 the pmv range low..high would need 21 bits.

   * But restricting ourselves to high level@high profile allows us to pack

   * the motion vectors tighter.

   * Table E-8: for High Level f_code_0_0, f_code_1_0: 1..9

   *                           f_code_0_1, f_code_1_1: 1..5

   *

   * Hence all f_code values are in the range 1..9.

   * This implies the motion vectors are in the range -4096..4095. (par. 7.6.3.1)

   * This means we can represent all motion vectors with 13 bits.

   *

   */

  output reg signed [12:0]pmv_0_0_0;

  output reg signed [12:0]pmv_0_0_1;

  output reg signed [12:0]pmv_1_0_0;

  output reg signed [12:0]pmv_1_0_1;

  output reg signed [12:0]pmv_0_1_0;

  output reg signed [12:0]pmv_0_1_1;

  output reg signed [12:0]pmv_1_1_0;

  output reg signed [12:0]pmv_1_1_1;

  output reg signed [12:0]dmv_0_0; // dual-prime motion vectors

  output reg signed [12:0]dmv_1_0;

  output reg signed [12:0]dmv_0_1;

  output reg signed [12:0]dmv_1_1;

  /* motion vector pipeline, stage 1 */

  reg         [2:0]motion_vector_0;

  reg              motion_vector_valid_0;

  reg              motion_code_neg_0;

  reg         [3:0]r_size_0;

  reg signed  [1:0]dmvector_0;

  reg signed [12:0]pmv_0;

  reg signed [12:0]pmv_delta_0;

  /* motion vector pipeline, stage 2 */

  reg         [2:0]motion_vector_1;

  reg              motion_vector_valid_1;

  reg         [3:0]r_size_1;

  reg signed  [1:0]dmvector_1;

  reg signed [12:0]pmv_1;

  /* motion vector pipeline, stage 3 */

  reg         [2:0]motion_vector_2;

  reg              motion_vector_valid_2;

  reg signed  [1:0]dmvector_2;

  reg signed [12:0]pmv_2;

  /* motion vector pipeline, stage 4 */

  reg         [2:0]motion_vector_3;

  reg              motion_vector_valid_3;

  reg signed [12:0]pmv_3;

  reg signed  [1:0]dmvector_3;

  /* motion vector pipeline, stage 5 */

  reg         [2:0]motion_vector_4;

  reg              motion_vector_valid_4;

  reg signed [12:0]pmv_4;

  /* motion vector pipeline, stage 6 */

  reg         [2:0]motion_vector_5;

  reg              motion_vector_valid_5;

  reg signed [12:0]pmv_5;

  /* motion vector pipeline, output */

  output reg       motion_vector_valid; // motion_vector valid is asserted when pmv_x_x_x dmv_x_x valid

  /* coded block pattern */

  reg        [11:0]coded_block_pattern;  // derived from coded_block_pattern_420, coded_block_pattern_1 and coded_block_pattern_2

  /* dct coefficients */

  reg         [3:0]dct_dc_size;          // holds dct_dc_size_luminance or dct_dc_size_chrominance, depending.

  reg        [10:0]dct_dc_pred;          // dct_dc_pred_0, dct_dc_pred_1 or dct_dc_pred_2, depending upon whether it's a Y, Cr or Cb block.

  reg        [10:0]dct_dc_pred_0;        // luminance (Y) dct dc predictor, par. 7.2.1

  reg        [10:0]dct_dc_pred_1;        // first chrominance (Cb) dct dc predictor, par. 7.2.1

  reg        [10:0]dct_dc_pred_2;        // second chrominance (Cr) dct dc predictor, par. 7.2.1

  /*

   * Each bit in block_pattern_code, block_lumi_code, ... corresponds to a block.

   * The first block corresponds to the leftmost bit (= bit 11) the second block to bit 10, etc.

   *

   * For instance, this is what things look like before the first block of a 4:2:0 macroblock:

   *

   * testbench.mpeg2_decoder.vld     STATE_BLOCK

   * testbench.mpeg2_decoder.vld     coded_block_pattern:  b111111000000

   * testbench.mpeg2_decoder.vld     block_pattern_code:   b111111000000

   * testbench.mpeg2_decoder.vld     block_lumi_code:     b011110

   * testbench.mpeg2_decoder.vld     block_chromi1_code:  b0000010101010

   * testbench.mpeg2_decoder.vld     block_chromi2_code:  b0000001010101

   *

   * 6 blocks, first 4 luminance blocks, then a chromi1 (Cb) block, finally a chromi2 (Cr) block.

   * Each block, block_pattern_code, block_lumi_code, block_chromi1_code and block_chromi2_code shift left one bit:

   *

   * testbench.mpeg2_decoder.vld     STATE_NEXT_BLOCK

   * testbench.mpeg2_decoder.vld     coded_block_pattern:  b111110000000

   * testbench.mpeg2_decoder.vld     block_pattern_code:   b111110000000

   * testbench.mpeg2_decoder.vld     block_lumi_code:     b111100

   * testbench.mpeg2_decoder.vld     block_chromi1_code:  b0000101010100

   * testbench.mpeg2_decoder.vld     block_chromi2_code:  b0000010101010

   * ...

   * testbench.mpeg2_decoder.vld     STATE_NEXT_BLOCK

   * testbench.mpeg2_decoder.vld     coded_block_pattern:  b111100000000

   * testbench.mpeg2_decoder.vld     block_pattern_code:   b111100000000

   * testbench.mpeg2_decoder.vld     block_lumi_code:     b111000

   * testbench.mpeg2_decoder.vld     block_chromi1_code:  b0001010101000

   * testbench.mpeg2_decoder.vld     block_chromi2_code:  b0000101010100

   * ...

   *

   * The loop ends when all bits have been shifted out of block_pattern_code:

   *

   * testbench.mpeg2_decoder.vld     STATE_NEXT_BLOCK

   * testbench.mpeg2_decoder.vld     coded_block_pattern:  b000000000000

   * testbench.mpeg2_decoder.vld     block_pattern_code:   b000000000000

   * testbench.mpeg2_decoder.vld     block_lumi_code:     b000000

   * testbench.mpeg2_decoder.vld     block_chromi1_code:  b0101010000000

   * testbench.mpeg2_decoder.vld     block_chromi2_code:  b1010101000000

   *

   * Note there still remain bits in block_chromi1_code and block_chromi2_code:

   * these would have been used in 4:2:2 and 4:4:4 video.

   *

   */

  reg        [11:0]block_pattern_code;   // block_pattern_code[i] is one if the corresponding block exists in the macroblock.

  reg        [12:7]block_lumi_code;      // block_lumi_code[i] is one if the corresponding block is a luminance block. bits 6:0 are always zero.

  reg        [12:0]block_chromi1_code;   // block_chromi1_code[i] is one if the corresponding block is a Cb chrominance block.

  reg        [12:0]block_chromi2_code;   // block_chromi2_code[i] is one if the corresponding block is a Cr chrominance block.

  wire             dct_coefficient_escape;

  output reg  [5:0]dct_coeff_run;

  output reg signed [11:0]dct_coeff_signed_level;

  output reg       dct_coeff_end;        // asserted after last dct_coeff_run/dct_coeff_signed_level

  reg              dct_coeff_valid;

  reg              dct_error;            // set when error occurs in dct decoding

  reg         [5:0]dct_coeff_run_0;

  reg signed [11:0]dct_coeff_signed_level_0;

  reg              dct_coeff_valid_0;

  reg              dct_coeff_end_0;

  reg              dct_coeff_apply_signbit_0;

  output reg       rld_wr_en;            // asserted when dct_coeff_run, dct_coeff_signed_level, and dct_coeff_end valid, or when quantizer rams need update

  output reg  [1:0]rld_cmd;              // RLD_DCT when dct_coeff_run, dct_coeff_signed_level, and dct_coeff_end valid, RLD_QUANT when quantizer rams need update, RLD_NOOP otherwise

  /* coded block pattern vlc lookup */

  wire        [3:0]coded_block_pattern_length;

  wire        [5:0]coded_block_pattern_value;

  /* motion code vlc lookup */

  wire        [3:0]motion_code_length;

  wire        [4:0]motion_code_value;

  wire             motion_code_sign;

  /* dmvector vlc lookup */

  wire        [1:0]dmvector_length;

  wire             dmvector_value;

  wire             dmvector_sign;

  /* dct dc size luminance vlc lookup */

  wire        [3:0]dct_dc_size_luminance_length;

  wire        [4:0]dct_dc_size_luminance_value;

  /* dct dc size chrominance vlc lookup */

  wire        [3:0]dct_dc_size_chrominance_length;

  wire        [4:0]dct_dc_size_chrominance_value;

  /* dct coefficient 0 vlc lookup */

  reg        [15:0]dct_coefficient_0_decoded;

  reg        [15:0]dct_non_intra_first_coefficient_0_decoded;

  /* dct coefficient 1 vlc lookup */

  reg        [15:0]dct_coefficient_1_decoded;

`include "vlc_tables.v"

  /* next state logic */

  always @*

    casex (state)

      STATE_NEXT_START_CODE:           if (getbits == 24'h000001) next = STATE_START_CODE;

                                       else next = STATE_NEXT_START_CODE;

      STATE_START_CODE:                casex(getbits[7:0])

                                         CODE_PICTURE_START:    if (sequence_header_seen & sequence_extension_seen) next = STATE_PICTURE_HEADER;

                                                                else next = STATE_NEXT_START_CODE;

                                         CODE_USER_DATA_START:  next = STATE_NEXT_START_CODE;

                                         CODE_SEQUENCE_HEADER:  next = STATE_SEQUENCE_HEADER;

                                         CODE_SEQUENCE_ERROR:   next = STATE_NEXT_START_CODE;

                                         CODE_EXTENSION_START:  next = STATE_EXTENSION_START_CODE;

                                         CODE_SEQUENCE_END:     next = STATE_SEQUENCE_END;

                                         CODE_GROUP_START:      next = STATE_GROUP_HEADER;

                                         8'h01,

                                         8'h02,

                                         8'h03,

                                         8'h04,

                                         8'h05,

                                         8'h06,

                                         8'h07,

                                         8'h08,

                                         8'h09,

                                         8'h0a,

                                         8'h0b,

                                         8'h0c,

                                         8'h0d,

                                         8'h0e,

                                         8'h0f,

                                         8'h1x,

                                         8'h2x,

                                         8'h3x,

                                         8'h4x,

                                         8'h5x,

                                         8'h6x,

                                         8'h7x,

                                         8'h8x,

                                         8'h9x,

                                         8'hax:                  if (sequence_header_seen & sequence_extension_seen & picture_header_seen) next = STATE_SLICE;

                                                                 else next = STATE_NEXT_START_CODE;

                                         default                 next = STATE_NEXT_START_CODE;

                                       endcase

      STATE_EXTENSION_START_CODE:      casex(getbits[23:20])

                                         EXT_SEQUENCE:                  next = STATE_SEQUENCE_EXT;

                                         EXT_SEQUENCE_DISPLAY:          next = STATE_SEQUENCE_DISPLAY_EXT;

                                         EXT_QUANT_MATRIX:              next = STATE_QUANT_MATRIX_EXT;

                                         EXT_COPYRIGHT:                 next = STATE_NEXT_START_CODE;

                                         EXT_SEQUENCE_SCALABLE:         next = STATE_NEXT_START_CODE;

                                         EXT_PICTURE_DISPLAY:           next = STATE_NEXT_START_CODE; // Pan & scan

                                         EXT_PICTURE_CODING:            next = STATE_PICTURE_CODING_EXT;

                                         EXT_PICTURE_SPATIAL_SCALABLE:  next = STATE_NEXT_START_CODE;

                                         EXT_PICTURE_TEMPORAL_SCALABLE: next = STATE_NEXT_START_CODE;

                                         EXT_CAMERA_PARAMETERS:         next = STATE_NEXT_START_CODE;

                                         EXT_ITU_T:                     next = STATE_NEXT_START_CODE;

                                         default                        next = STATE_NEXT_START_CODE;

                                       endcase

      /* par. 6.2.2.1: sequence header */

      STATE_SEQUENCE_HEADER:           next = STATE_SEQUENCE_HEADER0;

      STATE_SEQUENCE_HEADER0:          next = STATE_SEQUENCE_HEADER1;

      STATE_SEQUENCE_HEADER1:          next = STATE_SEQUENCE_HEADER2;

      STATE_SEQUENCE_HEADER2:          if (getbits[5] || ~STRICT_MARKER_BIT) next = STATE_SEQUENCE_HEADER3; // check marker bit

                                       else next = STATE_SEQUENCE_HEADER3;

      STATE_SEQUENCE_HEADER3:          if (getbits[12]) next = STATE_LD_INTRA_QUANT0;

                                       else if (getbits[11]) next = STATE_LD_NON_INTRA_QUANT0;

                                       else next = STATE_NEXT_START_CODE;

      STATE_LD_INTRA_QUANT0:           if (cnt != 6'b111111) next = STATE_LD_INTRA_QUANT0;

                                       else if (getbits[15]) next = STATE_LD_NON_INTRA_QUANT0;

                                       else next = STATE_NEXT_START_CODE;

      STATE_LD_NON_INTRA_QUANT0:       if (cnt != 6'b111111) next = STATE_LD_NON_INTRA_QUANT0;

                                       else next = STATE_NEXT_START_CODE;

      /* par. 6.2.2.3: Sequence extension */

      STATE_SEQUENCE_EXT:              next = STATE_SEQUENCE_EXT0;

      STATE_SEQUENCE_EXT0:             if (getbits[11] || ~STRICT_MARKER_BIT) next = STATE_SEQUENCE_EXT1; // check marker bit

                                       else next = STATE_ERROR;

      STATE_SEQUENCE_EXT1:             next = STATE_NEXT_START_CODE;

      /* par. 6.2.2.4: Sequence display extension */

      STATE_SEQUENCE_DISPLAY_EXT:      if (getbits[20]) next = STATE_SEQUENCE_DISPLAY_EXT0;

                                       else next = STATE_SEQUENCE_DISPLAY_EXT1;

      STATE_SEQUENCE_DISPLAY_EXT0:     next = STATE_SEQUENCE_DISPLAY_EXT1;

      STATE_SEQUENCE_DISPLAY_EXT1:     if (getbits[9]) next = STATE_SEQUENCE_DISPLAY_EXT2;

                                       else next = STATE_NEXT_START_CODE;

      STATE_SEQUENCE_DISPLAY_EXT2:     next = STATE_NEXT_START_CODE;

      /* par. 6.2.3.2: Quant matrix  extension */

      STATE_QUANT_MATRIX_EXT:          if (getbits[23]) next = STATE_LD_INTRA_QUANT1;

                                       else if (getbits[22]) next = STATE_LD_NON_INTRA_QUANT1;

                                       else if (getbits[21]) next = STATE_LD_CHROMA_INTRA_QUANT1;

                                       else if (getbits[20]) next = STATE_LD_CHROMA_NON_INTRA_QUANT1;

                                       else next = STATE_NEXT_START_CODE;

      STATE_LD_INTRA_QUANT1:           if (cnt != 6'b111111) next = STATE_LD_INTRA_QUANT1;

                                       else if (getbits[14]) next = STATE_LD_NON_INTRA_QUANT1;

                                       else if (getbits[13]) next = STATE_LD_CHROMA_INTRA_QUANT1;

                                       else if (getbits[12]) next = STATE_LD_CHROMA_NON_INTRA_QUANT1;

                                       else next = STATE_NEXT_START_CODE;

      STATE_LD_NON_INTRA_QUANT1:       if (cnt != 6'b111111) next = STATE_LD_NON_INTRA_QUANT1;

                                       else if (getbits[13]) next = STATE_LD_CHROMA_INTRA_QUANT1;

                                       else if (getbits[12]) next = STATE_LD_CHROMA_NON_INTRA_QUANT1;

                                       else next = STATE_NEXT_START_CODE;

      STATE_LD_CHROMA_INTRA_QUANT1:    if (cnt != 6'b111111) next = STATE_LD_CHROMA_INTRA_QUANT1;

                                       else if (getbits[12]) next = STATE_LD_CHROMA_NON_INTRA_QUANT1;

                                       else next = STATE_NEXT_START_CODE;

      STATE_LD_CHROMA_NON_INTRA_QUANT1: if (cnt != 6'b111111) next = STATE_LD_CHROMA_NON_INTRA_QUANT1;

                                       else next = STATE_NEXT_START_CODE;

      /* par. 6.2.3.1: Picture coding extension */

      STATE_PICTURE_CODING_EXT:        next = STATE_PICTURE_CODING_EXT0;

      STATE_PICTURE_CODING_EXT0:       if (getbits[10]) next = STATE_PICTURE_CODING_EXT1;