theora-fpga/theora_hardware/reconpixelindex.vhd

   1 library std;
   2 library ieee;
   3 use ieee.std_logic_1164.all;
   4 use ieee.numeric_std.all;
   5
   6 entity ReconPixelIndex is
   7   port (Clk,
   8         Reset_n       : in  std_logic;
   9
  10         in_request    : out std_logic;
  11         in_valid      : in  std_logic;
  12         in_data       : in  signed(31 downto 0);
  13
  14         out_requested : in  std_logic;
  15         out_valid     : out std_logic;
  16         out_data      : out signed(31 downto 0)
  17         );
  18 end entity ReconPixelIndex;
  19
  20 architecture a_ReconPixelIndex of ReconPixelIndex is
  21   component Divider
  22     generic (
  23       WIDTH : positive := 32);
  24     port (Clk,
  25           Reset_n       : in  std_logic;
  26
  27           in_request    : out std_logic;
  28           in_valid      : in  std_logic;
  29           dividend      : in  unsigned(WIDTH-1 downto 0);
  30           divisor       : in  unsigned(WIDTH-1 downto 0);
  31
  32           out_requested : in  std_logic;
  33           out_valid     : out std_logic;
  34           quotient      : out unsigned(WIDTH-1 downto 0);
  35           remainder     : out unsigned(WIDTH-1 downto 0));
  36   end component;
  37
  38
  39
  40   constant VFRAGPIXELS             : unsigned(3 downto 0) := x"8";
  41   constant HFRAGPIXELS             : unsigned(3 downto 0) := x"8";
  42
  43   constant RPI_POS_WIDTH           : positive := 17;
  44   constant HV_FRAG_WIDTH           : positive := 8;
  45   constant Y_STRIDE_WIDTH          : positive := 12;
  46   constant UV_STRIDE_WIDTH         : positive := 11;
  47   constant Y_PL_FRAG_WIDTH         : positive := 21;
  48   constant UV_PL_FRAG_WIDTH        : positive := 19;
  49   constant RECON_Y_DATA_OFS_WIDTH  : positive := 20;
  50   constant RECON_UV_DATA_OFS_WIDTH : positive := 20;
  51
  52   -- States machines
  53   type state_t is (stt_readIn, stt_Proc, stt_WriteOut);
  54   signal state : state_t;
  55
  56   type read_state_t is (stt_read_HFragments,
  57                         stt_read_YPlaneFragments,
  58                         stt_read_YStride,
  59                         stt_read_UVPlaneFragments,
  60                         stt_read_UVStride,
  61                         stt_read_VFragments,
  62                         stt_read_ReconYDataOffset,
  63                         stt_read_ReconUDataOffset,
  64                         stt_read_ReconVDataOffset,
  65                         stt_read_Position);
  66   signal read_state : read_state_t;
  67
  68   type proc_state_t is (stt_proc_1, stt_proc_2);
  69   signal proc_state : proc_state_t;
  70
  71   -- Signals that will be received
  72   signal rpi_position     : unsigned(RPI_POS_WIDTH-1 downto 0);
  73   signal HFragments       : unsigned(HV_FRAG_WIDTH-1 downto 0);
  74 --   signal VFragments       : unsigned(HV_FRAG_WIDTH-1 downto 0);
  75   signal YStride          : unsigned(Y_STRIDE_WIDTH-1 downto 0);
  76   signal UVStride         : unsigned(UV_STRIDE_WIDTH-1 downto 0);
  77   signal YPlaneFragments  : unsigned(Y_PL_FRAG_WIDTH-1 downto 0);
  78   signal UVPlaneFragments : unsigned(UV_PL_FRAG_WIDTH-1 downto 0);
  79   signal ReconYDataOffset : unsigned(RECON_Y_DATA_OFS_WIDTH-1 downto 0);
  80   signal ReconUDataOffset : unsigned(RECON_UV_DATA_OFS_WIDTH-1 downto 0);
  81   signal ReconVDataOffset : unsigned(RECON_UV_DATA_OFS_WIDTH-1 downto 0);
  82
  83   -- Calculated value
  84   signal rpi_value        : signed(31 downto 0);
  85
  86   -- Handshake signals
  87   signal s_in_request : std_logic;
  88   signal s_out_valid  : std_logic;
  89
  90   -- Divider signals
  91   signal s_divider_in_request    : std_logic;
  92   signal s_divider_in_valid      : std_logic;
  93   signal s_divider_dividend      : unsigned(RPI_POS_WIDTH-1 downto 0);
  94   signal s_divider_divisor       : unsigned(RPI_POS_WIDTH-1 downto 0);
  95   signal s_divider_out_requested : std_logic;
  96   signal s_divider_out_valid     : std_logic;
  97   signal s_divider_quotient      : unsigned(RPI_POS_WIDTH-1 downto 0);
  98   signal s_divider_remainder     : unsigned(RPI_POS_WIDTH-1 downto 0);
  99
 100
 101 begin  -- a_ReconPixelIndex
 102
 103   divider0: divider
 104     generic map (WIDTH  => RPI_POS_WIDTH)
 105     port map(Clk            => Clk,
 106              Reset_n        => Reset_n,
 107              in_request     => s_divider_out_requested,
 108              in_valid       => s_divider_out_valid,
 109              dividend       => s_divider_dividend,
 110              divisor        => s_divider_divisor,
 111              out_requested  => s_divider_in_request,
 112              out_valid      => s_divider_in_valid,
 113              quotient       => s_divider_quotient,
 114              remainder      => s_divider_remainder);
 115
 116   in_request <= s_in_request;
 117   out_valid <= s_out_valid;
 118   process(clk)
 119
 120     procedure ReadIn is
 121     begin
 122       s_in_request <= '1';
 123       s_out_valid <= '0';
 124
 125       if (s_in_request = '1' and in_valid = '1') then
 126
 127         case read_state is
 128           when stt_read_HFragments =>
 129             read_state <= stt_read_YPlaneFragments;
 130             HFragments <= unsigned(in_data(HV_FRAG_WIDTH-1 downto 0));
 131
 132           when stt_read_YPlaneFragments =>
 133             read_state <= stt_read_YStride;
 134             YPlaneFragments <= unsigned(in_data(Y_PL_FRAG_WIDTH-1 downto 0));
 135
 136           when stt_read_YStride =>
 137             read_state <= stt_read_UVPlaneFragments;
 138             YStride <= unsigned(in_data(Y_STRIDE_WIDTH-1 downto 0));
 139
 140           when stt_read_UVPlaneFragments =>
 141             read_state <= stt_read_UVStride;
 142             UVPlaneFragments <= unsigned(in_data(UV_PL_FRAG_WIDTH-1 downto 0));
 143
 144           when stt_read_UVStride =>
 145             read_state <= stt_read_VFragments;
 146             UVStride <= unsigned(in_data(UV_STRIDE_WIDTH-1 downto 0));
 147
 148           when stt_read_VFragments =>
 149             read_state <= stt_read_ReconYDataOffset;
 150 --             VFragments <= unsigned(in_data(HV_FRAG_WIDTH-1 downto 0));
 151
 152           when stt_read_ReconYDataOffset =>
 153             read_state <= stt_read_ReconUDataOffset;
 154             ReconYDataOffset <= unsigned(in_data(RECON_Y_DATA_OFS_WIDTH-1 downto 0));
 155
 156           when stt_read_ReconUDataOffset =>
 157             read_state <= stt_read_ReconVDataOffset;
 158             ReconUDataOffset <= unsigned(in_data(RECON_UV_DATA_OFS_WIDTH-1 downto 0));
 159
 160           when stt_read_ReconVDataOffset =>
 161             read_state <= stt_read_Position;
 162             ReconVDataOffset <= unsigned(in_data(RECON_UV_DATA_OFS_WIDTH-1 downto 0));
 163
 164           when others =>                -- stt_read_Position
 165             read_state <= stt_read_Position;
 166             state <= stt_Proc;
 167             proc_state <= stt_proc_1;
 168             rpi_position <= unsigned(in_data(RPI_POS_WIDTH-1 downto 0));
 169             s_in_request <= '0';
 170         end case;
 171       end if;
 172     end procedure ReadIn;
 173
 174     procedure Proc is
 175     begin
 176       s_divider_out_valid <= '0';
 177       s_divider_in_request <= '0';
 178       case proc_state is
 179         when stt_proc_1 =>
 180           if (s_divider_out_requested = '1') then
 181             s_divider_out_valid <= '1';
 182             s_divider_in_request <= '1';
 183             proc_state <= stt_proc_2;
 184             if (rpi_position < YPlaneFragments) then
 185               s_divider_dividend <= rpi_position;
 186               s_divider_divisor <= resize(HFragments, RPI_POS_WIDTH);
 187               rpi_value <= resize(signed('0' & ReconYDataOffset), 32);
 188
 189             elsif (rpi_position < YPlaneFragments + UVPlaneFragments) then
 190               s_divider_dividend <= resize(rpi_position - YPlaneFragments, RPI_POS_WIDTH);
 191               s_divider_divisor <= resize(SHIFT_RIGHT(HFragments, 1), RPI_POS_WIDTH);
 192               rpi_value <= resize(signed('0' & ReconUDataOffset) , 32);
 193             else
 194               s_divider_dividend <= resize(rpi_position - (YPlaneFragments + UVPlaneFragments), RPI_POS_WIDTH);
 195               s_divider_divisor <= resize(SHIFT_RIGHT(HFragments, 1), RPI_POS_WIDTH);
 196               rpi_value <= resize(signed('0' & ReconVDataOffset), 32);
 197             end if;
 198           end if;
 199
 200
 201
 202         when others =>
 203           s_divider_in_request <= '1';
 204           if (s_divider_in_request = '1' and s_divider_in_valid = '1') then
 205             s_divider_in_request <= '0';
 206             proc_state <= stt_proc_1;
 207             state <= stt_WriteOut;
 208
 209             if (rpi_position < YPlaneFragments) then
 210               rpi_value <= rpi_value +
 211                            resize(signed('0' &
 212                                   (s_divider_quotient * VFRAGPIXELS * YStride +
 213                                    s_divider_remainder * HFRAGPIXELS)), 32);
 214             else
 215               rpi_value <= rpi_value +
 216                            resize(signed('0' &
 217                                   (s_divider_quotient * VFRAGPIXELS * UVStride +
 218                                    s_divider_remainder * HFRAGPIXELS)), 32);
 219
 220             end if;
 221
 222           end if;
 223       end case;
 224     end procedure Proc;
 225
 226     procedure WriteOut is
 227     begin
 228       s_out_valid <= '1';
 229       out_data <= rpi_value;
 230       if (out_requested = '1') then
 231         state <= stt_readIn;
 232       end if;
 233     end procedure WriteOut;
 234
 235
 236
 237   begin
 238     if (clk'event and clk = '1') then
 239       if (Reset_n = '0') then
 240         state <= stt_readIn;
 241         read_state <= stt_read_HFragments;
 242         proc_state <= stt_proc_1;
 243         s_in_request <= '0';
 244         s_out_valid <= '0';
 245       else
 246         case state is
 247           when stt_readIn => ReadIn;
 248           when stt_Proc => Proc;
 249           when others => WriteOut;
 250         end case;
 251       end if;
 252     end if;
 253
 254   end process;
 255
 256 end a_ReconPixelIndex;