theora-fpga/testbenchs/reconrefframes/reconrefframes.vhd

   1 library std;
   2 library ieee;
   3 library work;
   4
   5 use ieee.std_logic_1164.all;
   6 use ieee.numeric_std.all;
   7 use work.all;
   8
   9
  10 entity ReconRefFrames is
  11   port (Clk,
  12         Reset_n       : in  std_logic;
  13
  14         in_request    : out std_logic;
  15         in_valid      : in  std_logic;
  16         in_data       : in  signed(31 downto 0);
  17
  18         out_requested : in  std_logic;
  19         out_valid     : out std_logic;
  20         out_data      : out signed(31 downto 0)
  21         );
  22 end entity ReconRefFrames;
  23
  24 architecture a_ReconRefFrames of ReconRefFrames is
  25   component ReconFrames
  26     port (
  27       Clk,
  28       Reset_n           : in  std_logic;
  29       Enable            : in  std_logic;
  30
  31       in_request        : out std_logic;
  32       in_valid          : in  std_logic;
  33       in_data           : in  signed(31 downto 0);
  34
  35       in_sem_request    : out std_logic;
  36       in_sem_valid      : in  std_logic;
  37       in_sem_addr       : out unsigned(19 downto 0);
  38       in_sem_data       : in  signed(31 downto 0);
  39
  40       out_sem_requested : in  std_logic;
  41       out_sem_valid     : out std_logic;
  42       out_sem_addr      : out unsigned(19 downto 0);
  43       out_sem_data      : out signed(31 downto 0);
  44
  45       out_done          : out std_logic;
  46       out_eb_done       : out std_logic);
  47   end component;
  48
  49
  50   component LoopFilter
  51     port (Clk,
  52           Reset_n       :       in std_logic;
  53           Enable        :       in std_logic;
  54
  55           in_request    :       out std_logic;
  56           in_valid      :       in std_logic;
  57           in_data       :       in signed(31 downto 0);
  58
  59           in_sem_request    :   out std_logic;
  60           in_sem_valid      :   in  std_logic;
  61           in_sem_addr       :   out unsigned(19 downto 0);
  62           in_sem_data       :   in  signed(31 downto 0);
  63
  64           out_sem_requested :   in  std_logic;
  65           out_sem_valid     :   out std_logic;
  66           out_sem_addr      :   out unsigned(19 downto 0);
  67           out_sem_data      :   out signed(31 downto 0);
  68
  69           out_done          :   out std_logic
  70           );
  71   end component;
  72
  73   component CopyRecon
  74     port (Clk,
  75           Reset_n       :       in std_logic;
  76           Enable        :       in std_logic;
  77
  78           in_request    :       out std_logic;
  79           in_valid      :       in std_logic;
  80           in_data       :       in signed(31 downto 0);
  81
  82           in_sem_request    :   out std_logic;
  83           in_sem_valid      :   in  std_logic;
  84           in_sem_addr       :   out unsigned(19 downto 0);
  85           in_sem_data       :   in  signed(31 downto 0);
  86
  87           out_sem_requested :   in  std_logic;
  88           out_sem_valid     :   out std_logic;
  89           out_sem_addr      :   out unsigned(19 downto 0);
  90           out_sem_data      :   out signed(31 downto 0);
  91
  92           out_done          :   out std_logic
  93           );
  94   end component;
  95
  96
  97   component UpdateUMV
  98     port (Clk,
  99           Reset_n           :   in std_logic;
 100           Enable            :   in std_logic;
 101
 102           in_request        :   out std_logic;
 103           in_valid          :   in std_logic;
 104           in_data           :   in signed(31 downto 0);
 105
 106           in_sem_request    :   out std_logic;
 107           in_sem_valid      :   in  std_logic;
 108           in_sem_addr       :   out unsigned(19 downto 0);
 109           in_sem_data       :   in  signed(31 downto 0);
 110
 111           out_sem_requested :   in  std_logic;
 112           out_sem_valid     :   out std_logic;
 113           out_sem_addr      :   out unsigned(19 downto 0);
 114           out_sem_data      :   out signed(31 downto 0);
 115
 116           out_done          :   out std_logic
 117           );
 118   end component;
 119
 120   component DataBuffer
 121     port (Clk,
 122           Reset_n       :       in std_logic;
 123
 124           in_request    :       out std_logic;
 125           in_valid      :       in std_logic;
 126           in_addr       :       in unsigned(19 downto 0);
 127           in_data       :       in signed(31 downto 0);
 128
 129
 130           out_requested :       in std_logic;
 131           out_valid     :       out std_logic;
 132           out_addr      :       in unsigned(19 downto 0);
 133           out_data      :       out signed(31 downto 0)
 134           );
 135   end component;
 136
 137   constant LG_MAX_SIZE    : natural := 10;
 138   constant MEM_ADDR_WIDTH : natural := 20;
 139 -------------------------------------------------------------------------------
 140 -- Buffer's signals
 141 -------------------------------------------------------------------------------
 142   signal in_DtBuf_request : std_logic;
 143   signal in_DtBuf_valid   : std_logic;
 144   signal in_DtBuf_addr    : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 145   signal in_DtBuf_data    : signed(31 downto 0);
 146
 147   signal out_DtBuf_request : std_logic;
 148   signal out_DtBuf_valid   : std_logic;
 149   signal out_DtBuf_addr    : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 150   signal out_DtBuf_data    : signed(31 downto 0);
 151
 152 -------------------------------------------------------------------------------
 153 -- ReconFrames' signals
 154 -------------------------------------------------------------------------------
 155   signal out_rf_request : std_logic;
 156   signal out_rf_valid : std_logic := '0';
 157   signal out_rf_data : signed(31 downto 0);
 158
 159   signal in_rf_DtBuf_request    : std_logic;
 160   signal in_rf_DtBuf_valid      : std_logic;
 161   signal in_rf_DtBuf_addr       : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 162   signal in_rf_DtBuf_data       : signed(31 downto 0);
 163
 164   signal out_rf_DtBuf_request   : std_logic;
 165   signal out_rf_DtBuf_valid     : std_logic;
 166   signal out_rf_DtBuf_addr      : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 167   signal out_rf_DtBuf_data      : signed(31 downto 0);
 168
 169   signal rf_done                : std_logic;
 170   signal rf_eb_done             : std_logic;
 171   signal rf_enable : std_logic;
 172
 173 -------------------------------------------------------------------------------
 174 -- CopyRecon's signals
 175 -------------------------------------------------------------------------------
 176   signal out_cr_request : std_logic;
 177   signal out_cr_valid : std_logic := '0';
 178   signal out_cr_data : signed(31 downto 0);
 179
 180   signal in_cr_DtBuf_request    : std_logic;
 181   signal in_cr_DtBuf_valid      : std_logic;
 182   signal in_cr_DtBuf_addr       : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 183   signal in_cr_DtBuf_data       : signed(31 downto 0);
 184
 185   signal out_cr_DtBuf_request   : std_logic;
 186   signal out_cr_DtBuf_valid     : std_logic;
 187   signal out_cr_DtBuf_addr      : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 188   signal out_cr_DtBuf_data      : signed(31 downto 0);
 189
 190   signal cr_done                : std_logic;
 191   signal cr_enable : std_logic;
 192
 193 -------------------------------------------------------------------------------
 194 -- LoopFilter's signals
 195 -------------------------------------------------------------------------------
 196   signal out_lf_request : std_logic;
 197   signal out_lf_valid : std_logic := '0';
 198   signal out_lf_data : signed(31 downto 0);
 199
 200   signal in_lf_DtBuf_request    : std_logic;
 201   signal in_lf_DtBuf_valid      : std_logic;
 202   signal in_lf_DtBuf_addr       : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 203   signal in_lf_DtBuf_data       : signed(31 downto 0);
 204
 205   signal out_lf_DtBuf_request   : std_logic;
 206   signal out_lf_DtBuf_valid     : std_logic;
 207   signal out_lf_DtBuf_addr      : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 208   signal out_lf_DtBuf_data      : signed(31 downto 0);
 209
 210   signal lf_done                : std_logic;
 211   signal lf_enable : std_logic;
 212
 213 -------------------------------------------------------------------------------
 214 -- UpdateUMV's signals
 215 -------------------------------------------------------------------------------
 216   signal out_uu_request : std_logic;
 217   signal out_uu_valid : std_logic := '0';
 218   signal out_uu_data : signed(31 downto 0);
 219
 220   signal in_uu_DtBuf_request    : std_logic;
 221   signal in_uu_DtBuf_valid      : std_logic;
 222   signal in_uu_DtBuf_addr       : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 223   signal in_uu_DtBuf_data       : signed(31 downto 0);
 224
 225   signal out_uu_DtBuf_request   : std_logic;
 226   signal out_uu_DtBuf_valid     : std_logic;
 227   signal out_uu_DtBuf_addr      : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 228   signal out_uu_DtBuf_data      : signed(31 downto 0);
 229
 230   signal uu_done                : std_logic;
 231   signal uu_enable : std_logic;
 232
 233 -------------------------------------------------------------------------------
 234   signal in_rr_DtBuf_request    : std_logic;
 235   signal in_rr_DtBuf_valid      : std_logic;
 236   signal in_rr_DtBuf_addr       : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 237
 238   signal out_rr_DtBuf_request   : std_logic;
 239   signal out_rr_DtBuf_valid     : std_logic;
 240   signal out_rr_DtBuf_addr      : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 241   signal out_rr_DtBuf_data      : signed(31 downto 0);
 242
 243
 244   signal FrameSize : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 245   signal GoldenFrameOfs    : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 246   signal ThisFrameReconOfs : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 247   signal LastFrameReconOfs : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 248
 249   signal FrameOfsAux       : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 250   signal FrameOfsAuxSrc    : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 251
 252   signal FrameType         : unsigned(7 downto 0);
 253   signal MaxDPFCount       : unsigned(LG_MAX_SIZE*2 downto 0);
 254
 255   signal s_in_request : std_logic;
 256   signal s_in_valid   : std_logic;
 257
 258   signal CountCopies  : std_logic;
 259   signal CountUpdates : std_logic;
 260   signal count : integer range 0 to 2097151;
 261
 262   signal count_lines   : integer range 0 to 1023;
 263   signal count_columns : integer range 0 to 1023;
 264
 265   constant KEY_FRAME : unsigned(7 downto 0) := "00000000";
 266
 267   type state_t is (stt_CleanBuffer,
 268                    stt_Forward, stt_ReconFrames,
 269                    stt_CopyRecon, stt_LoopFilter,
 270                    stt_UpdateUMV, stt_WriteOut);
 271   signal state : state_t;
 272
 273
 274   type forward_state_t is (stt_rec_framesize,
 275                            stt_rec_height,
 276                            stt_rec_width,
 277                            stt_forward_uniq_common,
 278                            stt_forward_uniq_cr_lf,
 279                            stt_forward_uniq_lf,
 280                            stt_forward_uniq_uu,
 281                            stt_forward_uniqperframe_rf,
 282                            stt_frametype,
 283                            stt_forward_golden_ofs_rf,
 284                            stt_forward_last_ofs_rf,
 285                            stt_forward_this_ofs_rf,
 286                            stt_forward_rf,
 287                            stt_forward_dispfrag,
 288                            stt_forward_source_ofs_cr,
 289                            stt_forward_dest_ofs_cr,
 290                            stt_forward_lf,
 291                            stt_forward_offset_lf,
 292                            stt_forward_offset_uu,
 293                            stt_forward_dispfrag_golden,
 294                            stt_forward_none);
 295   signal forward_state : forward_state_t;
 296
 297   type write_state_t is (stt_write1, stt_write2, stt_write3);
 298   signal write_state : write_state_t;
 299
 300   type plane_write_state_t is (stt_plane_write_Y, stt_plane_write_Cb, stt_plane_write_Cr);
 301   signal plane_write_state : plane_write_state_t;
 302
 303 -- Fragment Parameters
 304   signal YStride          : unsigned(LG_MAX_SIZE+1 downto 0);
 305   signal UVStride         : unsigned(LG_MAX_SIZE   downto 0);
 306   signal ReconYDataOffset : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 307   signal ReconUDataOffset : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 308   signal ReconVDataOffset : unsigned(MEM_ADDR_WIDTH-1 downto 0);
 309   signal video_height     : unsigned(9 downto 0);
 310   signal video_width      : unsigned(9 downto 0);
 311
 312   signal s_out_valid : std_logic;
 313   signal s_out_data : signed(31 downto 0);
 314
 315
 316 begin  -- a_ReconRefFrames
 317
 318   reconframes0: reconframes
 319     port map(clk, Reset_n, rf_enable,
 320              out_rf_request, out_rf_valid, out_rf_data,
 321              out_rf_DtBuf_request, out_rf_DtBuf_valid, out_rf_DtBuf_addr, out_rf_DtBuf_data,
 322              in_rf_DtBuf_request, in_rf_DtBuf_valid, in_rf_DtBuf_addr, in_rf_DtBuf_data,
 323              rf_done, rf_eb_done);
 324
 325   loopfilter0: loopfilter
 326     port map(clk, Reset_n, rf_enable,
 327              out_lf_request, out_lf_valid, out_lf_data,
 328              out_lf_DtBuf_request, out_lf_DtBuf_valid, out_lf_DtBuf_addr, out_lf_DtBuf_data,
 329              in_lf_DtBuf_request, in_lf_DtBuf_valid, in_lf_DtBuf_addr, in_lf_DtBuf_data,
 330              lf_done);
 331
 332   copyrecon0: copyrecon
 333     port map(clk, Reset_n, cr_enable,
 334              out_cr_request, out_cr_valid, out_cr_data,
 335              out_cr_DtBuf_request, out_cr_DtBuf_valid, out_cr_DtBuf_addr, out_cr_DtBuf_data,
 336              in_cr_DtBuf_request, in_cr_DtBuf_valid, in_cr_DtBuf_addr, in_cr_DtBuf_data,
 337              cr_done);
 338
 339   updateumv0: UpdateUMV
 340     port map(clk, Reset_n, uu_enable,
 341              out_uu_request, out_uu_valid, out_uu_data,
 342              out_uu_DtBuf_request, out_uu_DtBuf_valid, out_uu_DtBuf_addr, out_uu_DtBuf_data,
 343              in_uu_DtBuf_request, in_uu_DtBuf_valid, in_uu_DtBuf_addr, in_uu_DtBuf_data,
 344              uu_done);
 345
 346   databuffer0: databuffer
 347     port map(clk, Reset_n,
 348              out_DtBuf_request, out_DtBuf_valid, out_DtBuf_addr, out_DtBuf_data,
 349              in_DtBuf_request, in_DtBuf_valid, in_DtBuf_addr, in_DtBuf_data);
 350
 351
 352   out_valid <= s_out_valid;
 353   -----------------------------------------------------------------------------
 354   -- Switch the in_request
 355   -----------------------------------------------------------------------------
 356   -- If forward_state is a state that doesn't need external data then
 357   -- in_request will be turned off
 358   with forward_state select in_request <=
 359     '0' when stt_forward_golden_ofs_rf,
 360     '0' when stt_forward_last_ofs_rf,
 361     '0' when stt_forward_this_ofs_rf,
 362     '0' when stt_forward_source_ofs_cr,
 363     '0' when stt_forward_dest_ofs_cr,
 364     '0' when stt_forward_offset_lf,
 365     '0' when stt_forward_offset_uu,
 366     '0' when stt_forward_dispfrag_golden,
 367     '0' when stt_forward_none,
 368     s_in_request when others;
 369
 370   -----------------------------------------------------------------------------
 371   -- Switch the signals of the in_data and in_valid of the modules
 372   -----------------------------------------------------------------------------
 373   process (Reset_n,
 374            forward_state,
 375            out_rf_request,
 376            out_cr_request,
 377            out_lf_request,
 378            out_uu_request,
 379            in_valid,
 380            in_data,
 381            GoldenFrameOfs,
 382            LastFrameReconOfs,
 383            ThisFrameReconOfs,
 384            FrameOfsAuxSrc,
 385            FrameOfsAux)
 386
 387   begin
 388
 389     out_rf_valid <= '0';
 390     out_rf_data <= in_data;
 391     out_cr_valid <= '0';
 392     out_cr_data <= in_data;
 393     out_lf_valid <= '0';
 394     out_lf_data <= in_data;
 395     out_uu_valid <= '0';
 396     out_uu_data <= in_data;
 397
 398     s_in_valid <= in_valid;
 399     s_in_request <= '0';
 400
 401     -----------------------------------------------------------------------------
 402     -- Unique Parameters
 403     -----------------------------------------------------------------------------
 404     if (forward_state = stt_rec_framesize) then
 405       s_in_request <= '1';
 406
 407     elsif (forward_state = stt_rec_height) then
 408       s_in_request <= '1';
 409
 410     elsif (forward_state = stt_rec_width) then
 411       s_in_request <= '1';
 412
 413     elsif (forward_state = stt_forward_uniq_common) then
 414       s_in_request <= out_rf_request and
 415                  out_cr_request and
 416                  out_lf_request and
 417                  out_uu_request;
 418       out_rf_valid <= in_valid;
 419       out_cr_valid <= in_valid;
 420       out_lf_valid <= in_valid;
 421       out_uu_valid <= in_valid;
 422
 423     elsif (forward_state = stt_forward_uniq_cr_lf) then
 424       -------------------------------------------------------------------------
 425       -- UnitFragment is sent to CopyRecon and LoopFilter and read internaly
 426       -------------------------------------------------------------------------
 427       s_in_request <= out_cr_request and
 428                  out_lf_request;
 429
 430       out_cr_valid <= in_valid;
 431       out_lf_valid <= in_valid;
 432
 433     elsif (forward_state = stt_forward_uniq_lf) then
 434       s_in_request <= out_lf_request;
 435       out_lf_valid <= in_valid;
 436
 437     elsif (forward_state = stt_forward_uniq_uu) then
 438       s_in_request <= out_uu_request;
 439       out_uu_valid <= in_valid;
 440
 441
 442     -----------------------------------------------------------------------
 443     -- ReconFrames Parameters
 444     ---------------------------------------------------------------------------
 445     elsif (forward_state = stt_forward_uniqperframe_rf) then
 446       s_in_request <= out_rf_request;
 447       out_rf_valid <= in_valid;
 448
 449     elsif (forward_state = stt_frametype) then
 450       -------------------------------------------------------------------------
 451       -- FrameType is sent to ReconFrames and read internaly
 452       -------------------------------------------------------------------------
 453       s_in_request <= out_rf_request;
 454       out_rf_valid <= in_valid;
 455
 456     elsif (forward_state = stt_forward_golden_ofs_rf) then
 457       s_in_request <= out_rf_request;
 458       s_in_valid <= '1';
 459       out_rf_valid <= '1';
 460       out_rf_data <= resize('0' & signed(GoldenFrameOfs), 32);
 461
 462     elsif (forward_state = stt_forward_last_ofs_rf) then
 463       s_in_request <= out_rf_request;
 464       s_in_valid <= '1';
 465       out_rf_valid <= '1';
 466       out_rf_data <= resize('0' & signed(LastFrameReconOfs), 32);
 467
 468     elsif (forward_state = stt_forward_this_ofs_rf) then
 469       s_in_request <= out_rf_request;
 470       s_in_valid <= '1';
 471       out_rf_valid <= '1';
 472       out_rf_data <= resize('0' & signed(ThisFrameReconOfs), 32);
 473
 474     elsif (forward_state = stt_forward_rf) then
 475       s_in_request <= out_rf_request;
 476       out_rf_valid <= in_valid;
 477
 478     elsif (forward_state = stt_forward_dispfrag) then
 479       s_in_request <= out_cr_request and
 480                       out_lf_request;
 481       out_cr_valid <= '0';
 482       out_lf_valid <= '0';
 483       if ((out_cr_request and out_lf_request)= '1') then
 484         out_cr_valid <= in_valid;
 485         out_lf_valid <= in_valid;
 486       else
 487         assert false report "Somebody doesn't want read" severity note;
 488       end if;
 489
 490     elsif (forward_state = stt_forward_source_ofs_cr) then
 491       s_in_request <= out_cr_request;
 492       s_in_valid <= '1';
 493       out_cr_valid <= '1';
 494       out_cr_data <= resize('0' & signed(FrameOfsAuxSrc), 32);
 495
 496     elsif (forward_state = stt_forward_dest_ofs_cr) then
 497       s_in_request <= out_cr_request;
 498       s_in_valid <= '1';
 499       out_cr_valid <= '1';
 500       out_cr_data <= resize('0' & signed(FrameOfsAux), 32);
 501
 502     elsif (forward_state = stt_forward_lf) then
 503       s_in_request <= out_lf_request;
 504       out_lf_valid <= in_valid;
 505
 506     elsif (forward_state = stt_forward_offset_lf) then
 507       s_in_request <= out_lf_request;
 508       s_in_valid <= '1';
 509       out_lf_valid <= '1';
 510       out_lf_data <= resize('0' & signed(LastFrameReconOfs), 32);
 511
 512     elsif (forward_state = stt_forward_offset_uu) then
 513       s_in_request <= out_uu_request;
 514       s_in_valid <= '1';
 515       out_uu_valid <= '1';
 516       out_uu_data <= resize('0' & signed(FrameOfsAux), 32);
 517
 518     elsif (forward_state = stt_forward_dispfrag_golden) then
 519       -------------------------------------------------------------------------
 520       -- If it is a key frame then all fragments must be displayed.
 521       -- In such case all values of display_fragments is one
 522       -------------------------------------------------------------------------
 523       s_in_request <= out_cr_request;
 524       s_in_valid <= '1';
 525       out_cr_valid <= '1';
 526       out_cr_data <= x"FFFFFFFF";
 527     else
 528       null;
 529     end if;
 530     if (Reset_n = '0') then
 531           out_rf_valid <= '0';
 532           out_cr_valid <= '0';
 533           out_lf_valid <= '0';
 534           out_uu_valid <= '0';
 535           s_in_request <= '0';
 536     end if;
 537   end process;
 538
 539   -----------------------------------------------------------------------------
 540   -- Control the module's access to the Data Buffer
 541   -- This is just a big multiplexer
 542   -----------------------------------------------------------------------------
 543   process (Reset_n,
 544            state,
 545            in_DtBuf_valid,
 546            in_DtBuf_data,
 547            out_DtBuf_request,
 548
 549            out_rf_DtBuf_request,
 550            out_rf_DtBuf_addr,
 551            in_rf_DtBuf_valid,
 552            in_rf_DtBuf_addr,
 553            in_rf_DtBuf_data,
 554
 555            out_cr_DtBuf_request,
 556            out_cr_DtBuf_addr,
 557            in_cr_DtBuf_valid,
 558            in_cr_DtBuf_addr,
 559            in_cr_DtBuf_data,
 560
 561            out_lf_DtBuf_request,
 562            out_lf_DtBuf_addr,
 563            in_lf_DtBuf_valid,
 564            in_lf_DtBuf_addr,
 565            in_lf_DtBuf_data,
 566
 567            out_uu_DtBuf_request,
 568            out_uu_DtBuf_addr,
 569            in_uu_DtBuf_valid,
 570            in_uu_DtBuf_addr,
 571            in_uu_DtBuf_data,
 572
 573            out_rr_DtBuf_request,
 574            out_rr_DtBuf_addr,
 575            in_rr_DtBuf_valid,
 576            in_rr_DtBuf_addr
 577            )
 578   begin  -- process state
 579     out_rr_DtBuf_data  <= x"00000000";
 580     out_rr_DtBuf_valid <= '0';
 581
 582     out_cr_DtBuf_data  <= x"00000000";
 583     out_cr_DtBuf_valid <= '0';
 584
 585     out_lf_DtBuf_data  <= x"00000000";
 586     out_lf_DtBuf_valid <= '0';
 587
 588     out_rf_DtBuf_data <= x"00000000";
 589     out_rf_DtBuf_valid <= '0';
 590
 591     out_uu_DtBuf_data <= x"00000000";
 592     out_uu_DtBuf_valid <= '0';
 593
 594     in_uu_DtBuf_request <= '0';
 595     in_cr_DtBuf_request <= '0';
 596     in_lf_DtBuf_request <= '0';
 597     in_rf_DtBuf_request <= '0';
 598     in_rr_DtBuf_request <= '0';
 599
 600     if (state = stt_ReconFrames) then
 601       in_DtBuf_request <= out_rf_DtBuf_request;
 602       out_rf_DtBuf_valid <= in_DtBuf_valid;
 603       in_DtBuf_addr <= out_rf_DtBuf_addr;
 604       out_rf_DtBuf_data  <= in_DtBuf_data;
 605
 606       in_rf_DtBuf_request <= out_DtBuf_request;
 607       out_DtBuf_valid <= in_rf_DtBuf_valid;
 608       out_DtBuf_addr <= in_rf_DtBuf_addr;
 609       out_DtBuf_data <= in_rf_DtBuf_data;
 610
 611     elsif (state = stt_CopyRecon) then
 612       in_DtBuf_request <= out_cr_DtBuf_request;
 613       out_cr_DtBuf_valid <= in_DtBuf_valid;
 614       in_DtBuf_addr <= out_cr_DtBuf_addr;
 615       out_cr_DtBuf_data  <= in_DtBuf_data;
 616
 617       in_cr_DtBuf_request <= out_DtBuf_request;
 618       out_DtBuf_valid <= in_cr_DtBuf_valid;
 619       out_DtBuf_addr <= in_cr_DtBuf_addr;
 620       out_DtBuf_data <= in_cr_DtBuf_data;
 621
 622     elsif (state = stt_LoopFilter) then
 623       in_DtBuf_request <= out_lf_DtBuf_request;
 624       out_lf_DtBuf_valid <= in_DtBuf_valid;
 625       in_DtBuf_addr <= out_lf_DtBuf_addr;
 626       out_lf_DtBuf_data  <= in_DtBuf_data;
 627
 628       in_lf_DtBuf_request <= out_DtBuf_request;
 629       out_DtBuf_valid <= in_lf_DtBuf_valid;
 630       out_DtBuf_addr <= in_lf_DtBuf_addr;
 631       out_DtBuf_data <= in_lf_DtBuf_data;
 632
 633     elsif (state = stt_UpdateUMV) then
 634       in_DtBuf_request <= out_uu_DtBuf_request;
 635       out_uu_DtBuf_valid <= in_DtBuf_valid;
 636       in_DtBuf_addr <= out_uu_DtBuf_addr;
 637       out_uu_DtBuf_data  <= in_DtBuf_data;
 638
 639       in_uu_DtBuf_request <= out_DtBuf_request;
 640       out_DtBuf_valid <= in_uu_DtBuf_valid;
 641       out_DtBuf_addr <= in_uu_DtBuf_addr;
 642       out_DtBuf_data <= in_uu_DtBuf_data;
 643
 644     elsif (state = stt_CleanBuffer) then
 645
 646       in_DtBuf_request <= out_rr_DtBuf_request;
 647       out_rr_DtBuf_valid <= in_DtBuf_valid;
 648       in_DtBuf_addr <= out_rr_DtBuf_addr;
 649       out_rr_DtBuf_data  <= in_DtBuf_data;
 650
 651       in_rr_DtBuf_request <= out_DtBuf_request;
 652       out_DtBuf_valid <= in_rr_DtBuf_valid;
 653       out_DtBuf_addr <= in_rr_DtBuf_addr;
 654       out_DtBuf_data <= x"00000000";
 655
 656     else
 657       in_DtBuf_request <= out_rr_DtBuf_request;
 658       out_rr_DtBuf_valid <= in_DtBuf_valid;
 659       in_DtBuf_addr <= out_rr_DtBuf_addr;
 660       out_rr_DtBuf_data  <= in_DtBuf_data;
 661
 662       out_DtBuf_valid <= '0';
 663       out_DtBuf_addr <= x"00000";
 664       out_DtBuf_data <= x"00000000";
 665
 666     end if;
 667
 668     if (Reset_n = '0') then
 669       out_rr_DtBuf_data  <= x"00000000";
 670       out_rr_DtBuf_valid <= '0';
 671
 672       out_cr_DtBuf_data  <= x"00000000";
 673       out_cr_DtBuf_valid <= '0';
 674
 675       out_lf_DtBuf_data  <= x"00000000";
 676       out_lf_DtBuf_valid <= '0';
 677
 678       out_rf_DtBuf_data <= x"00000000";
 679       out_rf_DtBuf_valid <= '0';
 680
 681       out_uu_DtBuf_data <= x"00000000";
 682       out_uu_DtBuf_valid <= '0';
 683
 684       in_uu_DtBuf_request <= '0';
 685       in_cr_DtBuf_request <= '0';
 686       in_lf_DtBuf_request <= '0';
 687       in_rf_DtBuf_request <= '0';
 688     end if;
 689   end process;
 690
 691
 692   process(clk)
 693
 694     ---------------------------------------------------------------------------
 695     -- Procedure that write zero in all positions of Data Buffer
 696     ---------------------------------------------------------------------------
 697     procedure CleanBuffer is
 698     begin
 699       in_rr_DtBuf_valid <= '1';
 700       if (count = 0) then
 701         in_rr_DtBuf_addr <= x"00000";
 702       else
 703         in_rr_DtBuf_addr <= in_rr_DtBuf_addr + 1;
 704       end if;
 705
 706       if (in_rr_DtBuf_request = '1') then
 707         count <= count + 1;
 708       end if;
 709
 710       if (count = SHIFT_RIGHT(3*FrameSize,2)) then
 711         state <= stt_Forward;
 712         forward_state <= stt_forward_uniq_common;
 713         in_rr_DtBuf_addr <= x"00000";
 714         count <= 0;
 715         in_rr_DtBuf_valid <= '0';
 716       end if;
 717
 718     end CleanBuffer;
 719
 720
 721 -------------------------------------------------------------------------------
 722 -- Change the states syncronously
 723 -------------------------------------------------------------------------------
 724     procedure ForwardControl is
 725     begin
 726       if (s_in_request = '1' and s_in_valid = '1') then
 727 --        assert false report "forward_state = "&forward_state_t'image(forward_state) severity note;
 728         count <= 0;
 729
 730         if (forward_state = stt_rec_framesize) then
 731           -- The first parameter is FrameType
 732           FrameSize <= unsigned(in_data(MEM_ADDR_WIDTH-1 downto 0));
 733
 734           --   This is a hack. On FPGA when reset the module, I don't know explain
 735           -- why, reads the first value as zero.
 736           --   Here we are ignoring this zero value. So the first valid value is
 737           -- the second one that the module reads. The problem happens on an
 738           -- Altera Stratix II.
 739           if (count = 0) then
 740             count <= 1;
 741           else
 742             count <= 0;
 743             forward_state <= stt_rec_height;
 744           end if;
 745
 746
 747         elsif (forward_state = stt_rec_height) then
 748           video_height <= unsigned(in_data(9 downto 0));
 749           forward_state <= stt_rec_width;
 750
 751         elsif (forward_state = stt_rec_width) then
 752           video_width <=  unsigned(in_data(9 downto 0));
 753           count <= 0;
 754           forward_state <= stt_forward_none;
 755           state <= stt_CleanBuffer;
 756
 757
 758         elsif (forward_state = stt_forward_uniq_common) then
 759           -- Define the offsets
 760           GoldenFrameOfs <= x"00000";
 761           LastFrameReconOfs <= FrameSize;
 762           ThisFrameReconOfs <= SHIFT_LEFT(FrameSize, 1);
 763
 764
 765           ---------------------------------------------------------------------
 766           -- Forward and read the unique values common for all modules
 767           ---------------------------------------------------------------------
 768           -- if count = 0 then and forward the pbi->HFragments value
 769           ---------------------------------------------------------------------
 770           -- if count = 1 then read and forward the pbi->YPlaneFragments value
 771           ---------------------------------------------------------------------
 772           -- if count = 2 then read and forward the pbi->YStride value
 773           ---------------------------------------------------------------------
 774           -- if count = 3 then read and forward the pbi->UVPlaneFragments value
 775           ---------------------------------------------------------------------
 776           -- if count = 4 then read and forward the pbi->UVStride value
 777           ---------------------------------------------------------------------
 778           -- if count = 5 then read and forward the pbi->VFragments value
 779           ---------------------------------------------------------------------
 780           -- if count = 6 then read and forward the pbi->ReconYDataOffset value
 781           ---------------------------------------------------------------------
 782           -- if count = 7 then read and forward the pbi->ReconUDataOffset value
 783           ---------------------------------------------------------------------
 784           -- if count = 8 then read and forward the pbi->ReconVDataOffset value
 785           ---------------------------------------------------------------------
 786           count <= count + 1;
 787           if (count = 2) then
 788             YStride <= unsigned(in_data(LG_MAX_SIZE+1 downto 0));
 789
 790           elsif (count = 4) then
 791             UVStride <= unsigned(in_data(LG_MAX_SIZE   downto 0));
 792
 793           elsif (count = 6) then
 794             ReconYDataOffset <= unsigned(in_data(MEM_ADDR_WIDTH-1 downto 0));
 795
 796           elsif (count = 7) then
 797             ReconUDataOffset <= unsigned(in_data(MEM_ADDR_WIDTH-1 downto 0));
 798
 799           elsif (count = 8) then
 800             ReconVDataOffset <= unsigned(in_data(MEM_ADDR_WIDTH-1 downto 0));
 801             forward_state <= stt_forward_uniq_cr_lf;
 802             count <= 0;
 803           end if;
 804
 805         elsif (forward_state = stt_forward_uniq_cr_lf) then
 806           -- Forward the pbi->UnitFragments value to CopyRecon and LoopFilter
 807           forward_state <= stt_forward_uniq_lf;
 808
 809           -- Verify if the pbi-UnitFragments value is some multiple of 32
 810           -- because the matrix pbi->display_fragments is package
 811           MaxDPFCount <= SHIFT_RIGHT(
 812             unsigned(in_data(LG_MAX_SIZE*2 downto 0)), 5) + 1;
 813           if (in_data(4 downto 0) = "00000") then
 814             MaxDPFCount <= SHIFT_RIGHT(
 815               unsigned(in_data(LG_MAX_SIZE*2 downto 0)), 5);
 816           end if;
 817
 818
 819         elsif (forward_state = stt_forward_uniq_lf) then
 820           ---------------------------------------------------------------------
 821           -- Forward the Matrices pbi->QThreshTable and pbi->LoopFilterLimits
 822           -- to LoopFilter module
 823           ---------------------------------------------------------------------
 824           -- For Count = 0 to Count = 63 forward pbi->QThreshTable
 825           ---------------------------------------------------------------------
 826           -- For Count = 64 to Count = 79 forward pbi->LoopFilterLimits
 827           ---------------------------------------------------------------------
 828           count <= count + 1;
 829           if (count = 79) then
 830             forward_state <= stt_forward_uniq_uu;
 831             count <= 0;
 832           end if;
 833
 834         elsif (forward_state = stt_forward_uniq_uu) then
 835           -- Forward the pbi->info.height value to UpdateUMV module
 836           forward_state <= stt_forward_uniqperframe_rf;
 837
 838         elsif (forward_state = stt_forward_uniqperframe_rf) then
 839           ---------------------------------------------------------------------
 840           -- If Count = 0 forward to ReconFrame the QuantDispFrags that is
 841           -- equal to pbi->CodedBlockIndex of the software
 842           ---------------------------------------------------------------------
 843           -- For Count = 1 to Count = 64 forward the
 844           -- pbi->dequant_Y_coeffs matrix to ReconFrames
 845           -----------------------------------------------------------
 846           -- For Count = 65 to Count = 128 forward the
 847           -- pbi->dequant_U_coeffs matrix to ReconFrames
 848           -----------------------------------------------------------
 849           -- For Count = 129 to Count = 192 forward the
 850           -- pbi->dequant_V_coeffs matrix to ReconFrames
 851           -----------------------------------------------------------
 852           -- For Count = 193 to Count = 256 forward the
 853           -- dequant_InterY_coeffs matrix to ReconFrames
 854           -----------------------------------------------------------
 855           -- For Count = 257 to Count = 320 forward the
 856           -- dequant_InterU_coeffs matrix to ReconFrames
 857           -----------------------------------------------------------
 858           -- For Count = 321 to Count = 384 forward the
 859           -- dequant_InterV_coeffs matrix to ReconFrames
 860           count <= count + 1;
 861           if (Count = 0) then
 862             if (in_data(LG_MAX_SIZE*2-1 downto 0) = 0) then
 863               forward_state <= stt_forward_none;
 864               state <= stt_ReconFrames;
 865               count <= 0;
 866               FrameType <= (others => '1');
 867             end if;
 868           elsif (count = 384) then
 869             forward_state <= stt_frametype;
 870             count <= 0;
 871           end if;
 872
 873         elsif (forward_state = stt_frametype) then
 874           -- Forward and read the pbi->FrameType
 875           forward_state <= stt_forward_golden_ofs_rf;
 876           FrameType <= unsigned(in_data(7 downto 0));
 877
 878         -----------------------------------------------------------------------
 879         --   The three states below is used to forward the three Data Buffer's
 880         -- offsets to the modules that need these informations
 881         --   The hardware is responsible for the offsets.
 882         -----------------------------------------------------------------------
 883         elsif (forward_state = stt_forward_golden_ofs_rf) then
 884           forward_state <= stt_forward_last_ofs_rf;
 885
 886         elsif (forward_state = stt_forward_last_ofs_rf) then
 887           forward_state <= stt_forward_this_ofs_rf;
 888
 889         elsif (forward_state = stt_forward_this_ofs_rf) then
 890           forward_state <= stt_forward_rf;
 891
 892         elsif (forward_state = stt_forward_rf) then
 893           -----------------------------------------------------------
 894           -- Forward to ReconFrames the parameters below that are
 895           -- sent for all fragments
 896           -----------------------------------------------------------
 897           -- For Count = 0 to Count = 63 forward the
 898           -- pbi->QFragData(number of the fragment to be expanded)
 899           -- matrix
 900           ------------------------------------------------------------
 901           -- If Count = 64 forward the
 902           -- pbi->FragCodingMethod(number of the fragment to be expanded)
 903           -- value
 904           -----------------------------------------------------------
 905           -- If Count = 65 forward the
 906           -- pbi->FragCoefEOB(number of the fragment to be expanded)
 907           -- value
 908           -----------------------------------------------------------
 909           -- If Count = 66 forward the
 910           -- (pbi->FragMVect(number of the fragment to be expanded)).x
 911           -- value
 912           -----------------------------------------------------------
 913           -- If Count = 67 forward the
 914           -- (pbi->FragMVect(number of the fragment to be expanded)).y
 915           -- value
 916           -----------------------------------------------------------
 917           -- If Count = 68 forward the
 918           -- (number of fragment to be expanded)
 919           -----------------------------------------------------------
 920           count <= count + 1;
 921           if (count = 68) then
 922             forward_state <= stt_forward_none;
 923             state <= stt_ReconFrames;
 924             count <= 0;
 925           end if;
 926
 927         elsif (forward_state = stt_forward_dispfrag or
 928                forward_state = stt_forward_dispfrag_golden) then
 929 --           assert false report "forward_state = "&forward_state_t'image(forward_state) severity note;
 930 --           assert false report "Count = "&integer'image(count) severity note;
 931 --           assert false report "MaxDPFCount = "&integer'image(to_integer(MaxDPFCount)) severity note;
 932
 933           count <= count + 1;
 934           if (count = MaxDPFCount - 1) then
 935             forward_state <= stt_forward_source_ofs_cr;
 936             count <= 0;
 937           end if;
 938
 939         elsif (forward_state = stt_forward_source_ofs_cr) then
 940 --           assert false report "forward_state = "&forward_state_t'image(forward_state) severity note;
 941           forward_state <= stt_forward_dest_ofs_cr;
 942
 943         elsif (forward_state = stt_forward_dest_ofs_cr) then
 944 --           assert false report "forward_state = "&forward_state_t'image(forward_state) severity note;
 945           forward_state <= stt_forward_none;
 946           state <= stt_CopyRecon;
 947
 948         elsif (forward_state = stt_forward_lf) then
 949           forward_state <= stt_forward_offset_lf;
 950
 951         elsif (forward_state = stt_forward_offset_lf) then
 952           forward_state <= stt_forward_none;
 953           state <= stt_LoopFilter;
 954
 955         elsif (forward_state = stt_forward_offset_uu) then
 956           assert false report "Calling UU" severity note;
 957           forward_state <= stt_forward_none;
 958           state <= stt_UpdateUMV;
 959         else
 960           null;
 961         end if;
 962       end if;
 963     end procedure ForwardControl;
 964
 965     procedure ReconFrames is
 966     begin
 967 --      assert false report "out_rf_request = "&std_logic'image(out_rf_request) severity note;
 968       if (rf_done = '1' and rf_eb_done = '1') then
 969         assert false report "ReconFrames Concluido" severity note;
 970         forward_state <= stt_forward_dispfrag;
 971         state <= stt_Forward;
 972         FrameOfsAux <= LastFrameReconOfs;
 973         FrameOfsAuxSrc <= ThisFrameReconOfs;
 974       elsif (rf_eb_done = '1') then
 975         forward_state <= stt_forward_rf;
 976         state <= stt_Forward;
 977         count <= 0;
 978       else
 979         null;
 980       end if;
 981     end procedure ReconFrames;
 982
 983     procedure CopyRecon is
 984     begin
 985       if (cr_done = '1') then
 986         assert false report "CopyRecon Concluido" severity note;
 987
 988         forward_state <= stt_forward_lf;
 989         state <= stt_Forward;
 990         CountCopies <= '0';
 991          if (FrameType = KEY_FRAME and CountCopies = '0') then
 992            CountCopies <= '1';
 993          elsif (FrameType = KEY_FRAME and CountCopies = '1') then
 994            forward_state <= stt_forward_offset_uu;
 995            state <= stt_Forward;
 996          else
 997            null;
 998          end if;
 999       end if;
1000     end procedure CopyRecon;
1001
1002     procedure LoopFilter is
1003     begin
1004       if (lf_done = '1') then
1005         assert false report "LoopFilter Concluido" severity note;
1006         forward_state <= stt_forward_offset_uu;
1007         state <= stt_Forward;
1008       end if;
1009     end procedure LoopFilter;
1010
1011     procedure UpdateUMV is
1012     begin
1013       if (uu_done = '1') then
1014         assert false report "UpdateUMV Concluido" severity note;
1015         count_lines <= 0;
1016         count_columns <= 0;
1017         state <= stt_WriteOut;
1018         plane_write_state <= stt_plane_write_Y;
1019         write_state <= stt_write1;
1020         forward_state <= stt_forward_none;
1021         CountUpdates <= '0';
1022         if (FrameType = KEY_FRAME and CountUpdates = '0') then
1023           FrameOfsAux <= GoldenFrameOfs;
1024           FrameOfsAuxSrc <= LastFrameReconOfs;
1025           forward_state <= stt_forward_dispfrag_golden;
1026           state <= stt_Forward;
1027           CountUpdates <= '1';
1028         end if;
1029       end if;
1030     end procedure UpdateUMV;
1031
1032     procedure WriteOut is
1033     begin
1034       s_out_valid <= '0';
1035       if (write_state = stt_write1) then
1036         write_state <= stt_write2;
1037         out_rr_DtBuf_request <= '1';
1038         out_rr_DtBuf_addr <= out_rr_DtBuf_addr + 1;
1039
1040         count_columns <= count_columns + 4;
1041         case plane_write_state is
1042
1043           when stt_plane_write_Y =>
1044             if (count_columns = 0) then
1045               out_rr_DtBuf_addr <= resize(SHIFT_RIGHT(LastFrameReconOfs + ReconYDataOffset + YStride * (video_height - 1) - YStride*(count_lines), 2), MEM_ADDR_WIDTH);
1046
1047             elsif (count_columns = video_width - 4) then
1048               count_columns <= 0;
1049               count_lines <= count_lines + 1;
1050               if (count_lines = video_height - 1) then
1051                 count_lines <= 0;
1052                 plane_write_state <= stt_plane_write_Cb;
1053               end if;
1054             end if;
1055
1056           when stt_plane_write_Cb =>
1057             if (count_columns = 0) then
1058               out_rr_DtBuf_addr <= resize(SHIFT_RIGHT(LastFrameReconOfs + ReconUDataOffset + UVStride * ((video_height/2) - 1) - UVStride*(count_lines), 2), MEM_ADDR_WIDTH);
1059
1060             elsif (count_columns = (video_width / 2) - 4) then
1061               count_columns <= 0;
1062               count_lines <= count_lines + 1;
1063               if (count_lines = (video_height / 2) - 1) then
1064                 count_lines <= 0;
1065                 plane_write_state <= stt_plane_write_Cr;
1066               end if;
1067             end if;
1068
1069           when stt_plane_write_Cr =>
1070             if (count_columns = 0) then
1071               out_rr_DtBuf_addr <= resize(SHIFT_RIGHT(LastFrameReconOfs + ReconVDataOffset + UVStride * ((video_height/2) - 1) - UVStride*(count_lines), 2), MEM_ADDR_WIDTH);
1072
1073             elsif (count_columns = (video_width / 2) - 4) then
1074               count_columns <= 0;
1075               count_lines <= count_lines + 1;
1076               if (count_lines = (video_height / 2) - 1) then
1077                 ---------------------------------------------------------------
1078                 -- Because count_columns, by construction, is always dividable by
1079                 -- 4, count_columns = 1 is used as a flag that indicate we have
1080                 -- wrote all the visible frame
1081                 ---------------------------------------------------------------
1082                 count_columns <= 1;
1083                 count_lines <= 0;
1084               end if;
1085
1086             -------------------------------------------------------------------
1087             -- If we have already wrote all the visible frame we are done
1088             -------------------------------------------------------------------
1089             elsif (count_columns = 1) then
1090 --               count_leo <= count_leo + 1;
1091 --               assert count_leo /= 2 report "Dois frames" severity FAILURE;
1092               assert false report "Teste4" severity note;
1093               count_columns <= 0;
1094               forward_state <= stt_forward_uniqperframe_rf;
1095               plane_write_state <= stt_plane_write_Y;
1096               state <= stt_Forward;
1097               write_state <= stt_write1;
1098               out_rr_DtBuf_request <= '0';
1099             end if;
1100         end case;
1101
1102       elsif (write_state = stt_write2) then
1103         if (out_rr_DtBuf_valid = '1') then
1104           s_out_data <= out_rr_DtBuf_data;
1105           out_rr_DtBuf_request <= '0';
1106           write_state <= stt_write3;
1107         end if;
1108
1109       else
1110         s_out_valid <= '1';
1111         out_data <= s_out_data;
1112         if (out_requested = '1') then
1113           write_state <= stt_write1;
1114           out_rr_DtBuf_request <= '0';
1115         end if;
1116       end if;
1117     end procedure WriteOut;
1118
1119   begin
1120     if (clk'event and clk = '1') then
1121       if (Reset_n = '0') then
1122         rf_enable <= '1';
1123         cr_enable <= '1';
1124         lf_enable <= '1';
1125         uu_enable <= '1';
1126
1127         plane_write_state <= stt_plane_write_Y;
1128         write_state <= stt_write1;
1129         forward_state <= stt_rec_framesize;
1130         state <= stt_Forward;
1131
1132
1133         CountCopies  <= '0';
1134         CountUpdates <= '0';
1135         count <= 0;
1136         out_data <= x"00000000";
1137         s_out_data <= x"00000000";
1138         s_out_valid <= '0';
1139
1140         out_rr_DtBuf_request <= '0';
1141       else
1142         case state is
1143           when stt_CleanBuffer => CleanBuffer;
1144           when stt_Forward => ForwardControl;
1145           when stt_ReconFrames => ReconFrames;
1146           when stt_CopyRecon => CopyRecon;
1147           when stt_LoopFilter => LoopFilter;
1148           when stt_UpdateUMV => UpdateUMV;
1149           when others => WriteOut;
1150         end case;
1151       end if;
1152     end if;
1153   end process;
1154
1155
1156 end a_ReconRefFrames;