Subversion Repositories mpeg2fpga

/*

 * motcomp_recon.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.

 */

/*

 * motcomp_recon.v - Motion Compensation: pixel reconstruction.

 */

`include "timescale.v"

`undef DEBUG

//`define DEBUG 1

 /*

  Block reconstruction summary:

   - read work to be done from dst fifo.

   - combine forward prediction (fwd_rd_dta) and backward prediction (bwd_rd_dta) (p[y][x] in Figure 7-5)

   - add idct coefficients (f[y][x] in Figure 7-5)

   - clip and saturate to 0..255 range

   - write reconstructed pixels to frame store (recon_wr_dta, recon_wr_addr)

  Can produce one 8-pixel row every two clock cycles. In practice this means speed is limited by how fast

  the memory subsystem can feed it with pixels.

  In detail:

   - from dst fifo, read work to be done. This includes write_address_0, the address where the reconstructed pixels have to be written

     if write_recon_0 is high.

   - Compute forward prediction: (prediction_fwd_row)

     if motion_forward_0 is high, read  a row of 16 pixels from forward motion compensation data fifo (fwd_row_0).

     Shift the double row left by fwd_hor_offset_0 pixels.

     If fwd_hor_halfpixel_0, do linear interpolation between two adjacent pixels on same horizontal.

     If fwd_ver_halfpixel_0, do linear interpolation between two adjacent pixels on fwd_row_0 and the previous row, prev_fwd_2.

     If motion_forward_0 is low, forward prediction is not used (is zero).

   - Compute forward prediction: (prediction_bwd_row)

     if motion_backward_0 is high, read  a row of 16 pixels from backward motion compensation data fifo (bwd_row_0).

     Shift the double row left by bwd_hor_offset_0 pixels.

     If bwd_hor_halfpixel_0, do linear interpolation between two adjacent pixels on same horizontal.

     If bwd_ver_halfpixel_0, do linear interpolation between two adjacent pixels on bwd_row_0 and the previous row, prev_bwd_2.

     If motion_backward_0 is low, backward prediction is not used (is zero).

   - Obtain idct coefficients

     - If write_recon_0 is high, read  a row of eight idct coefficients from idct_row_0.

     - If write_recon_0 is low, idct coefficients are not used.

   - Combine predictions (combine_row)

     - If motion_forward_0 is asserted but motion_backward_0 is not asserted, prediction is forward prediction.

     - If motion_backward_0 is asserted but motion_forward_0 is not asserted, prediction is backward prediction.

     - If both motion_forward_0 and motion_backward_0 are asserted, prediction is the average of forward and backward prediction.

     - If neither motion_forward_0 nor motion_backward_0 are asserted, prediction is all zeroes.

     - add idct coefficients to the prediction.

     - clip and saturate each pixel to 0..255 range.

     This produces the reconstructed block row.

   - If write_recon_0 is high, write the reconstructed block row to frame store at address write_address_0.

     If write_recon_0 is low, no action is taken.

  Use of write_recon_0:

     In vertical halfpixel calculations we need the value of the pixels above the current pixel (the previous row)

     to do vertical interpolation. By setting write_recon_0 low, the fwd/bwd pixels of the first row are loaded into the appropriate

     registers, but do not produce a write to the frame store. A write would be inappropriate: since it's the first row,

     there's no previous row and vertical halfpixel calculations would fail.

     As an example, consider motion compensation of an 8x8 block. dst_rd_write_recon is low during the first row of fwd/bwd pixels,

     and high during the eight following rows. Then comes the next 8x8 block: again dst_rd_write_recon is low during the first row,

     and high during the next eight rows.

  Note motcomp_recon reconstructs a row of 8 pixels in parallel.

  The pixels are stored in the frame store as signed 8-bit values, with values between -128 and 127.

  One can obtain the unsigned pixel values by adding 128.

  Thus, -128 corresponding to 0 and 127 corresponding to 255.

  Storing the pixels as signed 8-bit values has the advantage that one can average two frames without the dc level going up.

  The 128 gets added at the end, in the yuv to rgb conversion.

  */

module motcomp_recon(

  clk, clk_en, rst,

  dst_rd_dta_empty, dst_rd_dta_en, dst_rd_dta, dst_rd_dta_valid,

  idct_rd_dta_empty, idct_rd_dta_en, idct_rd_dta, idct_rd_dta_valid,

  fwd_rd_dta_empty, fwd_rd_dta_en, fwd_rd_dta, fwd_rd_dta_valid,

  bwd_rd_dta_empty, bwd_rd_dta_en, bwd_rd_dta, bwd_rd_dta_valid,

  recon_wr_full, recon_wr_almost_full, recon_wr_en, recon_wr_addr, recon_wr_dta

  );

  input              clk;                      // clock

  input              clk_en;                   // clock enable

  input              rst;                      // synchronous active low reset

  /* reading block address and recon parameters */

  input             dst_rd_dta_empty;          // low if dst fifo is not empty

  input             dst_rd_dta_valid;          // high if dst fifo read successful

  output            dst_rd_dta_en;             // assert to read dst fifo

  input       [34:0]dst_rd_dta;                // reconstruction parameters: address to write reconstructed block row to, whether to use forward or backward motion compensation, ...

  /* reading idct data */

  input       [71:0]idct_rd_dta;               // fifo of idct coefficients. Each idct_rd_dta is a row of 8 idct coefficients. Each idct coefficient is 9-bit signed.

  output            idct_rd_dta_en;            // assert to read next idct coefficients

  input             idct_rd_dta_empty;         // low if idct_rd_dta fifo not empty

  input             idct_rd_dta_valid;         // asserted if idct_rd_dta valid

  /* reading forward reference frame: reading data */

  input             fwd_rd_dta_empty;          // low if fwd_rd_dta fifo not empty

  output            fwd_rd_dta_en;             // assert to read next fwd_rd_dta

  input       [63:0]fwd_rd_dta;                // fifo of forward block rows

  input             fwd_rd_dta_valid;

  /* reading backward reference frame: reading data */

  input             bwd_rd_dta_empty;          // low if bwd_rd_dta fifo not empty

  output            bwd_rd_dta_en;             // assert to read next bwd_rd_dta

  input       [63:0]bwd_rd_dta;                // fifo of backward block rows

  input             bwd_rd_dta_valid;

  /* writing reconstructed frame: writing address and data */

  input             recon_wr_full;             // high if recon_wr_dta/recon_wr_addr fifo full.

  input             recon_wr_almost_full;      // high if recon_wr_dta/recon_wr_addr fifo is almost full (8 free slots left) XXX

  output reg        recon_wr_en;               // assert to write recon_wr_addr/recon_wr_dta to fifo.

  output reg  [21:0]recon_wr_addr;             // address to write reconstructed block row to

  output reg  [63:0]recon_wr_dta;              // reconstructed block row

  /*

   To reconstruct a row

    - if dst_rd_motion_forward is asserted, fwd_rd_dta_empty should be low: forward prediction data is needed (~fwd_rd_dta_empty)

    - if dst_rd_motion_backward is asserted, bwd_rd_dta_empty should be low: backward prediction data is needed (~bwd_rd_dta_empty)

    - idct_rd_dta_empty is not asserted: eight idct coefficients are available in the fifo pipeline. (~idct_rd_dta_empty)

      (For skipped macroblocks and uncoded blocks , the inverse discrete cosine transform data are all zeroes.)

    - recon_wr_full is not asserted: there is room to write the reconstructed block row.

   */

  parameter [1:0]

    STATE_WAIT       = 3'b001, // wait for data ready

    STATE_RUN        = 3'b010; // start pipeline and read next data

  reg           [1:0]state;

  reg           [1:0]next;

  /* stage 0 variables */

  reg                dst_rd_en;

  wire               dst_valid_0;

  wire               valid_0;

  wire        [127:0]fwd_row_0; // one row of 16 pixels, each pixel an 8 bit unsigned reg. 

  wire               fwd_row_0_valid;

  reg                fwd_row_0_rd_en;

  wire        [127:0]bwd_row_0; // one row of 16 pixels, each pixel an 8 bit unsigned reg.

  wire               bwd_row_0_valid;

  reg                bwd_row_0_rd_en;

  wire         [71:0]idct_row_0; // one row of 8 idct coefficients; each idct coefficient a 9 bit signed reg.

  wire               idct_row_0_valid;

  reg                idct_row_0_rd_en;

  wire               write_recon_0;

  wire         [21:0]write_address_0;

  wire               motion_forward_0;

  wire          [2:0]fwd_hor_offset_0;

  wire               fwd_hor_halfpixel_0;

  wire               fwd_ver_halfpixel_0;

  wire               motion_backward_0;

  wire          [2:0]bwd_hor_offset_0;

  wire               bwd_hor_halfpixel_0;

  wire               bwd_ver_halfpixel_0;

  /* next state */

  always @*

    case (state)

                     /*

                      * If recon_wr_almost_full is low, we're sure there will be enough room in the reconstruction fifo to write the reconstructed pixels and their address,

                      * If recon_wr_almost_full is high, wait until the framestore has written reconstruction write requests already in the queue.

                      *

                      * If dst_valid_0 is low, we have no work to do. Wait.

                      */

      STATE_WAIT:    if (recon_wr_almost_full || ~dst_valid_0) next = STATE_WAIT;

                     /*

                      * If write_recon_0 is high, the reconstructed pixels will be written to write_address_0.

                      * Reconstructing the pixels will need the idct values, hence idct_row_0_valid has to be high.

                      * If write_recon_0 is low, the reconstructed pixels are thrown away. We just want to load values in prev_fwd_row_0 and prev_bwd_row_0.

                      * As the reconstructed pixels are thrown away, there's no need for idct_row_0_valid to be high.

                      *

                      * If motion_forward_0 is high, we will use forward motion compensation, and fwd_row_0_valid has to be high.

                      *

                      * If motion_backward_0 is high, we will use backward motion compensation, and bwd_row_0_valid has to be high.

                      */

                     else if ((~write_recon_0 || idct_row_0_valid) && (~motion_forward_0 || fwd_row_0_valid) && (~motion_backward_0 || bwd_row_0_valid)) next = STATE_RUN;

                     else next = STATE_WAIT;

      STATE_RUN:     next = STATE_WAIT;

      default        next = STATE_WAIT;

    endcase

  always @(posedge clk)

    if (~rst) state <= STATE_WAIT;

    else if (clk_en) state <= next;

    else state <= state;

  /* fifo read enables */

  always @(posedge clk)

    if (~rst) dst_rd_en <= 1'b0;

    else if (clk_en) dst_rd_en <= (next == STATE_RUN);

    else dst_rd_en <= dst_rd_en;

  always @(posedge clk)

    if (~rst) idct_row_0_rd_en <= 1'b0;

    // If reconstructed pixels are written to the framestore, read next idct values.

    else if (clk_en) idct_row_0_rd_en <= write_recon_0 && (next == STATE_RUN);

    else idct_row_0_rd_en <= idct_row_0_rd_en;

  always @(posedge clk)

    if (~rst) fwd_row_0_rd_en <= 1'b0;

    // If we used forward motion compensation, read next row of forward motion compensation pixels.

    else if (clk_en) fwd_row_0_rd_en <= motion_forward_0 && (next == STATE_RUN);

    else fwd_row_0_rd_en <= fwd_row_0_rd_en;

  always @(posedge clk)

    if (~rst) bwd_row_0_rd_en <= 1'b0;

    // If we used backward motion compensation, read next row of backward motion compensation pixels.

    else if (clk_en) bwd_row_0_rd_en <= motion_backward_0 && (next == STATE_RUN);

    else bwd_row_0_rd_en <= bwd_row_0_rd_en;

  /* stage 0 */

  assign valid_0 = dst_rd_en;

  fwft_reader #(.dta_width(9'd35)) dst_fwft_reader (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .fifo_rd_en(dst_rd_dta_en),

    .fifo_valid(dst_rd_dta_valid),

    .fifo_dout(dst_rd_dta),

    .valid(dst_valid_0),

    .dout({write_recon_0, write_address_0, motion_forward_0, fwd_hor_offset_0, fwd_hor_halfpixel_0, fwd_ver_halfpixel_0, motion_backward_0, bwd_hor_offset_0, bwd_hor_halfpixel_0, bwd_ver_halfpixel_0}),

    .rd_en(dst_rd_en)

    );

  fwft_reader #(.dta_width(9'd72)) idct_fwft_reader (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .fifo_rd_en(idct_rd_dta_en),

    .fifo_valid(idct_rd_dta_valid),

    .fifo_dout(idct_rd_dta),

    .valid(idct_row_0_valid),

    .dout(idct_row_0),

    .rd_en(idct_row_0_rd_en)

    );

  fwft2_reader #(.dta_width(9'd64)) fwd_fwft2_reader (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .fifo_rd_en(fwd_rd_dta_en),

    .fifo_valid(fwd_rd_dta_valid),

    .fifo_dout(fwd_rd_dta),

    .valid(fwd_row_0_valid),

    .dout(fwd_row_0),

    .rd_en(fwd_row_0_rd_en)

    );

  fwft2_reader #(.dta_width(9'd64)) bwd_fwft2_reader (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .fifo_rd_en(bwd_rd_dta_en),

    .fifo_valid(bwd_rd_dta_valid),

    .fifo_dout(bwd_rd_dta),

    .valid(bwd_row_0_valid),

    .dout(bwd_row_0),

    .rd_en(bwd_row_0_rd_en)

    );

  /* horizontal offset, including horizontal halfpixel */

  wire               valid_2;

  wire               write_recon_2;

  wire         [71:0]idct_row_2;

  wire         [21:0]write_address_2;

  wire               motion_forward_2;

  wire               fwd_hor_halfpixel_2;

  wire               fwd_ver_halfpixel_2;

  wire               motion_backward_2;

  wire               bwd_hor_halfpixel_2;

  wire               bwd_ver_halfpixel_2;

  wire signed   [7:0]fwd_2_pixel_0;

  wire signed   [7:0]fwd_2_pixel_1;

  wire signed   [7:0]fwd_2_pixel_2;

  wire signed   [7:0]fwd_2_pixel_3;

  wire signed   [7:0]fwd_2_pixel_4;

  wire signed   [7:0]fwd_2_pixel_5;

  wire signed   [7:0]fwd_2_pixel_6;

  wire signed   [7:0]fwd_2_pixel_7;

  wire signed   [7:0]fwd_2_pixel_8;

  wire signed   [7:0]bwd_2_pixel_0;

  wire signed   [7:0]bwd_2_pixel_1;

  wire signed   [7:0]bwd_2_pixel_2;

  wire signed   [7:0]bwd_2_pixel_3;

  wire signed   [7:0]bwd_2_pixel_4;

  wire signed   [7:0]bwd_2_pixel_5;

  wire signed   [7:0]bwd_2_pixel_6;

  wire signed   [7:0]bwd_2_pixel_7;

  wire signed   [7:0]bwd_2_pixel_8;

  wire signed   [8:0]idct_2_pixel_0;

  wire signed   [8:0]idct_2_pixel_1;

  wire signed   [8:0]idct_2_pixel_2;

  wire signed   [8:0]idct_2_pixel_3;

  wire signed   [8:0]idct_2_pixel_4;

  wire signed   [8:0]idct_2_pixel_5;

  wire signed   [8:0]idct_2_pixel_6;

  wire signed   [8:0]idct_2_pixel_7;

  assign {idct_2_pixel_0, idct_2_pixel_1, idct_2_pixel_2, idct_2_pixel_3, idct_2_pixel_4, idct_2_pixel_5, idct_2_pixel_6, idct_2_pixel_7} = idct_row_2;

  wire signed   [7:0]prev_fwd_2_pixel_0;

  wire signed   [7:0]prev_fwd_2_pixel_1;

  wire signed   [7:0]prev_fwd_2_pixel_2;

  wire signed   [7:0]prev_fwd_2_pixel_3;

  wire signed   [7:0]prev_fwd_2_pixel_4;

  wire signed   [7:0]prev_fwd_2_pixel_5;

  wire signed   [7:0]prev_fwd_2_pixel_6;

  wire signed   [7:0]prev_fwd_2_pixel_7;

  wire signed   [7:0]prev_fwd_2_pixel_8;

  wire signed   [7:0]prev_bwd_2_pixel_0;

  wire signed   [7:0]prev_bwd_2_pixel_1;

  wire signed   [7:0]prev_bwd_2_pixel_2;

  wire signed   [7:0]prev_bwd_2_pixel_3;

  wire signed   [7:0]prev_bwd_2_pixel_4;

  wire signed   [7:0]prev_bwd_2_pixel_5;

  wire signed   [7:0]prev_bwd_2_pixel_6;

  wire signed   [7:0]prev_bwd_2_pixel_7;

  wire signed   [7:0]prev_bwd_2_pixel_8;

  reg [71:0]prev_fwd_2;

  assign {prev_fwd_2_pixel_0, prev_fwd_2_pixel_1, prev_fwd_2_pixel_2, prev_fwd_2_pixel_3, prev_fwd_2_pixel_4,

          prev_fwd_2_pixel_5, prev_fwd_2_pixel_6, prev_fwd_2_pixel_7, prev_fwd_2_pixel_8} = prev_fwd_2;

  always @(posedge clk)

    if (~rst) prev_fwd_2 <= 72'b0;

    else if (clk_en && valid_2) prev_fwd_2 <= {fwd_2_pixel_0, fwd_2_pixel_1, fwd_2_pixel_2, fwd_2_pixel_3, fwd_2_pixel_4, fwd_2_pixel_5, fwd_2_pixel_6, fwd_2_pixel_7, fwd_2_pixel_8};

    else prev_fwd_2 <= prev_fwd_2;

  reg [71:0]prev_bwd_2;

  assign {prev_bwd_2_pixel_0, prev_bwd_2_pixel_1, prev_bwd_2_pixel_2, prev_bwd_2_pixel_3, prev_bwd_2_pixel_4,

          prev_bwd_2_pixel_5, prev_bwd_2_pixel_6, prev_bwd_2_pixel_7, prev_bwd_2_pixel_8} = prev_bwd_2;

  always @(posedge clk)

    if (~rst) prev_bwd_2 <= 72'b0;

    else if (clk_en && valid_2) prev_bwd_2 <= {bwd_2_pixel_0, bwd_2_pixel_1, bwd_2_pixel_2, bwd_2_pixel_3, bwd_2_pixel_4, bwd_2_pixel_5, bwd_2_pixel_6, bwd_2_pixel_7, bwd_2_pixel_8};

    else prev_bwd_2 <= prev_bwd_2;

  prediction_horizontal_offset #(.dta_width(8'd101)) prediction_fwd_row (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_0),

    .row_in(fwd_row_0),

    .motion_compensation_in(motion_forward_0),

    .hor_offset_in(fwd_hor_offset_0),

    .dta_in({write_recon_0, idct_row_0, write_address_0, motion_forward_0, fwd_hor_halfpixel_0, fwd_ver_halfpixel_0, motion_backward_0, bwd_hor_halfpixel_0, bwd_ver_halfpixel_0}),

    .valid_out(valid_2),

    .pixel_0_out(fwd_2_pixel_0),

    .pixel_1_out(fwd_2_pixel_1),

    .pixel_2_out(fwd_2_pixel_2),

    .pixel_3_out(fwd_2_pixel_3),

    .pixel_4_out(fwd_2_pixel_4),

    .pixel_5_out(fwd_2_pixel_5),

    .pixel_6_out(fwd_2_pixel_6),

    .pixel_7_out(fwd_2_pixel_7),

    .pixel_8_out(fwd_2_pixel_8),

    .dta_out({write_recon_2, idct_row_2, write_address_2, motion_forward_2, fwd_hor_halfpixel_2, fwd_ver_halfpixel_2, motion_backward_2, bwd_hor_halfpixel_2, bwd_ver_halfpixel_2})

    );

  prediction_horizontal_offset #(.dta_width(8'd1)) prediction_bwd_row (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_0),

    .row_in(bwd_row_0),

    .motion_compensation_in(motion_backward_0),

    .hor_offset_in(bwd_hor_offset_0),

    .dta_in(1'b0),

    .valid_out(),

    .pixel_0_out(bwd_2_pixel_0),

    .pixel_1_out(bwd_2_pixel_1),

    .pixel_2_out(bwd_2_pixel_2),

    .pixel_3_out(bwd_2_pixel_3),

    .pixel_4_out(bwd_2_pixel_4),

    .pixel_5_out(bwd_2_pixel_5),

    .pixel_6_out(bwd_2_pixel_6),

    .pixel_7_out(bwd_2_pixel_7),

    .pixel_8_out(bwd_2_pixel_8),

    .dta_out()

    );

  /* vertical halfpixel, and prediction error */

  wire               valid_out;

  wire               write_recon_out;

  wire         [21:0]write_address_out;

  wire          [7:0]pixel_out_0;

  wire          [7:0]pixel_out_1;

  wire          [7:0]pixel_out_2;

  wire          [7:0]pixel_out_3;

  wire          [7:0]pixel_out_4;

  wire          [7:0]pixel_out_5;

  wire          [7:0]pixel_out_6;

  wire          [7:0]pixel_out_7;

  combine_predictions combine_predictions_0 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_0),

    .fwd_rght_pixel_in(fwd_2_pixel_1),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_0),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_1),

    .bwd_left_pixel_in(bwd_2_pixel_0),

    .bwd_rght_pixel_in(bwd_2_pixel_1),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_0),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_1),

    .idct_pixel_in(idct_2_pixel_0),

    .valid_out(valid_out),

    .write_recon_out(write_recon_out),

    .write_address_out(write_address_out),

    .pixel_out(pixel_out_0)

    );

  combine_predictions combine_predictions_1 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_1),

    .fwd_rght_pixel_in(fwd_2_pixel_2),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_1),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_2),

    .bwd_left_pixel_in(bwd_2_pixel_1),

    .bwd_rght_pixel_in(bwd_2_pixel_2),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_1),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_2),

    .idct_pixel_in(idct_2_pixel_1),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_1)

    );

  combine_predictions combine_predictions_2 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_2),

    .fwd_rght_pixel_in(fwd_2_pixel_3),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_2),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_3),

    .bwd_left_pixel_in(bwd_2_pixel_2),

    .bwd_rght_pixel_in(bwd_2_pixel_3),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_2),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_3),

    .idct_pixel_in(idct_2_pixel_2),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_2)

    );

  combine_predictions combine_predictions_3 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_3),

    .fwd_rght_pixel_in(fwd_2_pixel_4),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_3),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_4),

    .bwd_left_pixel_in(bwd_2_pixel_3),

    .bwd_rght_pixel_in(bwd_2_pixel_4),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_3),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_4),

    .idct_pixel_in(idct_2_pixel_3),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_3)

    );

  combine_predictions combine_predictions_4 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_4),

    .fwd_rght_pixel_in(fwd_2_pixel_5),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_4),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_5),

    .bwd_left_pixel_in(bwd_2_pixel_4),

    .bwd_rght_pixel_in(bwd_2_pixel_5),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_4),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_5),

    .idct_pixel_in(idct_2_pixel_4),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_4)

    );

  combine_predictions combine_predictions_5 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_5),

    .fwd_rght_pixel_in(fwd_2_pixel_6),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_5),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_6),

    .bwd_left_pixel_in(bwd_2_pixel_5),

    .bwd_rght_pixel_in(bwd_2_pixel_6),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_5),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_6),

    .idct_pixel_in(idct_2_pixel_5),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_5)

    );

  combine_predictions combine_predictions_6 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_6),

    .fwd_rght_pixel_in(fwd_2_pixel_7),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_6),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_7),

    .bwd_left_pixel_in(bwd_2_pixel_6),

    .bwd_rght_pixel_in(bwd_2_pixel_7),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_6),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_7),

    .idct_pixel_in(idct_2_pixel_6),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_6)

    );

  combine_predictions combine_predictions_7 (

    .rst(rst),

    .clk(clk),

    .clk_en(clk_en),

    .valid_in(valid_2),

    .write_recon_in(write_recon_2),

    .write_address_in(write_address_2),

    .motion_forward_in(motion_forward_2),

    .fwd_hor_halfpixel_in(fwd_hor_halfpixel_2),

    .fwd_ver_halfpixel_in(fwd_ver_halfpixel_2),

    .motion_backward_in(motion_backward_2),

    .bwd_hor_halfpixel_in(bwd_hor_halfpixel_2),

    .bwd_ver_halfpixel_in(bwd_ver_halfpixel_2),

    .fwd_left_pixel_in(fwd_2_pixel_7),

    .fwd_rght_pixel_in(fwd_2_pixel_8),

    .prev_fwd_left_pixel_in(prev_fwd_2_pixel_7),

    .prev_fwd_rght_pixel_in(prev_fwd_2_pixel_8),

    .bwd_left_pixel_in(bwd_2_pixel_7),

    .bwd_rght_pixel_in(bwd_2_pixel_8),

    .prev_bwd_left_pixel_in(prev_bwd_2_pixel_7),

    .prev_bwd_rght_pixel_in(prev_bwd_2_pixel_8),

    .idct_pixel_in(idct_2_pixel_7),

    .valid_out(),

    .write_recon_out(),

    .write_address_out(),

    .pixel_out(pixel_out_7)

    );

  always @(posedge clk)

    if (~rst) recon_wr_en <= 1'b0;

    else if (clk_en) recon_wr_en <= write_recon_out && valid_out;

    else recon_wr_en <= recon_wr_en;

  always @(posedge clk)

    if (~rst) recon_wr_addr <= 22'b0;

    else if (clk_en && valid_out) recon_wr_addr <= write_address_out;

    else recon_wr_addr <= recon_wr_addr;

  always @(posedge clk)

    if (~rst) recon_wr_dta <= 64'b0;

    else if (clk_en && valid_out) recon_wr_dta <= {pixel_out_0, pixel_out_1, pixel_out_2, pixel_out_3, pixel_out_4, pixel_out_5, pixel_out_6, pixel_out_7};