URL https://opencores.org/ocsvn/macroblock_motion_detection/macroblock_motion_detection/trunk

Subversion Repositories macroblock_motion_detection

[/] [macroblock_motion_detection/] [trunk/] [macroblock_motion_detection/] [MotionDetection.v] - Blame information for rev 24

Details | Compare with Previous | View Log


/////////////////////////////////////////////////////////////////////
////                                                             ////
////  MotionDetection.v                                          ////
////                                                             ////
////  Performs motion estimation for one 16 x 16 macroblock      ////
////  in a 48 x 48 pixel window every 512 clock cycles.          ////
////                                                             ////
////                                                             ////
////  Author: James Edgar                                        ////
////          JamesSEDgar@Hotmail.com                            ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2004 James Edgar                              ////
////                                                             ////
//// This source file may be used and distributed without        ////
//// restriction provided that this copyright statement is not   ////
//// removed from the file and that any derivative work contains ////
//// the original copyright notice and the associated disclaimer.////
////                                                             ////
////     THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. 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.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// This disclaimer of warranty extends to the user of these    ////
//// programs and user's customers, employees, agents,           ////
//// transferees, successors, and assigns.                       ////
////                                                             ////
//// The author does not represent or warrant that the programs  ////
//// furnished hereunder are free of infringement of any         ////
//// third-party patents.                                        ////
////                                                             ////
//// Commercial implementations of MPEG like video encoders      ////
//// 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.                                                     ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
//synopsys translate_off
`include "timescale.v"
//synopsys translate_on
module MotionDetection(clk, ena, rst, din1, din2, dout, state, count);
// runs at 1/2 clock speed?
reg clk2;
parameter COMP =  0;
 
input [31:0] din1, din2;
input clk, ena, rst;
input [3:0] state;
output [31:0] dout;
input [8:0] count;
 
reg [31:0] dout;
 
integer i, j, k, l, m, n, o;
 
// Motion Estimation Registers
 
  reg [8:0]  diff[0:2][0:15];
  reg [7:0]  diffp[0:15];
  reg [7:0]  diffpd[0:15];
  reg [7:0]  diffm[0:2][0:15];
  reg [7:0]  diffpp[0:2][0:15];
  reg [7:0]  diffmm[0:2][0:15];
  reg [7:0]  diffmd[0:2][0:15];
  reg [10:0] difft[0:2][0:3];
 
  reg [3:0]  offset;
  wire [7:0]  curt[0:15];
  wire [7:0]  searcht [0:47];
 
  reg [15:0] sums [0:2][0:11];
  reg [15:0] lowsum[0:1];
  reg        lowflag;
 
  reg [5:0]  minxt,minyt;
  reg [5:0]  oldminx,oldminy;
  reg [3:0]  cursum;
  reg        sumflag;
  reg [5:0]  minx;
  reg [5:0]  miny;
 
    wire [31:0] DOUTC0;
    wire [31:0] DOUTC1;
    wire [31:0] DOUTC2;
    wire [31:0] DOUTC3;
    wire [31:0] DOUT0;
    wire [31:0] DOUT1;
    wire [31:0] DOUT2;
    wire [31:0] DOUT3;
    wire [31:0] DOUT4;
    wire [31:0] DOUT5;
    wire [31:0] DOUT6;
    wire [31:0] DOUT7;
    wire [31:0] DOUT8;
    wire [31:0] DOUT9;
    wire [31:0] DOUT10;
    wire [31:0] DOUT11;
 
assign {curt[0],curt[1],curt[2],curt[3]} = DOUTC0;
assign {curt[4],curt[5],curt[6],curt[7]} =  DOUTC1;
assign {curt[8],curt[9],curt[10],curt[11]} =  DOUTC2;
assign {curt[12],curt[13],curt[14],curt[15]} =  DOUTC3;
 
assign {searcht[0],searcht[1],searcht[2],searcht[3]} = DOUT0;
assign {searcht[4],searcht[5],searcht[6],searcht[7]} = DOUT1;
assign {searcht[8],searcht[9],searcht[10],searcht[11]} = DOUT2;
assign {searcht[12],searcht[13],searcht[14],searcht[15]} = DOUT3;
assign {searcht[16],searcht[17],searcht[18],searcht[19]} = DOUT4;
assign {searcht[20],searcht[21],searcht[22],searcht[23]} = DOUT5;
assign {searcht[24],searcht[25],searcht[26],searcht[27]} = DOUT6;
assign {searcht[28],searcht[29],searcht[30],searcht[31]} = DOUT7;
assign {searcht[32],searcht[33],searcht[34],searcht[35]} = DOUT8;
assign {searcht[36],searcht[37],searcht[38],searcht[39]} = DOUT9;
assign {searcht[40],searcht[41],searcht[42],searcht[43]} = DOUT10;
assign {searcht[44],searcht[45],searcht[46],searcht[47]} = DOUT11;
 
// Instantiate MD_Block_Ram
    MD_Block_Ram MD_Block_Ram (
        .clk(clk2),
        .ena(ena),
        .rst(rst),
        .din1(din1),
        .din2(din2),
        .DOUTC0(DOUTC0),
        .DOUTC1(DOUTC1),
        .DOUTC2(DOUTC2),
        .DOUTC3(DOUTC3),
        .DOUT0(DOUT0),
        .DOUT1(DOUT1),
        .DOUT2(DOUT2),
        .DOUT3(DOUT3),
        .DOUT4(DOUT4),
        .DOUT5(DOUT5),
        .DOUT6(DOUT6),
        .DOUT7(DOUT7),
        .DOUT8(DOUT8),
        .DOUT9(DOUT9),
        .DOUT10(DOUT10),
        .DOUT11(DOUT11),
        .count(count),
        .minx(minx),
        .miny(miny)
        );
 
 
always @(posedge clk2 or negedge rst)
  begin
    if (~rst)
      begin
           i = 0;
           o = 0;
           for (i = 0; i < 12; i=i+1)
             begin
                  sums[0][i] <= 0;
                  sums[1][i] <= 0;
                  sums[2][i] <= 0;
                end
         end
    else
      begin
        if (ena)
          begin
            case (state)
              COMP:
                begin
                           // delay curt 1 cycle to match diffm selection below
                      for (i=0; i < 16; i=i+1)
                              begin
                                         diffp[i] <= curt[i];
                                    end
                      for (i=0; i < 16; i=i+1)
                              begin
                                         diffpd[i] <= diffp[i];
                                    end
                        // find differences for this row at three places
 
                           case (offset)
                                8:  begin     // 1 and 3 offset by 16
                          for (i=0; i < 16; i=i+1)
                                 begin
                                            diffm[0][i] <= searcht[i+8];
                                            diffm[2][i] <= searcht[i+24];
                                          end
                                    end
                                4:  begin     // 1 and 3 offset by 8
                          for (i=0; i < 16; i=i+1)
                                 begin
                                         case (minx)
                                              8:   begin
                                                     diffm[0][i] <= searcht[i+4];
                                                   end
                                              16:  begin
                                                     diffm[0][i] <= searcht[i+12];
                                                   end
                                              24:  begin
                                                     diffm[0][i] <= searcht[i+20];
                                                   end
                                            endcase
                                          end
                          for (i=8; i < 16; i=i+1)
                                 begin
                                         case (minx)
                                              8:   begin
                                                     diffm[2][i] <= searcht[i+12];
                                                   end
                                              16:  begin
                                                     diffm[2][i] <= searcht[i+20];
                                                   end
                                              24:  begin
                                                     diffm[2][i] <= searcht[i+28];
                                                   end
                                            endcase
                                          end
                                    end
                                2:  begin     // 1 and 3 offset by 4
                          for (i=0; i < 16; i=i+1)
                                 begin
                                         case (minx)
                                              4:         begin
                                                     diffm[0][i] <= searcht[i+2];
                                                   end
                                              8:   begin
                                                     diffm[0][i] <= searcht[i+6];
                                                   end
                                                 12:     begin
                                                     diffm[0][i] <= searcht[i+10];
                                                   end
                                              16:  begin
                                                     diffm[0][i] <= searcht[i+14];
                                                   end
                                                 20:     begin
                                                     diffm[0][i] <= searcht[i+18];
                                                   end
                                              24:  begin
                                                     diffm[0][i] <= searcht[i+22];
                                                   end
                                                 28:     begin
                                                     diffm[0][i] <= searcht[i+26];
                                                   end
                                            endcase
                                          end
                          for (i=12; i < 16; i=i+1)
                                 begin
                                         case (minx)
                                              4:         begin
                                                     diffm[2][i] <= searcht[i+6];
                                                   end
                                              8:   begin
                                                     diffm[2][i] <= searcht[i+10];
                                                   end
                                                 12:     begin
                                                     diffm[2][i] <= searcht[i+14];
                                                   end
                                              16:  begin
                                                     diffm[2][i] <= searcht[i+18];
                                                   end
                                                 20:     begin
                                                     diffm[2][i] <= searcht[i+22];
                                                   end
                                              24:  begin
                                                     diffm[2][i] <= searcht[i+26];
                                                   end
                                                 28:     begin
                                                     diffm[2][i] <= searcht[i+30];
                                                   end
                                            endcase
                                          end
                                    end
                                1:  begin     // 1 and 3 offset by 2
                          for (i=0; i < 16; i=i+1)
                                 begin
                                         case (minx)
                                              2:         begin
                                                     diffm[0][i] <= searcht[i+1];
                                                   end
                                              4:         begin
                                                     diffm[0][i] <= searcht[i+3];
                                                   end
                                                 6:      begin
                                                     diffm[0][i] <= searcht[i+5];
                                                   end
                                              8:   begin
                                                     diffm[0][i] <= searcht[i+7];
                                                   end
                                                 10:     begin
                                                     diffm[0][i] <= searcht[i+9];
                                                   end
                                                 12:     begin
                                                     diffm[0][i] <= searcht[i+11];
                                                   end
                                                 14:     begin
                                                     diffm[0][i] <= searcht[i+13];
                                                   end
                                              16:  begin
                                                     diffm[0][i] <= searcht[i+15];
                                                   end
                                                 18:     begin
                                                     diffm[0][i] <= searcht[i+17];
                                                   end
                                                 20:     begin
                                                     diffm[0][i] <= searcht[i+19];
                                                   end
                                                 22:     begin
                                                     diffm[0][i] <= searcht[i+21];
                                                   end
                                              24:  begin
                                                     diffm[0][i] <= searcht[i+23];
                                                   end
                                                 26:     begin
                                                     diffm[0][i] <= searcht[i+25];
                                                   end
                                                 28:     begin
                                                     diffm[0][i] <= searcht[i+27];
                                                   end
                                                 30:     begin
                                                     diffm[0][i] <= searcht[i+29];
                                                   end
                                            endcase
                                          end
                          for (i=14; i < 16; i=i+1)
                                 begin
                                         case (minx)
                                              2:         begin
                                                     diffm[2][i] <= searcht[i+3];
                                                   end
                                              4:         begin
                                                     diffm[2][i] <= searcht[i+5];
                                                   end
                                                 6:      begin
                                                     diffm[2][i] <= searcht[i+7];
                                                   end
                                              8:   begin
                                                     diffm[2][i] <= searcht[i+9];
                                                   end
                                                 10:     begin
                                                     diffm[2][i] <= searcht[i+11];
                                                   end
                                                 12:     begin
                                                     diffm[2][i] <= searcht[i+13];
                                                   end
                                                 14:     begin
                                                     diffm[2][i] <= searcht[i+15];
                                                   end
                                              16:  begin
                                                     diffm[2][i] <= searcht[i+17];
                                                   end
                                                 18:     begin
                                                     diffm[2][i] <= searcht[i+19];
                                                   end
                                                 20:     begin
                                                     diffm[2][i] <= searcht[i+21];
                                                   end
                                                 22:     begin
                                                     diffm[2][i] <= searcht[i+23];
                                                   end
                                              24:  begin
                                                     diffm[2][i] <= searcht[i+25];
                                                   end
                                                 26:     begin
                                                     diffm[2][i] <= searcht[i+27];
                                                   end
                                                 28:     begin
                                                     diffm[2][i] <= searcht[i+29];
                                                   end
                                                 30:     begin
                                                     diffm[2][i] <= searcht[i+31];
                                                   end
                                            endcase
                                          end
                                    end
                           endcase
// copy from 1 and 3 to 1 2 and 3
// 1 is the same
                           for (i=0; i < 16; i=i+1)
                          begin
                                  diffmd[0][i] <= diffm[0][i];
                                end
// 2 is combination of 1 and 3
                           case (offset)
                           8:  begin
                                    for (i=0; i < 8; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[0][i+8];
                                           diffmd[1][i+8] <= diffm[2][i];
                                      end
                               end
                           4:  begin
                                    for (i=0; i < 12; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[0][i+4];
                                      end
                                    for (i=12; i < 16; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[2][i-4];
                                      end
                               end
                           2:  begin
                                    for (i=0; i < 14; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[0][i+2];
                                      end
                                    for (i=14; i < 16; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[2][i-2];
                                      end
                               end
                           1:  begin
                                    for (i=0; i < 15; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[0][i+1];
                                      end
                                    for (i=15; i < 16; i=i+1)
                                begin
                                        diffmd[1][i] <= diffm[2][i-1];
                                      end
                               end
                           endcase
// 3 is combination of 1 and 3
                           case (offset)
                           8:  begin
                                    for (i=0; i < 16; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[2][i];
                                      end
                               end
                           4:  begin
                                    for (i=0; i < 8; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[0][i+8];
                                      end
                                    for (i=8; i < 16; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[2][i];
                                      end
                               end
                           2:  begin
                                    for (i=0; i < 12; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[0][i+4];
                                      end
                                    for (i=12; i < 16; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[2][i];
                                      end
                               end
                           1:  begin
                                    for (i=0; i < 14; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[0][i+2];
                                      end
                                    for (i=14; i < 16; i=i+1)
                                begin
                                        diffmd[2][i] <= diffm[2][i];
                                      end
                               end
                           endcase
 
 
                        for (o = 0; o < 3; o = o + 1)
                          begin
                      for (i=0; i < 16; i=i+1)
                              begin
                                         if (diffpd[i] > diffmd[o][i])
                                           begin
                                             diffpp[o][i] <= diffpd[i];
                                                diffmm[o][i] <= diffmd[o][i];
                                           end
                                         else
                                            begin
                                             diffpp[o][i] <= diffmd[o][i];
                                                diffmm[o][i] <= diffpd[i];
                                           end
                                      diff[o][i] <= diffpp[o][i] - diffmm[o][i];
                           end  // for i 0 to 15
                          end  // for o 0 to 3
 
                        // partial sums three times for three tests per row
                        for (o = 0; o < 3; o = o + 1)
                          begin
                            for(i=0; i < 4; i = i + 1)
                              begin
                                k = {i,2'b0};
                                l = k + 1;
                                m = k + 2;
                                n = k + 3;
                          difft[o][i] <= diff[o][k]+diff[o][l]+diff[o][m]+diff[o][n];
                              end
                          end    // o loop
 
                        // final sums at proper delay repeat three times for three tests per row
                        if (sumflag)
                          begin
                            for (i =0; i < 3; i = i + 1)
                              begin
                             sums[i][cursum] <= sums[i][cursum] + difft[i][0] + difft[i][1] + difft[i][2] + difft[i][3];
                              end
                          end
                           else
                             if (count == 511)
                                  begin
                                    for (i =0; i < 3; i = i + 1)
                                      begin
                                        for (j =0; j < 12; j = j + 1)
                                    begin
                                   sums[i][j] <= 0;
                                    end
                                         end
                                  end
                end      // COMP state
            endcase // state
 
          end  // if ena
         end     // if ~rst else
  end  // always
 
// control for cursum and sumflag , minx, & miny control
always @(posedge clk2 or negedge rst)
  begin
    if (~rst)
      begin
           cursum     <= 0;
           sumflag    <= 0;
           minxt      <= 0;
           minyt      <= 0;
           oldminx    <= 0;
           oldminy    <= 0;
           lowsum[1]  <= 0;
           lowflag    <= 0;
           dout       <= 0;
         end
    else
    if (ena)
      begin
           i = 5;
           case (count)         // 16 adds for each offset i from beginning
              0+i:  begin sumflag <=1; cursum <= 0; end  //0
                16+i:  begin sumflag <=1; cursum <= 1; end //16
                32+i:  begin sumflag <=1; cursum <= 2; end //32
                48+i:  sumflag <=0;
 
                49+i:  begin
                          lowflag <=1;
                          lowsum[1] <= sums[0][0];
                          minxt <= 8;
                          minyt <= 8;
                        end
                50+i:  begin
                          lowsum[1] <= sums[1][0];
                          minxt <= 16;
                          minyt <= 8;
                        end
                51+i:  begin
                          lowsum[1] <= sums[2][0];
                          minxt <= 24;
                          minyt <= 8;
                        end
 
                52+i:  begin
                          lowsum[1] <= sums[0][1];
                          minxt <= 8;
                          minyt <= 16;
                        end
                53+i:  begin
                          lowsum[1] <= sums[1][1];
                          minxt <= 16;
                          minyt <= 16;
                        end
                54+i:  begin
                          lowsum[1] <= sums[2][1];
                          minxt <= 24;
                          minyt <= 16;
                        end
 
                55+i:  begin
                          lowsum[1] <= sums[0][2];
                          minxt <= 8;
                          minyt <= 24;
                        end
                56+i:  begin
                          lowsum[1] <= sums[1][2];
                          minxt <= 16;
                          minyt <= 24;
                        end
                57+i:  begin
                          lowsum[1] <= sums[2][2];
                          minxt <= 24;
                          minyt <= 24;
                        end
                58+i:  lowflag <=0;
 
                112+i:  begin sumflag <=1; cursum <= 3; end //112
                128+i:  begin sumflag <=1; cursum <= 4; end //128
                144+i:  begin sumflag <=1; cursum <= 5; end //144
                160+i:  sumflag <=0;
                161+i:  begin
                            oldminx <= minx;
                            oldminy <= miny;
                      end
 
                162+i:  begin
                          lowflag <=1;
                          lowsum[1] <= sums[0][3];
                          minxt <= oldminx - 4;
                          minyt <= oldminy - 4;
                        end
                163+i:  begin
                          lowsum[1] <= sums[1][3];
                          minxt <= oldminx - 0;
                          minyt <= oldminy - 4;
                        end
                164+i:  begin
                          lowsum[1] <= sums[2][3];
                          minxt <= oldminx + 4;
                          minyt <= oldminy - 4;
                        end
 
                165+i:  begin
                          lowsum[1] <= sums[0][4];
                          minxt <= oldminx - 4;
                          minyt <= oldminy;
                        end
                166+i:  begin
                          lowsum[1] <= sums[1][4];
                          minxt <= oldminx;
                          minyt <= oldminy;
                        end
                167+i:  begin
                          lowsum[1] <= sums[2][4];
                          minxt <= oldminx + 4;
                          minyt <= oldminy;
                        end
 
                168+i:  begin
                          lowsum[1] <= sums[0][5];
                          minxt <= oldminx - 4;
                          minyt <= oldminy + 4;
                        end
                169+i:  begin
                          lowsum[1] <= sums[1][5];
                          minxt <= oldminx;
                          minyt <= oldminy + 4;
                        end
                170+i:  begin
                          lowsum[1] <= sums[2][5];
                          minxt <= oldminx + 4;
                          minyt <= oldminy + 4;
                        end
                171+i:  lowflag <=0;
 
                224+i:  begin sumflag <=1; cursum <= 6; end //224
                240+i:  begin sumflag <=1; cursum <= 7; end //240
                256+i:  begin sumflag <=1; cursum <= 8; end //256
                272+i:  sumflag <=0;
                273+i:  begin
                            oldminx <= minx;
                            oldminy <= miny;
                      end
                274+i:  begin
                          lowflag <=1;
                          lowsum[1] <= sums[0][6];
                          minxt <= oldminx - 2;
                          minyt <= oldminy - 2;
                        end
                275+i:  begin
                          lowsum[1] <= sums[1][6];
                          minxt <= oldminx;
                          minyt <= oldminy - 2;
                        end
                276+i:  begin
                          lowsum[1] <= sums[2][6];
                          minxt <= oldminx + 2;
                          minyt <= oldminy - 2;
                        end
 
                277+i:  begin
                          lowsum[1] <= sums[0][7];
                          minxt <= oldminx - 2;
                          minyt <= oldminy;
                        end
                278+i:  begin
                          lowsum[1] <= sums[1][7];
                          minxt <= oldminx;
                          minyt <= oldminy;
                        end
                279+i:  begin
                          lowsum[1] <= sums[2][7];
                          minxt <= oldminx + 2;
                          minyt <= oldminy;
                        end
 
                280+i:  begin
                          lowsum[1] <= sums[0][8];
                          minxt <= oldminx - 2;
                          minyt <= oldminy + 2;
                        end
                281+i:  begin
                          lowsum[1] <= sums[1][8];
                          minxt <= oldminx;
                          minyt <= oldminy + 2;
                        end
                282+i:  begin
                          lowsum[1] <= sums[2][8];
                          minxt <= oldminx + 2;
                          minyt <= oldminy + 2;
                        end
                283+i:  lowflag <=0;
 
 
                336+i:  begin sumflag <=1; cursum <= 9; end //336
                352+i:  begin sumflag <=1; cursum <= 10; end //352
                368+i:  begin sumflag <=1; cursum <= 11; end //368
                384+i:  sumflag <=0;
                385+i:  begin
                            oldminx <= minx;
                            oldminy <= miny;
                      end
 
                386+i:  begin
                          lowflag <=1;
                          lowsum[1] <= sums[0][9];
                          minxt <= oldminx - 1;
                          minyt <= oldminy - 1;
                        end
                387+i:  begin
                          lowsum[1] <= sums[1][9];
                          minxt <= oldminx;
                          minyt <= oldminy - 1;
                        end
                388+i:  begin
                          lowsum[1] <= sums[2][9];
                          minxt <= oldminx + 1;
                          minyt <= oldminy - 1;
                        end
 
                389+i:  begin
                          lowsum[1] <= sums[0][10];
                          minxt <= oldminx - 1;
                          minyt <= oldminy;
                        end
                390+i:  begin
                          lowsum[1] <= sums[1][10];
                          minxt <= oldminx;
                          minyt <= oldminy;
                        end
                391+i:  begin
                          lowsum[1] <= sums[2][10];
                          minxt <= oldminx + 1;
                          minyt <= oldminy;
                        end
 
                392+i:  begin
                          lowsum[1] <= sums[0][11];
                          minxt <= oldminx - 1;
                          minyt <= oldminy + 1;
                        end
                393+i:  begin
                          lowsum[1] <= sums[1][11];
                          minxt <= oldminx;
                          minyt <= oldminy + 1;
                        end
                394+i:  begin
                          lowsum[1] <= sums[2][11];
                          minxt <= oldminx + 1;
                          minyt <= oldminy + 1;
                        end
                500:  lowflag <=0;
                507:  dout <= {10'b0,minx,10'b0,miny};
                510:  begin minxt <= 16; minyt <= 16; lowsum[1] <= 0; lowflag <=1; end
                // Upper Left Corner of Center Block
             511:  lowflag <= 0;
 
             default:  cursum <= cursum;
           endcase
         end  // if (ena)
  end  //always loop
 
// control for minx miny lowsum[0] calc
always @(posedge clk2 or negedge rst)
  begin
    if (~rst)
      begin
           lowsum[0] <= 16'b1111111111111111;
           minx    <= 0;
           miny    <= 0;
         end
    else
    if (ena)
      begin
           if (lowflag)
             begin
                  if (lowsum[1] < lowsum[0])
                 begin
                      lowsum[0] <= lowsum[1];
                      minx <= minxt;
                      miny <= minyt;
                    end
                end
           else
             begin
                  lowsum[0] <= 16'b1111111111111111;
                  minx <= minx;
                  miny <= miny;
                end
         end
  end
 
  // control for offset
always @(posedge clk2 or negedge rst)
  begin
    if (~rst)
      begin
           offset  <= 0;
         end
    else
    if (ena)
      begin
           case (count)
             111: offset  <= 4;
                223: offset  <= 2;
                335: offset  <= 1;
                511: offset  <= 8;
                default:  offset <= offset;
           endcase
         end
  end
 
  // control for clk2
always @(posedge clk or negedge rst)
  begin
    if (~rst)
      begin
           clk2  <= 0;
         end
    else
    if (ena)
      begin
           clk2 <= ~clk2;
         end
  end
endmodule

Browse

Tools

Subversion Repositories macroblock_motion_detection

[/] [macroblock_motion_detection/] [trunk/] [macroblock_motion_detection/] [MotionDetection.v] - Blame information for rev 24

Line No.	Rev	Author	Line
1	2	jamesedgar	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// MotionDetection.v ////`
4	15	jamesedgar	`//// ////`
5			`//// Performs motion estimation for one 16 x 16 macroblock ////`
6			`//// in a 48 x 48 pixel window every 512 clock cycles. ////`
7			`//// ////`
8			`//// ////`
9	2	jamesedgar	`//// Author: James Edgar ////`
10			`//// JamesSEDgar@Hotmail.com ////`
11			`//// ////`
12			`/////////////////////////////////////////////////////////////////////`
13			`//// ////`
14			`//// Copyright (C) 2004 James Edgar ////`
15			`//// ////`
16			`//// This source file may be used and distributed without ////`
17			`//// restriction provided that this copyright statement is not ////`
18			`//// removed from the file and that any derivative work contains ////`
19			`//// the original copyright notice and the associated disclaimer.////`
20			`//// ////`
21			//// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY ////
22			`//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ////`
23			`//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ////`
24			`//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR ////`
25			`//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ////`
26			`//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ////`
27			`//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ////`
28			`//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR ////`
29			`//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ////`
30			`//// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ////`
31			`//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ////`
32			`//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ////`
33			`//// POSSIBILITY OF SUCH DAMAGE. ////`
34			`//// ////`
35	15	jamesedgar	`/////////////////////////////////////////////////////////////////////`
36	2	jamesedgar	`//// ////`
37	15	jamesedgar	`//// This disclaimer of warranty extends to the user of these ////`
38			`//// programs and user's customers, employees, agents, ////`
39			`//// transferees, successors, and assigns. ////`
40			`//// ////`
41			`//// The author does not represent or warrant that the programs ////`
42			`//// furnished hereunder are free of infringement of any ////`
43			`//// third-party patents. ////`
44			`//// ////`
45			`//// Commercial implementations of MPEG like video encoders ////`
46			`//// including shareware, are subject to royalty fees to patent ////`
47			`//// holders. Many of these patents are general enough such ////`
48			`//// that they are unavoidable regardless of implementation ////`
49			`//// design. ////`
50			`//// ////`
51			`/////////////////////////////////////////////////////////////////////`
52
53	2	jamesedgar	`//synopsys translate_off`
54			`include "timescale.v"
55	15	jamesedgar	`//synopsys translate_on`
56			`module MotionDetection(clk, ena, rst, din1, din2, dout, state, count);`
57			`// runs at 1/2 clock speed?`
58			`reg clk2;`
59			`parameter COMP = 0;`
60
61			`input [31:0] din1, din2;`
62			`input clk, ena, rst;`
63			`input [3:0] state;`
64			`output [31:0] dout;`
65			`input [8:0] count;`
66
67			`reg [31:0] dout;`
68
69			`integer i, j, k, l, m, n, o;`
70
71			`// Motion Estimation Registers`
72
73			`reg [8:0] diff[0:2][0:15];`
74			`reg [7:0] diffp[0:15];`
75			`reg [7:0] diffpd[0:15];`
76			`reg [7:0] diffm[0:2][0:15];`
77			`reg [7:0] diffpp[0:2][0:15];`
78			`reg [7:0] diffmm[0:2][0:15];`
79			`reg [7:0] diffmd[0:2][0:15];`
80			`reg [10:0] difft[0:2][0:3];`
81
82			`reg [3:0] offset;`
83			`wire [7:0] curt[0:15];`
84			`wire [7:0] searcht [0:47];`
85
86			`reg [15:0] sums [0:2][0:11];`
87			`reg [15:0] lowsum[0:1];`
88			`reg lowflag;`
89
90			`reg [5:0] minxt,minyt;`
91			`reg [5:0] oldminx,oldminy;`
92			`reg [3:0] cursum;`
93			`reg sumflag;`
94			`reg [5:0] minx;`
95			`reg [5:0] miny;`
96
97			`wire [31:0] DOUTC0;`
98			`wire [31:0] DOUTC1;`
99			`wire [31:0] DOUTC2;`
100			`wire [31:0] DOUTC3;`
101			`wire [31:0] DOUT0;`
102			`wire [31:0] DOUT1;`
103			`wire [31:0] DOUT2;`
104			`wire [31:0] DOUT3;`
105			`wire [31:0] DOUT4;`
106			`wire [31:0] DOUT5;`
107			`wire [31:0] DOUT6;`
108			`wire [31:0] DOUT7;`
109			`wire [31:0] DOUT8;`
110			`wire [31:0] DOUT9;`
111			`wire [31:0] DOUT10;`
112			`wire [31:0] DOUT11;`
113
114			`assign {curt[0],curt[1],curt[2],curt[3]} = DOUTC0;`
115			`assign {curt[4],curt[5],curt[6],curt[7]} = DOUTC1;`
116			`assign {curt[8],curt[9],curt[10],curt[11]} = DOUTC2;`
117			`assign {curt[12],curt[13],curt[14],curt[15]} = DOUTC3;`
118
119			`assign {searcht[0],searcht[1],searcht[2],searcht[3]} = DOUT0;`
120			`assign {searcht[4],searcht[5],searcht[6],searcht[7]} = DOUT1;`
121			`assign {searcht[8],searcht[9],searcht[10],searcht[11]} = DOUT2;`
122			`assign {searcht[12],searcht[13],searcht[14],searcht[15]} = DOUT3;`
123			`assign {searcht[16],searcht[17],searcht[18],searcht[19]} = DOUT4;`
124			`assign {searcht[20],searcht[21],searcht[22],searcht[23]} = DOUT5;`
125			`assign {searcht[24],searcht[25],searcht[26],searcht[27]} = DOUT6;`
126			`assign {searcht[28],searcht[29],searcht[30],searcht[31]} = DOUT7;`
127			`assign {searcht[32],searcht[33],searcht[34],searcht[35]} = DOUT8;`
128			`assign {searcht[36],searcht[37],searcht[38],searcht[39]} = DOUT9;`
129			`assign {searcht[40],searcht[41],searcht[42],searcht[43]} = DOUT10;`
130			`assign {searcht[44],searcht[45],searcht[46],searcht[47]} = DOUT11;`
131
132			`// Instantiate MD_Block_Ram`
133			`MD_Block_Ram MD_Block_Ram (`
134			`.clk(clk2),`
135			`.ena(ena),`
136			`.rst(rst),`
137			`.din1(din1),`
138			`.din2(din2),`
139			`.DOUTC0(DOUTC0),`
140			`.DOUTC1(DOUTC1),`
141			`.DOUTC2(DOUTC2),`
142			`.DOUTC3(DOUTC3),`
143			`.DOUT0(DOUT0),`
144			`.DOUT1(DOUT1),`
145			`.DOUT2(DOUT2),`
146			`.DOUT3(DOUT3),`
147			`.DOUT4(DOUT4),`
148			`.DOUT5(DOUT5),`
149			`.DOUT6(DOUT6),`
150			`.DOUT7(DOUT7),`
151			`.DOUT8(DOUT8),`
152			`.DOUT9(DOUT9),`
153			`.DOUT10(DOUT10),`
154			`.DOUT11(DOUT11),`
155			`.count(count),`
156			`.minx(minx),`
157			`.miny(miny)`
158			`);`
159
160
161			`always @(posedge clk2 or negedge rst)`
162			`begin`
163			`if (~rst)`
164			`begin`
165			`i = 0;`
166			`o = 0;`
167			`for (i = 0; i < 12; i=i+1)`
168			`begin`
169			`sums[0][i] <= 0;`
170			`sums[1][i] <= 0;`
171			`sums[2][i] <= 0;`
172			`end`
173			`end`
174			`else`
175			`begin`
176			`if (ena)`
177			`begin`
178			`case (state)`
179			`COMP:`
180			`begin`
181			`// delay curt 1 cycle to match diffm selection below`
182			`for (i=0; i < 16; i=i+1)`
183			`begin`
184			`diffp[i] <= curt[i];`
185			`end`
186			`for (i=0; i < 16; i=i+1)`
187			`begin`
188			`diffpd[i] <= diffp[i];`
189			`end`
190			`// find differences for this row at three places`
191
192			`case (offset)`
193			`8: begin // 1 and 3 offset by 16`
194			`for (i=0; i < 16; i=i+1)`
195			`begin`
196			`diffm[0][i] <= searcht[i+8];`
197			`diffm[2][i] <= searcht[i+24];`
198			`end`
199			`end`
200			`4: begin // 1 and 3 offset by 8`
201			`for (i=0; i < 16; i=i+1)`
202			`begin`
203			`case (minx)`
204			`8: begin`
205			`diffm[0][i] <= searcht[i+4];`
206			`end`
207			`16: begin`
208			`diffm[0][i] <= searcht[i+12];`
209			`end`
210			`24: begin`
211			`diffm[0][i] <= searcht[i+20];`
212			`end`
213			`endcase`
214			`end`
215			`for (i=8; i < 16; i=i+1)`
216			`begin`
217			`case (minx)`
218			`8: begin`
219			`diffm[2][i] <= searcht[i+12];`
220			`end`
221			`16: begin`
222			`diffm[2][i] <= searcht[i+20];`
223			`end`
224			`24: begin`
225			`diffm[2][i] <= searcht[i+28];`
226			`end`
227			`endcase`
228			`end`
229			`end`
230			`2: begin // 1 and 3 offset by 4`
231			`for (i=0; i < 16; i=i+1)`
232			`begin`
233			`case (minx)`
234			`4: begin`
235			`diffm[0][i] <= searcht[i+2];`
236			`end`
237			`8: begin`
238			`diffm[0][i] <= searcht[i+6];`
239			`end`
240			`12: begin`
241			`diffm[0][i] <= searcht[i+10];`
242			`end`
243			`16: begin`
244			`diffm[0][i] <= searcht[i+14];`
245			`end`
246			`20: begin`
247			`diffm[0][i] <= searcht[i+18];`
248			`end`
249			`24: begin`
250			`diffm[0][i] <= searcht[i+22];`
251			`end`
252			`28: begin`
253			`diffm[0][i] <= searcht[i+26];`
254			`end`
255			`endcase`
256			`end`
257			`for (i=12; i < 16; i=i+1)`
258			`begin`
259			`case (minx)`
260			`4: begin`
261			`diffm[2][i] <= searcht[i+6];`
262			`end`
263			`8: begin`
264			`diffm[2][i] <= searcht[i+10];`
265			`end`
266			`12: begin`
267			`diffm[2][i] <= searcht[i+14];`
268			`end`
269			`16: begin`
270			`diffm[2][i] <= searcht[i+18];`
271			`end`
272			`20: begin`
273			`diffm[2][i] <= searcht[i+22];`
274			`end`
275			`24: begin`
276			`diffm[2][i] <= searcht[i+26];`
277			`end`
278			`28: begin`
279			`diffm[2][i] <= searcht[i+30];`
280			`end`
281			`endcase`
282			`end`
283			`end`
284			`1: begin // 1 and 3 offset by 2`
285			`for (i=0; i < 16; i=i+1)`
286			`begin`
287			`case (minx)`
288			`2: begin`
289			`diffm[0][i] <= searcht[i+1];`
290			`end`
291			`4: begin`
292			`diffm[0][i] <= searcht[i+3];`
293			`end`
294			`6: begin`
295			`diffm[0][i] <= searcht[i+5];`
296			`end`
297			`8: begin`
298			`diffm[0][i] <= searcht[i+7];`
299			`end`
300			`10: begin`
301			`diffm[0][i] <= searcht[i+9];`
302			`end`
303			`12: begin`
304			`diffm[0][i] <= searcht[i+11];`
305			`end`
306			`14: begin`
307			`diffm[0][i] <= searcht[i+13];`
308			`end`
309			`16: begin`
310			`diffm[0][i] <= searcht[i+15];`
311			`end`
312			`18: begin`
313			`diffm[0][i] <= searcht[i+17];`
314			`end`
315			`20: begin`
316			`diffm[0][i] <= searcht[i+19];`
317			`end`
318			`22: begin`
319			`diffm[0][i] <= searcht[i+21];`
320			`end`
321			`24: begin`
322			`diffm[0][i] <= searcht[i+23];`
323			`end`
324			`26: begin`
325			`diffm[0][i] <= searcht[i+25];`
326			`end`
327			`28: begin`
328			`diffm[0][i] <= searcht[i+27];`
329			`end`
330			`30: begin`
331			`diffm[0][i] <= searcht[i+29];`
332			`end`
333			`endcase`
334			`end`
335			`for (i=14; i < 16; i=i+1)`
336			`begin`
337			`case (minx)`
338			`2: begin`
339			`diffm[2][i] <= searcht[i+3];`
340			`end`
341			`4: begin`
342			`diffm[2][i] <= searcht[i+5];`
343			`end`
344			`6: begin`
345			`diffm[2][i] <= searcht[i+7];`
346			`end`
347			`8: begin`
348			`diffm[2][i] <= searcht[i+9];`
349			`end`
350			`10: begin`
351			`diffm[2][i] <= searcht[i+11];`
352			`end`
353			`12: begin`
354			`diffm[2][i] <= searcht[i+13];`
355			`end`
356			`14: begin`
357			`diffm[2][i] <= searcht[i+15];`
358			`end`
359			`16: begin`
360			`diffm[2][i] <= searcht[i+17];`
361			`end`
362			`18: begin`
363			`diffm[2][i] <= searcht[i+19];`
364			`end`
365			`20: begin`
366			`diffm[2][i] <= searcht[i+21];`
367			`end`
368			`22: begin`
369			`diffm[2][i] <= searcht[i+23];`
370			`end`
371			`24: begin`
372			`diffm[2][i] <= searcht[i+25];`
373			`end`
374			`26: begin`
375			`diffm[2][i] <= searcht[i+27];`
376			`end`
377			`28: begin`
378			`diffm[2][i] <= searcht[i+29];`
379			`end`
380			`30: begin`
381			`diffm[2][i] <= searcht[i+31];`
382			`end`
383			`endcase`
384			`end`
385			`end`
386			`endcase`
387			`// copy from 1 and 3 to 1 2 and 3`
388			`// 1 is the same`
389			`for (i=0; i < 16; i=i+1)`
390			`begin`
391			`diffmd[0][i] <= diffm[0][i];`
392			`end`
393			`// 2 is combination of 1 and 3`
394			`case (offset)`
395			`8: begin`
396			`for (i=0; i < 8; i=i+1)`
397			`begin`
398			`diffmd[1][i] <= diffm[0][i+8];`
399			`diffmd[1][i+8] <= diffm[2][i];`
400			`end`
401			`end`
402			`4: begin`
403			`for (i=0; i < 12; i=i+1)`
404			`begin`
405			`diffmd[1][i] <= diffm[0][i+4];`
406			`end`
407			`for (i=12; i < 16; i=i+1)`
408			`begin`
409			`diffmd[1][i] <= diffm[2][i-4];`
410			`end`
411			`end`
412			`2: begin`
413			`for (i=0; i < 14; i=i+1)`
414			`begin`
415			`diffmd[1][i] <= diffm[0][i+2];`
416			`end`
417			`for (i=14; i < 16; i=i+1)`
418			`begin`
419			`diffmd[1][i] <= diffm[2][i-2];`
420			`end`
421			`end`
422			`1: begin`
423			`for (i=0; i < 15; i=i+1)`
424			`begin`
425			`diffmd[1][i] <= diffm[0][i+1];`
426			`end`
427			`for (i=15; i < 16; i=i+1)`
428			`begin`
429			`diffmd[1][i] <= diffm[2][i-1];`
430			`end`
431			`end`
432			`endcase`
433			`// 3 is combination of 1 and 3`
434			`case (offset)`
435			`8: begin`
436			`for (i=0; i < 16; i=i+1)`
437			`begin`
438			`diffmd[2][i] <= diffm[2][i];`
439			`end`
440			`end`
441			`4: begin`
442			`for (i=0; i < 8; i=i+1)`
443			`begin`
444			`diffmd[2][i] <= diffm[0][i+8];`
445			`end`
446			`for (i=8; i < 16; i=i+1)`
447			`begin`
448			`diffmd[2][i] <= diffm[2][i];`
449			`end`
450			`end`
451			`2: begin`
452			`for (i=0; i < 12; i=i+1)`
453			`begin`
454			`diffmd[2][i] <= diffm[0][i+4];`
455			`end`
456			`for (i=12; i < 16; i=i+1)`
457			`begin`
458			`diffmd[2][i] <= diffm[2][i];`
459			`end`
460			`end`
461			`1: begin`
462			`for (i=0; i < 14; i=i+1)`
463			`begin`
464			`diffmd[2][i] <= diffm[0][i+2];`
465			`end`
466			`for (i=14; i < 16; i=i+1)`
467			`begin`
468			`diffmd[2][i] <= diffm[2][i];`
469			`end`
470			`end`
471			`endcase`
472
473
474			`for (o = 0; o < 3; o = o + 1)`
475			`begin`
476			`for (i=0; i < 16; i=i+1)`
477			`begin`
478			`if (diffpd[i] > diffmd[o][i])`
479			`begin`
480			`diffpp[o][i] <= diffpd[i];`
481			`diffmm[o][i] <= diffmd[o][i];`
482			`end`
483			`else`
484			`begin`
485			`diffpp[o][i] <= diffmd[o][i];`
486			`diffmm[o][i] <= diffpd[i];`
487			`end`
488			`diff[o][i] <= diffpp[o][i] - diffmm[o][i];`
489			`end // for i 0 to 15`
490			`end // for o 0 to 3`
491
492			`// partial sums three times for three tests per row`
493			`for (o = 0; o < 3; o = o + 1)`
494			`begin`
495			`for(i=0; i < 4; i = i + 1)`
496			`begin`
497			`k = {i,2'b0};`
498			`l = k + 1;`
499			`m = k + 2;`
500			`n = k + 3;`
501			`difft[o][i] <= diff[o][k]+diff[o][l]+diff[o][m]+diff[o][n];`
502			`end`
503			`end // o loop`
504
505			`// final sums at proper delay repeat three times for three tests per row`
506			`if (sumflag)`
507			`begin`
508			`for (i =0; i < 3; i = i + 1)`
509			`begin`
510			`sums[i][cursum] <= sums[i][cursum] + difft[i][0] + difft[i][1] + difft[i][2] + difft[i][3];`
511			`end`
512			`end`
513			`else`
514			`if (count == 511)`
515			`begin`
516			`for (i =0; i < 3; i = i + 1)`
517			`begin`
518			`for (j =0; j < 12; j = j + 1)`
519			`begin`
520			`sums[i][j] <= 0;`
521			`end`
522			`end`
523			`end`
524			`end // COMP state`
525			`endcase // state`
526
527			`end // if ena`
528			`end // if ~rst else`
529			`end // always`
530
531			`// control for cursum and sumflag , minx, & miny control`
532			`always @(posedge clk2 or negedge rst)`
533			`begin`
534			`if (~rst)`
535			`begin`
536			`cursum <= 0;`
537			`sumflag <= 0;`
538			`minxt <= 0;`
539			`minyt <= 0;`
540			`oldminx <= 0;`
541			`oldminy <= 0;`
542			`lowsum[1] <= 0;`
543			`lowflag <= 0;`
544			`dout <= 0;`
545			`end`
546			`else`
547			`if (ena)`
548			`begin`
549			`i = 5;`
550			`case (count) // 16 adds for each offset i from beginning`
551			`0+i: begin sumflag <=1; cursum <= 0; end //0`
552			`16+i: begin sumflag <=1; cursum <= 1; end //16`
553			`32+i: begin sumflag <=1; cursum <= 2; end //32`
554			`48+i: sumflag <=0;`
555
556			`49+i: begin`
557			`lowflag <=1;`
558			`lowsum[1] <= sums[0][0];`
559			`minxt <= 8;`
560			`minyt <= 8;`
561			`end`
562			`50+i: begin`
563			`lowsum[1] <= sums[1][0];`
564			`minxt <= 16;`
565			`minyt <= 8;`
566			`end`
567			`51+i: begin`
568			`lowsum[1] <= sums[2][0];`
569			`minxt <= 24;`
570			`minyt <= 8;`
571			`end`
572
573			`52+i: begin`
574			`lowsum[1] <= sums[0][1];`
575			`minxt <= 8;`
576			`minyt <= 16;`
577			`end`
578			`53+i: begin`
579			`lowsum[1] <= sums[1][1];`
580			`minxt <= 16;`
581			`minyt <= 16;`
582			`end`
583			`54+i: begin`
584			`lowsum[1] <= sums[2][1];`
585			`minxt <= 24;`
586			`minyt <= 16;`
587			`end`
588
589			`55+i: begin`
590			`lowsum[1] <= sums[0][2];`
591			`minxt <= 8;`
592			`minyt <= 24;`
593			`end`
594			`56+i: begin`
595			`lowsum[1] <= sums[1][2];`
596			`minxt <= 16;`
597			`minyt <= 24;`
598			`end`
599			`57+i: begin`
600			`lowsum[1] <= sums[2][2];`
601			`minxt <= 24;`
602			`minyt <= 24;`
603			`end`
604			`58+i: lowflag <=0;`
605
606			`112+i: begin sumflag <=1; cursum <= 3; end //112`
607			`128+i: begin sumflag <=1; cursum <= 4; end //128`
608			`144+i: begin sumflag <=1; cursum <= 5; end //144`
609			`160+i: sumflag <=0;`
610			`161+i: begin`
611			`oldminx <= minx;`
612			`oldminy <= miny;`
613			`end`
614
615			`162+i: begin`
616			`lowflag <=1;`
617			`lowsum[1] <= sums[0][3];`
618			`minxt <= oldminx - 4;`
619			`minyt <= oldminy - 4;`
620			`end`
621			`163+i: begin`
622			`lowsum[1] <= sums[1][3];`
623			`minxt <= oldminx - 0;`
624			`minyt <= oldminy - 4;`
625			`end`
626			`164+i: begin`
627			`lowsum[1] <= sums[2][3];`
628			`minxt <= oldminx + 4;`
629			`minyt <= oldminy - 4;`
630			`end`
631
632			`165+i: begin`
633			`lowsum[1] <= sums[0][4];`
634			`minxt <= oldminx - 4;`
635			`minyt <= oldminy;`
636			`end`
637			`166+i: begin`
638			`lowsum[1] <= sums[1][4];`
639			`minxt <= oldminx;`
640			`minyt <= oldminy;`
641			`end`
642			`167+i: begin`
643			`lowsum[1] <= sums[2][4];`
644			`minxt <= oldminx + 4;`
645			`minyt <= oldminy;`
646			`end`
647
648			`168+i: begin`
649			`lowsum[1] <= sums[0][5];`
650			`minxt <= oldminx - 4;`
651			`minyt <= oldminy + 4;`
652			`end`
653			`169+i: begin`
654			`lowsum[1] <= sums[1][5];`
655			`minxt <= oldminx;`
656			`minyt <= oldminy + 4;`
657			`end`
658			`170+i: begin`
659			`lowsum[1] <= sums[2][5];`
660			`minxt <= oldminx + 4;`
661			`minyt <= oldminy + 4;`
662			`end`
663			`171+i: lowflag <=0;`
664
665			`224+i: begin sumflag <=1; cursum <= 6; end //224`
666			`240+i: begin sumflag <=1; cursum <= 7; end //240`
667			`256+i: begin sumflag <=1; cursum <= 8; end //256`
668			`272+i: sumflag <=0;`
669			`273+i: begin`
670			`oldminx <= minx;`
671			`oldminy <= miny;`
672			`end`
673			`274+i: begin`
674			`lowflag <=1;`
675			`lowsum[1] <= sums[0][6];`
676			`minxt <= oldminx - 2;`
677			`minyt <= oldminy - 2;`
678			`end`
679			`275+i: begin`
680			`lowsum[1] <= sums[1][6];`
681			`minxt <= oldminx;`
682			`minyt <= oldminy - 2;`
683			`end`
684			`276+i: begin`
685			`lowsum[1] <= sums[2][6];`
686			`minxt <= oldminx + 2;`
687			`minyt <= oldminy - 2;`
688			`end`
689
690			`277+i: begin`
691			`lowsum[1] <= sums[0][7];`
692			`minxt <= oldminx - 2;`
693			`minyt <= oldminy;`
694			`end`
695			`278+i: begin`
696			`lowsum[1] <= sums[1][7];`
697			`minxt <= oldminx;`
698			`minyt <= oldminy;`
699			`end`
700			`279+i: begin`
701			`lowsum[1] <= sums[2][7];`
702			`minxt <= oldminx + 2;`
703			`minyt <= oldminy;`
704			`end`
705
706			`280+i: begin`
707			`lowsum[1] <= sums[0][8];`
708			`minxt <= oldminx - 2;`
709			`minyt <= oldminy + 2;`
710			`end`
711			`281+i: begin`
712			`lowsum[1] <= sums[1][8];`
713			`minxt <= oldminx;`
714			`minyt <= oldminy + 2;`
715			`end`
716			`282+i: begin`
717			`lowsum[1] <= sums[2][8];`
718			`minxt <= oldminx + 2;`
719			`minyt <= oldminy + 2;`
720			`end`
721			`283+i: lowflag <=0;`
722
723
724			`336+i: begin sumflag <=1; cursum <= 9; end //336`
725			`352+i: begin sumflag <=1; cursum <= 10; end //352`
726			`368+i: begin sumflag <=1; cursum <= 11; end //368`
727			`384+i: sumflag <=0;`
728			`385+i: begin`
729			`oldminx <= minx;`
730			`oldminy <= miny;`
731			`end`
732
733			`386+i: begin`
734			`lowflag <=1;`
735			`lowsum[1] <= sums[0][9];`
736			`minxt <= oldminx - 1;`
737			`minyt <= oldminy - 1;`
738			`end`
739			`387+i: begin`
740			`lowsum[1] <= sums[1][9];`
741			`minxt <= oldminx;`
742			`minyt <= oldminy - 1;`
743			`end`
744			`388+i: begin`
745			`lowsum[1] <= sums[2][9];`
746			`minxt <= oldminx + 1;`
747			`minyt <= oldminy - 1;`
748			`end`
749
750			`389+i: begin`
751			`lowsum[1] <= sums[0][10];`
752			`minxt <= oldminx - 1;`
753			`minyt <= oldminy;`
754			`end`
755			`390+i: begin`
756			`lowsum[1] <= sums[1][10];`
757			`minxt <= oldminx;`
758			`minyt <= oldminy;`
759			`end`
760			`391+i: begin`
761			`lowsum[1] <= sums[2][10];`
762			`minxt <= oldminx + 1;`
763			`minyt <= oldminy;`
764			`end`
765
766			`392+i: begin`
767			`lowsum[1] <= sums[0][11];`
768			`minxt <= oldminx - 1;`
769			`minyt <= oldminy + 1;`
770			`end`
771			`393+i: begin`
772			`lowsum[1] <= sums[1][11];`
773			`minxt <= oldminx;`
774			`minyt <= oldminy + 1;`
775			`end`
776			`394+i: begin`
777			`lowsum[1] <= sums[2][11];`
778			`minxt <= oldminx + 1;`
779			`minyt <= oldminy + 1;`
780			`end`
781			`500: lowflag <=0;`
782			`507: dout <= {10'b0,minx,10'b0,miny};`
783			`510: begin minxt <= 16; minyt <= 16; lowsum[1] <= 0; lowflag <=1; end`
784			`// Upper Left Corner of Center Block`
785			`511: lowflag <= 0;`
786
787			`default: cursum <= cursum;`
788			`endcase`
789			`end // if (ena)`
790			`end //always loop`
791
792			`// control for minx miny lowsum[0] calc`
793			`always @(posedge clk2 or negedge rst)`
794			`begin`
795			`if (~rst)`
796			`begin`
797			`lowsum[0] <= 16'b1111111111111111;`
798			`minx <= 0;`
799			`miny <= 0;`
800			`end`
801			`else`
802			`if (ena)`
803			`begin`
804			`if (lowflag)`
805			`begin`
806			`if (lowsum[1] < lowsum[0])`
807			`begin`
808			`lowsum[0] <= lowsum[1];`
809			`minx <= minxt;`
810			`miny <= minyt;`
811			`end`
812			`end`
813			`else`
814			`begin`
815			`lowsum[0] <= 16'b1111111111111111;`
816			`minx <= minx;`
817			`miny <= miny;`
818			`end`
819			`end`
820			`end`
821
822			`// control for offset`
823			`always @(posedge clk2 or negedge rst)`
824			`begin`
825			`if (~rst)`
826			`begin`
827			`offset <= 0;`
828			`end`
829			`else`
830			`if (ena)`
831			`begin`
832			`case (count)`
833			`111: offset <= 4;`
834			`223: offset <= 2;`
835			`335: offset <= 1;`
836			`511: offset <= 8;`
837			`default: offset <= offset;`
838			`endcase`
839			`end`
840			`end`
841
842			`// control for clk2`
843			`always @(posedge clk or negedge rst)`
844			`begin`
845			`if (~rst)`
846			`begin`
847			`clk2 <= 0;`
848			`end`
849			`else`
850			`if (ena)`
851			`begin`
852			`clk2 <= ~clk2;`
853			`end`
854			`end`
855			`endmodule`