Subversion Repositories motion_estimation_processor

----------------------------------------------------------------------------

--  This file is a part of the LM VHDL IP LIBRARY

--  Copyright (C) 2009 Jose Nunez-Yanez

--

--  This program is free software; you can redistribute it and/or modify

--  it under the terms of the GNU General Public License as published by

--  the Free Software Foundation; either version 2 of the License, or

--  (at your option) any later version.

--

--  See the file COPYING for the full details of the license.

--

--  The license allows free and unlimited use of the library and tools for research and education purposes. 

--  The full LM core supports many more advanced motion estimation features and it is available under a 

--  low-cost commercial license. See the readme file to learn more or contact us at 

--  eejlny@byacom.co.uk or www.byacom.co.uk

--------------------------------------

--  entity       = sad_selector     --

--  version      = 1.0              --

--  last update  = 30/12/07         --

--  author       = Jose Nunez       --

--------------------------------------

library IEEE;

use IEEE.std_logic_1164.all;

use IEEE.std_logic_unsigned."<";

use IEEE.std_logic_unsigned."+";

use IEEE.Numeric_STD.all;

use work.config.all;

entity sad_selector is

generic (integer_pipeline_count : integer);

port (

      clk : in std_logic;

        reset : in std_logic;

        clear : in std_logic;

      calculate_sad_done : in std_logic;

        active_pipelines : in std_logic_vector(CFG_PIPELINE_COUNT-1 downto 0);

      update : in std_logic; --end of program

        update_fp : in std_logic; -- end of iteraction

        best_eu : out std_logic_vector(3 downto 0);

        best_sad : in std_logic_vector(15 downto 0);

        best_mv : in std_logic_vector(15 downto 0);

      rest_best_sad : in rest_type_displacement;

        rest_best_mv : in rest_type_displacement;

        best_sad_out : out std_logic_vector(15 downto 0);

        best_mv_out : out std_logic_vector(15 downto 0));

end sad_selector;

architecture behavioral of sad_selector is

type eu_id_type is array(CFG_PIPELINE_COUNT-1 downto 0) of std_logic_vector(3 downto 0); -- max number of integer eu is 15

-- zero identifies when there is no winner

type active_pipelines_type is array(5 downto 0) of std_logic_vector(CFG_PIPELINE_COUNT-1 downto 0);

type state_register_type is record

   best_sad_candidate : std_logic_vector(15 downto 0); -- found sad for the best mv

   best_sad : std_logic_vector(15 downto 0); -- stored sad for the best mv

   best_mv  : std_logic_vector(15 downto 0); -- mv associated to best sad

   best_eu : std_logic_vector(3 downto 0);

   eu_id : eu_id_type; -- keep track of the winning eu

   active_pipelines_r : active_pipelines_type; -- reproduce pipeline effects

   calculate_sad_done_int : std_logic; -- pipeline for performance

end record;

signal r, r_in: state_register_type; -- state register

begin

    selection : process(best_sad,best_mv,rest_best_sad,rest_best_mv,update,calculate_sad_done,update_fp)

    variable vbest_sad_fp,vbest_mv_fp : std_logic_vector(15 downto 0);

    variable v : state_register_type; -- state register

    variable veu_id : std_logic_vector(3 downto 0); -- execution unit identifier 

        begin

      vbest_sad_fp := best_sad;

      vbest_mv_fp := best_mv;

        veu_id := r.eu_id(0);

           v := r;

    for i in 1 to (integer_pipeline_count-1) loop

         if (v.active_pipelines_r(5)(i) = '1') then

          if rest_best_sad(i) < vbest_sad_fp then

              vbest_sad_fp := rest_best_sad(i);

              vbest_mv_fp := rest_best_mv(i);

                  veu_id := r.eu_id(i);

          end if;

          end if;

      end loop;

   v.best_sad_candidate := vbest_sad_fp;

   v.active_pipelines_r(5) := v.active_pipelines_r(4);

   v.active_pipelines_r(4) := v.active_pipelines_r(3);

   v.active_pipelines_r(3) := v.active_pipelines_r(2);

   v.active_pipelines_r(2) := v.active_pipelines_r(1);

   v.active_pipelines_r(1) := v.active_pipelines_r(0);

   v.active_pipelines_r(0) := active_pipelines; -- pipeline effect

  if (r.best_sad_candidate < r.best_sad and v.calculate_sad_done_int = '1') then

                        v.best_sad := r.best_sad_candidate;

                        v.best_mv := vbest_mv_fp;

                        v.best_eu := veu_id;

                        best_sad_out <= r.best_sad_candidate;

                        best_mv_out <= vbest_mv_fp;

                        best_eu <= veu_id;

   else

                best_sad_out <= r.best_sad;

                        best_mv_out <= r.best_mv;

                        best_eu <= r.best_eu;

   end if;

   if (update = '1') then

      v.best_sad := x"FFFF"; --new program new max value

    elsif (update_fp = '1') then --iteraction completes

                for i in 0 to (CFG_PIPELINE_COUNT-1) loop

                        v.eu_id(i) := std_logic_vector(to_unsigned((i+1),4));

                end loop;

                v.best_eu := (others => '0');

   elsif (v.calculate_sad_done_int = '1') then

                   for i in 0 to (CFG_PIPELINE_COUNT-1) loop

                        v.eu_id(i) := v.eu_id(i)+CFG_PIPELINE_COUNT;

                        end loop;

    end if;

   v.calculate_sad_done_int := calculate_sad_done;

   r_in <= v;

  end process;

regs : process(clk,clear)

begin

 if (clear = '1') then

        r.best_sad <= x"FFFF"; -- start with the highest value

        r.best_sad_candidate <= (others => '0');

        r.best_mv <= (others => '0');

        r.best_eu <= (others => '0');

        for i in 0 to 5 loop

                r.active_pipelines_r(i) <= (others => '0');

        end loop;

        for i in 0 to (CFG_PIPELINE_COUNT-1) loop

                r.eu_id(i) <= std_logic_vector(to_unsigned((i+1),4));

        end loop;

      r.calculate_sad_done_int <= '0';

 elsif rising_edge(clk) then

                if (reset = '1') then -- general enable

                 r.best_sad <= x"FFFF"; -- start with the highest value

                   r.best_sad_candidate <= (others => '0');

                 r.best_mv <= (others => '0');

                   r.best_eu <= (others => '0');

                   for i in 0 to 5 loop

                        r.active_pipelines_r(i) <= (others => '0');

                   end loop;

                   for i in 0 to (CFG_PIPELINE_COUNT-1) loop

                        r.eu_id(i) <= std_logic_vector(to_unsigned((i+1),4));

                   end loop;

                   r.calculate_sad_done_int <= '0';

                else

                         r <= r_in;

                end if;

 end if;

end process regs;

end  behavioral;