18.双线性插值缩放算法的matlab与FPGA实现（二）

MATALB算法转化为FPGA算法的过程

  在图像算法中，可以知道算法本身不算复杂，但是在FPGA中，视频重要用视频流的方式在FPGA中，基本不大概对图像进行任意位置的索引。因此，如何根据视频流来进行插值最难的点在于如何寻找到缩放后的点对应的四个点坐标。
  根据视频流的特点，可以知道视频流的索引式按照左上到右下进行依次索引的。根据这个特点，可以实现只缓存几行数据即可实现图像的索引。
  这里缩放算法对视频流有两种，一种是主动式(act)，另一种是被动式（inact），主动式是指算法的视频流输入不受缩放模块控制，视频信息通常以视频流的方式直接进入模块。被动式式指算法的视频流输入受到缩放模块的控制,视频流一般先存储在DDR、SDRAM等存储介质中，等待缩放模块去读取像素信息。
  由双线性插值的直观图一节结合FPGA中的数据流特点，可以大致推算出FPGA的缩放实现原理。
  首先由缩放后的显示信息来依次产生缩放后的坐标信息，然后根据缩放后的坐标信息来推算出缩放前的像素信息，根据缩放前的像素信息来求出加权和得到缩放后的坐标像素。难点是判定点是否到了下一个数据并且找到精确的四个点。
被动式的缩放算法

  被动式的缩放算法模块中像素信息由卑鄙数据流主动索取，一般卑鄙数据流可以为显示模块或者算法模块。首先，我们来看被动式的模块接口。可以看到缩放前的数据由缩放模块主动请求，而缩放后的数据由缩放模块被动发出。

1. module scaler_inact #(
2.         parameter SRC_IW = 640         ,
3.         parameter SRC_IH = 480         ,
4.         parameter DST_IW = 1280 ,
5.         parameter DST_IH = 720
6. )
7. (
8.         input                                clk                                ,         //输入时钟
9.         input                                rst                                ,         //复位
10.         //上游一般是内存DMA的读出缓存                       
11.         input                                pre_ready                ,         //上游数据准备信号
12.         output                                pre_req                        ,         //数据请求输入信号
13.         input                [7:0]        pre_data                ,         //数据输入
14.        
15.         //下游一般是VGA/HDMI等数据显示端口
16.         input                                post_clk                ,         //数据输出时钟
17.         output        reg                        post_ready                ,         //数据缓存准备好
18.         input                                post_req                ,         //数据请求输出信号
19.         output                [7:0]        post_data                ,         //数据输出
20.         output                                post_empty                         //数据空信号
21. );

复制代码

  首先，MATLAB中求出缩放系数：                                             s                            x                                       s_x                  sx​和                                             s                            y                                       s_y                  sy​。

1. sx = src_w / dst_w;
2. sy = src_h / dst_h;

复制代码

  对应的，在FPGA中也要求出缩放系数，由于模块的输入输入比例都是已知的（例化时参数已经定义了），以是这个缩放系数也可以直接求出。这里由于缩放系数一般都是浮点数，以是将数据放大                                             2                            12                                  次方                              2^{12}次方                  212次方.

1. //fix16_12
2. localparam         [15:0]         sx         =         SRC_IW*4096/DST_IW         ;
3. localparam        [15:0]         sy         =         SRC_IH*4096/DST_IH         ;

复制代码

  盘算出了缩放系数后，MATLAB开始进行循环索引了，这里也是FPGA实现的难点之一。首先来看FPGA中的目标图像计数。

1. always @(posedge clk)
2.         if(rst)
3.                 dst_hcnt         <=         0;
4.         else if(dst_hcnt == DST_IW - 1)
5.                 dst_hcnt         <=         0;
6.         else if(dst_de == 1'b1)
7.                 dst_hcnt         <=         dst_hcnt + 1;
8.         else
9.                 dst_hcnt         <=         dst_hcnt;
11. always @(posedge clk)
12.         if(rst)
13.                 dst_vcnt         <=         0;
14.         else if(dst_hcnt == DST_IW - 1 && dst_vcnt == DST_IH - 1)
15.                 dst_vcnt         <=         0;
16.         else if(dst_hcnt == DST_IW - 1)
17.                 dst_vcnt         <=         dst_vcnt + 1;
18.         else
19.                 dst_vcnt         <=         dst_vcnt;

复制代码

  这里对应了MATLAB的两层for循环。
先将行数据存入RAM中

  接下来我们看一个状态机。先只看状态机的启动，当模块的写入缓存足够时，状态机启动，由0状态跳转到2状态。

1. /*
2.         wr_data_cnt                 模块的数据输入端计数       
3. */
4. always@(posedge clk)
5.         if(rst)
6.                 begin
7.                         dst_de                 <= 0;
8.                         state                  <= 0;
9.                 end
10.         else if(pre_ready==1'b1)
11.                 case(state)
12.                         0:       
13.                                 if(wr_data_count<DST_IW*buf_line-13)  //缩放数据存储完毕
14.                                         begin
15.                                                 state          <= 2;                          //开始判断是往RAM里面读数据还是进行缩放像素计算
16.                                         end               
17.                                 else
18.                                         begin
19.                                                 state          <= state;
20.                                         end       

复制代码

  然后再来看这个一个状态跳转影响了什么。可以看出这个信号当状态由不是2状态跳转到2状态的时间，原坐标的盘算使能会拉高一个时钟周期。

1. //expt_src_vcnt_de           原坐标计算使能
2. always @(posedge clk)
3.         if(rst)
4.                 expt_src_vcnt_de         <=         1'b0;
5.         else if(state_r != 2 && state == 2)
6.                 expt_src_vcnt_de         <=         1'b1;
7.         else
8.                 expt_src_vcnt_de         <=         1'b0;

复制代码

  拉高一个时钟周期后，这个信号会进行打拍，后面的这个expt_src_vcntp1_de属于信号流的调度优化，当进入3状态盘算的时间也会盘算并根据条件来判定是否读取下一行。每打一拍代表了一步盘算。

1. always @(posedge clk)
2.         if(rst)begin
3.                 expt_src_vcnt_de0         <=         0;
4.                 expt_src_vcnt_de1         <=         0;
5.                 expt_src_vcnt_de2         <=         0;
6.                 expt_src_vcnt_de3         <=         0;               
7.         end
8.         else begin
9.                 expt_src_vcnt_de0         <=         expt_src_vcnt_de || expt_src_vcntp1_de;
10.                 expt_src_vcnt_de1         <=         expt_src_vcnt_de0;
11.                 expt_src_vcnt_de2         <=         expt_src_vcnt_de1;
12.                 expt_src_vcnt_de3         <=         expt_src_vcnt_de2;               
13.         end

复制代码

  首先看第一步盘算。也就是expt_src_vcnt_de0

1. /*
2.         第一个else if对应MATLAB的src_yf = ((i-1)+0.5) * sy - 0.5;%浮点数
3. 中的(i-1)+0.5,
4.         第二个的这个else if暂且不看
5. */
6. //fix16_2 + fix0_2 = fix16_2
7. always @(posedge clk)
8.         if(rst)
9.                 expt_src_vcnt0         <=         0;
10.         else if(expt_src_vcnt_de == 1'b1)
11.                 expt_src_vcnt0         <=         {dst_vcnt,2'b0} + 2; //0.5*4
12.         else if(expt_src_vcntp1_de == 1'b1 && dst_vcnt < DST_IH - 1)
13.                 expt_src_vcnt0         <=         {dst_vcnt + 1,2'd0} + 2;
14.         else
15.                 expt_src_vcnt0         <=         'd0;

复制代码

  然后看第二步盘算。也就是expt_src_vcnt_de1

1. /*
2.         对应MATLAB的src_yf = ((i-1)+0.5) * sy - 0.5;%浮点数
3. 中的((i-1)+0.5)*sy,
4. */
5. //fix16_2 * fix16_12 = fix32_14
6. always @(posedge clk)
7.         if(rst)
8.                 expt_src_vcnt1         <=         'd0;
9.         else
10.                 expt_src_vcnt1         <=         expt_src_vcnt0 * sy ;

复制代码

  然后看第三步盘算。也就是expt_src_vcnt_de2

1. /*
2.         对应MATLAB的src_yf = ((i-1)+0.5) * sy - 0.5;%浮点数
3. 中的((i-1)+0.5)*sy-0.5,
4.         这里按道理来说应该是fix30_12 - fix12_12 = fix30_12
5.         但是缩放系数一般没有超过2,
6.         所以高位基本都是0
7. */
8. //fix26_12 - fix12_12 = fix26_12
9. always @(posedge clk)
10.         if(rst)
11.                 expt_src_vcnt2         <=         'd0;
12.         else
13.                 expt_src_vcnt2         <=         expt_src_vcnt1[27:2] - 2048 ;

复制代码

  然后看第四步盘算。也就是expt_src_vcnt_de3

1.         /*
2.         这里对应MATLAB的
3.            if(src_yf<0)
4.             src_y0 = 0;
5.         else
6.             src_y0 = floor(src_yf);
7.         end
8.         这个边界条件是2到SRC_IH
9.         这个跟后面的状态机有关
10.         因为这个2指的是缓存读出的数据行数读到0，1行结束
11.         看后面状态机就可以明白
12.         */
13. //fix26_12        -> 取整 + 2 = fix14_0 + 2       
14. always@(posedge clk)
15.         if(rst)       
16.                 expt_src_vcnt3 <= 'd0;
17.         else if(expt_src_vcnt2[25]==1'b1)
18.                 expt_src_vcnt3 <= 'd2;
19.         else if(expt_src_vcnt2[25:12]>SRC_IH-2)
20.                 expt_src_vcnt3 <= SRC_IH;
21.         else
22.                 expt_src_vcnt3 <= expt_src_vcnt2[25:12] + 2;

复制代码

  当expt_src_vcnt_de3拉高的时间，看此时的状态机，现在我们处于状态2阶段。于是只看状态2的跳转。

1. /*
2.         可以看到当expt_src_vcnt_de3拉高的时候，会判断此时的src_vcnt与expt_src_vcnt3的大小
3.         状态1是用来读取一整行原像素的
4.         状态3是用来求目标图像的像素值的
5.         当原图像目前的行数还在目标图像的行数之内的时候就不用读取一整行像素，直接比较
6.         当原图像目前的行数不在目标图像的行数之内的时候就需要读取一整行像素，直到在目标行数之内的时候，再比较
7.         当expt_src_vcnt3为初始值2的时候，src_cnt会连续读取0行和1行的数据
8. */
9.         2:  
10.                 if(src_vcnt>=expt_src_vcnt3&&expt_src_vcnt_de3==1'b1)
11.                         begin
12.                                 state         <= 3;
13.                         end
14.                 else if(src_vcnt<expt_src_vcnt3&&expt_src_vcnt_de3==1'b1)
15.                         begin
16.                                 state         <= 1;
17.                         end
18.                 else
19.                         begin
20.                                 state         <= state;
21.                         end       

复制代码

  这里先看状态1，也就是当原图像目前的行数还在目标图像的行数之内的时间就不用读取一整行像素的过程。

1. //当进入状态1的时候会读取一整行数据
2. always@(posedge clk)
3.         if(rst)
4.                 src_de <= 1'b0;
5.         else if(src_hcnt==SRC_IW-1)
6.                 src_de <= 1'b0;
7.         else if(state_r!=1&&state==1)
8.                 src_de <= 1'b1;
9.           else if(src_vcnt<expt_src_vcnt3&&expt_src_vcnt_de3==1'b1&&state==3)       
10.                 src_de <= 1'b1;
11.         else
12.                 src_de <= src_de;
13. //行计数
14. always@(posedge clk)
15.         if(rst)               
16.                 src_hcnt <= 'd0;
17.         else if(src_hcnt==SRC_IW-1)
18.                 src_hcnt <= 'd0;
19.         else if(src_de==1'b1)
20.                 src_hcnt <= src_hcnt + 1'b1;
21.         else
22.                 src_hcnt <= src_hcnt;
23. //列计数
24. always@(posedge clk)
25.         if(rst)               
26.                 src_vcnt <= 'd0;
27.         else if(src_vcnt==SRC_IH&&dst_hcnt==DST_IW-1&&dst_vcnt==DST_IH-1)       
28.                 src_vcnt <= 'd0;
29.         else if(src_hcnt==SRC_IW-1)
30.                 src_vcnt <= src_vcnt + 1'b1;
31.         else
32.                 src_vcnt <= src_vcnt;
34. assign pre_req = src_de;

复制代码

  以上就是盘算原图像行的过程。这里再返来看前面没有分析的部门。

1. always@(posedge clk)
2.         if(rst)
3.                 expt_src_vcntp1_de <= 1'b0;
4.         else if(state_r!=3&&state==3)
5.                 expt_src_vcntp1_de <= 1'b1;       
6.         else
7.                 expt_src_vcntp1_de <= 1'b0;       
8.                
9.         expt_src_vcnt_de0         <=         expt_src_vcnt_de || expt_src_vcntp1_de;
11.         else if(expt_src_vcnt_de == 1'b1)
12.                 expt_src_vcnt0         <=         {dst_vcnt,2'b0} + 2; //0.5*4
13.         else if(expt_src_vcntp1_de == 1'b1 && dst_vcnt < DST_IH - 1)
14.                 expt_src_vcnt0         <=         {dst_vcnt + 1,2'd0} + 2;

复制代码

  这两个是我们上面没有分析的部门。首先观察状态机可知，这个状态机有四个状态，分别是初始状态、判定状态、读取到指定行状态、以及盘算列状态。判定、读取和盘算是分开的，这样会导致带宽的利用率不高，于是我们在盘算列状态的时间也判定行并读取原像素数据。这样到了状态2就可以立即做出判定并将状态跳转到3。防止状态过多的卡在读原像素的状态1。造成带宽的浪费。
盘算行坐标

  当读出一行信号后，就可以先将列存储在RAM或者FIFO中了，这里我们选择将列存储在RAM中。看下面这段代码。下面这段代码实际上例化了四个RAM，然后将行数据依次循环存入RAM中。使用RAM的好处是可以对一行数据进行任意位置的索引。

1. //RAM选择信号   0~3
2. always@(posedge clk)
3.         if(rst)               
4.                 wr_addr_sel <= 'd0;
5.         else if(wr_addr_cnt==SRC_IW-1&&wr_addr_sel==3)
6.                 wr_addr_sel <= 'd0;
7.         else if(wr_addr_cnt==SRC_IW-1)
8.                 wr_addr_sel <= wr_addr_sel + 1'b1;
9.         else
10.                 wr_addr_sel <= wr_addr_sel;
11. //RAM内的数据写入计数
12. always@(posedge clk)
13.         if(rst)               
14.                 wr_addr_cnt <= 'd0;
15.         else if(wr_addr_cnt==SRC_IW-1)
16.                 wr_addr_cnt <= 'd0;
17.         else if(pre_req==1'b1)
18.                 wr_addr_cnt <= wr_addr_cnt + 1'b1;
19.         else
20.                 wr_addr_cnt <= wr_addr_cnt;
21. //例化四个RAM
22. genvar i;
23. generate
24.   for (i=0; i < 4; i=i+1)
25.   begin: wr_src_data
26.         //依次拉高写数据使能
27.         assign wr_addr_de[i] = (pre_req==1'b1&&wr_addr_sel==i);
28.        
29.         //对应的RAM地址信号加一与清零
30.         always@(posedge clk)
31.                 if(rst)                       
32.                         pre_wr_addr[i] <= 'd0;
33.                 else if(pre_wr_addr[i]==SRC_IW-1)
34.                         pre_wr_addr[i] <= 'd0;
35.                 else if(wr_addr_de[i]==1'b1)
36.                         pre_wr_addr[i] <= pre_wr_addr[i] + 1'b1;
37.                 else
38.                         pre_wr_addr[i] <= pre_wr_addr[i];
39.         //对应赋值
40.         always@(*)
41.                 if(rst)                       
42.                         wr_addr[i] = 'd0;
43.                 else if(wr_addr_de[i]==1'b1)
44.                         wr_addr[i] = pre_wr_addr[i];
45.                 else
46.                         wr_addr[i] = rd_addr_w[i];                       
47.                 //例化RAM
48.                 tdpram #(
49.                         .AW (12),
50.                         .DW (8 )  
51.                 )
52.                 u1_tdpram
53.                 (
54.                   .clka                (clk                        ),
55.                   .wea                (wr_addr_de[i]        ),
56.                   .addra        (wr_addr[i]                ),
57.                   .dina                (pre_data                ),
58.                   .douta        (douta[i]                ),
59.                   .clkb                (clk                        ),
60.                   .web                (1'b0                        ),
61.                   .addrb        (rd_addr[i]                ),
62.                   .dinb                (8'd0                        ),
63.                   .doutb        (doutb[i]                )
64.                 );               
65.   end
66. endgenerate

复制代码

  这里再把前面循环的目标图像代码拿出来。

1. always @(posedge clk)
2.         if(rst)
3.                 dst_hcnt         <=         0;
4.         else if(dst_hcnt == DST_IW - 1)
5.                 dst_hcnt         <=         0;
6.         else if(dst_de == 1'b1)
7.                 dst_hcnt         <=         dst_hcnt + 1;
8.         else
9.                 dst_hcnt         <=         dst_hcnt;
11. always @(posedge clk)
12.         if(rst)
13.                 dst_vcnt         <=         0;
14.         else if(dst_hcnt == DST_IW - 1 && dst_vcnt == DST_IH - 1)
15.                 dst_vcnt         <=         0;
16.         else if(dst_hcnt == DST_IW - 1)
17.                 dst_vcnt         <=         dst_vcnt + 1;
18.         else
19.                 dst_vcnt         <=         dst_vcnt;

复制代码

  行数据有了之后就需要列数据，来看看MATLAB怎么盘算列数据的。

1. src_xf = ((j-1)+0.5) * sx - 0.5;%浮点数

复制代码

  这里对应的FPGA实现有

1. //这里先计算src_xf1 = (j-1)+0.5   扩大两倍然后+2
2. //fix16_2 + fix2_2  = fix16_2
3. always@(posedge clk)
4.         if(rst)       
5.                 src_xf0 <= 'd0;
6.         else if(dst_de==1'b1)
7.                 src_xf0 <= {dst_hcnt,2'd0} + 2;
8.         else
9.                 src_xf0 <= 'd0;
10. //这里计算 src_xf1 = ((j-1)+0.5) * sx
11. //fix16_2 * fix16_12  = fix32_14               
12. always@(posedge clk)
13.         if(rst)       
14.                 src_xf1 <= 'd0;
15.         else
16.                 src_xf1 <= src_xf0*sx;
17. //这里计算 src_xf2 = ((j-1)+0.5) * sx - 0.5
18. //fix26_12 - fix12_12  = fix26_12 可能为负数
19. always@(posedge clk)
20.         if(rst)       
21.                 src_xf2 <= 'd0;
22.         else
23.                 src_xf2 <= src_xf1[27:2] - 2048;
25. //纯打排       
26. always@(posedge clk)
27.         if(rst)       
28.                 src_xf3 <= 'd0;
29.         else
30.                 src_xf3 <= src_xf2;               
31. //x0的坐标
32. always@(posedge clk)
33.         if(rst)       
34.                 src_x0 <= 'd0;
35.         else if(src_xf2[25]==1'b1)
36.                 src_x0 <= 'd0;               
37.         else
38.                 src_x0 <= src_xf2[25:12];
39. //x1的坐标
40. always@(posedge clk)
41.         if(rst)       
42.                 src_x1 <= 'd0;
43.         else if(src_xf2[25]==1'b1)
44.                 src_x1 <= 'd1;
45.         else
46.                 src_x1 <= src_xf2[25:12] + 1'b1;

复制代码

盘算列坐标

  前面已经盘算过列坐标了，前面盘算一次是为了确定读取的是哪一行，这里再盘算一次。
  先看MATLAB盘算。

1. src_yf = ((i-1)+0.5) * sy - 0.5;%浮点数

复制代码

  再看FPGA实现。

1. //这里先计算src_yf0 = (j-1)+0.5   扩大两倍然后+2
2. //fix16_2 + fix2_2  = fix16_2
3. always@(posedge clk)
4.         if(rst)       
5.                 src_yf0 <= 'd0;
6.         else if(dst_de==1'b1)
7.                 src_yf0 <= {dst_vcnt,2'd0} + 2;
8.         else
9.                 src_yf0 <= 'd0;
10. //这里先计算src_yf1 = ((j-1)+0.5)*sy   
11. //fix16_2 * fix16_12  = fix32_14               
12. always@(posedge clk)
13.         if(rst)       
14.                 src_yf1 <= 'd0;
15.         else
16.                 src_yf1 <= src_yf0*sy;
17. //这里先计算src_yf2 = ((j-1)+0.5)*sy - 0.5  
18. //fix26_12 - fix12_12  = fix26_12 可能为负数
19. always@(posedge clk)
20.         if(rst)       
21.                 src_yf2 <= 'd0;
22.         else
23.                 src_yf2 <= src_yf1[27:2] - 2048;
24. //打拍
25. always@(posedge clk)
26.         if(rst)       
27.                 src_yf3 <= 'd0;
28.         else
29.                 src_yf3 <= src_yf2;
30. //计算y0  注意是在src_yf2的基础上，而不是打拍后的基础上
31. always@(posedge clk)
32.         if(rst)       
33.                 src_y0 <= 'd0;
34.         else if(src_yf2[25]==1'b1)
35.                 src_y0 <= 'd0;
36.         else
37.                 src_y0 <= src_yf2[25:12];               
38. //计算y1
39. always@(posedge clk)
40.         if(rst)       
41.                 src_y1 <= 'd0;
42.         else if(src_yf2[25]==1'b1)
43.                 src_y1 <= 'd1;
44.         else
45.                 src_y1 <= src_yf2[25:12] + 1'b1;

复制代码

  接下来看有用信号

1. reg                dst_de0                 ;  //src_yf0   src_xf0
2. reg                dst_de1          ;  //src_yf1   src_xf1
3. reg                dst_de2          ;  //src_yf2   src_xf2
5. reg                src_xy_de   ;  //src_y0   src_x0
7. always@(posedge clk)
8.         if(rst)       
9.                 begin       
10.                         dst_de0 <= 1'b0;
11.                         dst_de1 <= 1'b0;
12.                         dst_de2 <= 1'b0;
13.                 end
14.         else
15.                 begin       
16.                         dst_de0 <= dst_de;        
17.                         dst_de1 <= dst_de0; //src_yf2
18.                         dst_de2 <= dst_de1; //src_yf3
19.                 end               
21. always@(posedge clk)
22.         if(rst)       
23.                 src_xy_de <= 1'b0;
24.         else
25.                 src_xy_de <= dst_de2;  //src_y0和y1

复制代码

  此时我们得到了临近的四个点以及目标图像的坐标。此时看MATLAB代码

1.    %根据四个点坐标以及待求点坐标计算出四个权重
2.         w11 = (src_x1 - src_xf) * (src_y1 - src_yf);   
3.         w21 = (src_xf - src_x0) * (src_y1 - src_yf);
4.         w12 = (src_x1 - src_xf) * (src_yf - src_y0);
5.         w22 = (src_xf - src_x0) * (src_yf - src_y0);
6.         %下面的+1是为了对应索引  与上面的+1求相邻坐标不一样
7.         if(src_y0 >= row - 1 && src_x0 >= col - 1) //最后一个点
8.             line_data(i,j) =    src_data(src_y0 + 1,src_x0 + 1) * w11;
9.         elseif(src_y0 >= row - 1)   //最下面一行
10.             line_data(i,j) =    src_data(src_y0 + 1,src_x0 + 1) * w11 + ...
11.                                 src_data(src_y0 + 1,src_x1 + 1) * w12;
12.         elseif(src_x0 >= col - 1)    //最右边一行
13.             line_data(i,j) =    src_data(src_y0 + 1,src_x0 + 1) * w11 + ...
14.                                 src_data(src_y1 + 1,src_x0 + 1) * w21;
15.         else
16.             line_data(i,j) =    src_data(src_y0 + 1,src_x0 + 1) * w11 + ...
17.                                 src_data(src_y1 + 1,src_x0 + 1) * w21 + ...
18.                                 src_data(src_y0 + 1,src_x1 + 1) * w12 + ...
19.                                 src_data(src_y1 + 1,src_x1 + 1) * w22;
20.         end

复制代码

  首先，if else的条件判定对应四个边界地区。在FPGA中代码如下：

1. reg        [2:0]        region_type                ;
2. reg        [2:0]        region_type_r        ;
3. reg        [2:0]        region_type_r1        ;
4. reg        [2:0]        region_type_r2        ;
5. reg        [2:0]        region_type_r3        ;
6. reg        [2:0]        region_type_r4        ;
7. //src_xy_de==1'b1代表四个点全部被算出
8. always@(posedge clk)
9.         if(rst)       
10.                 region_type <= 0;
11.         else if(src_x0>=SRC_IW-1&&src_y0>=SRC_IH-1&&src_xy_de==1'b1)
12.                 region_type <= 1;
13.         else if(src_y0>=SRC_IH-1&&src_xy_de==1'b1)
14.                 region_type <= 2;
15.         else if(src_x0>=SRC_IW-1&&src_xy_de==1'b1)       
16.                 region_type <= 3;
17.         else
18.                 region_type <= 4;
20. always@(posedge clk)
21.         if(rst)       
22.                 begin
23.                         region_type_r        <=  'd0;
24.                         region_type_r1  <=  'd0;
25.                         region_type_r2  <=  'd0;
26.                         region_type_r3  <=  'd0;
27.                         region_type_r4  <=  'd0;                       
28.                 end
29.         else
30.                 begin
31.                         region_type_r        <=  region_type                ;
32.                         region_type_r1  <=  region_type_r        ;
33.                         region_type_r2  <=  region_type_r1        ;
34.                         region_type_r3  <=  region_type_r2        ;
35.                         region_type_r4  <=  region_type_r3        ;
36.                 end               

复制代码

  剩下的部门就是无脑盘算了。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。