Subversion Repositories dirac

-- ***** BEGIN LICENSE BLOCK *****
-- 
-- $Id: DECODERTESTBENCH.VHD,v 1.1 2006-09-06 18:41:06 petebleackley Exp $ $Name: not supported by cvs2svn $
-- *
-- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
-- *
-- * The contents of this file are subject to the Mozilla Public License
-- * Version 1.1 (the "License"); you may not use this file except in compliance
-- * with the License. You may obtain a copy of the License at
-- * http://www.mozilla.org/MPL/
-- *
-- * Software distributed under the License is distributed on an "AS IS" basis,
-- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
-- * the specific language governing rights and limitations under the License.
-- *
-- * The Original Code is BBC Research and Development code.
-- *
-- * The Initial Developer of the Original Code is the British Broadcasting
-- * Corporation.
-- * Portions created by the Initial Developer are Copyright (C) 2004.
-- * All Rights Reserved.
-- *
-- * Contributor(s): Peter Bleackley (Original author)
-- *
-- * Alternatively, the contents of this file may be used under the terms of
-- * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
-- * Public License Version 2.1 (the "LGPL"), in which case the provisions of
-- * the GPL or the LGPL are applicable instead of those above. If you wish to
-- * allow use of your version of this file only under the terms of the either
-- * the GPL or LGPL and not to allow others to use your version of this file
-- * under the MPL, indicate your decision by deleting the provisions above
-- * and replace them with the notice and other provisions required by the GPL
-- * or LGPL. If you do not delete the provisions above, a recipient may use
-- * your version of this file under the terms of any one of the MPL, the GPL
-- * or the LGPL.
-- * ***** END LICENSE BLOCK ***** */
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
use IEEE.std_logic_textio.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
use STD.textio.all;


entity DECODERTESTBENCH is
end DECODERTESTBENCH;

architecture BEHAVIOUR of DECODERTESTBENCH is

        component ARITHMETICDECODER
        port (ENABLE : in std_logic;
                DATA_IN : in std_logic;
                NEWCONTEXT : in std_logic;
                CONTEXT_SELECT : in std_logic_vector (5 downto 0);
                HALVECOUNTS : in std_logic;
                RESET : in std_logic;
                CLOCK : in std_logic;
                SENDING : out std_logic;
                DATA_OUT : out std_logic);
        end component ARITHMETICDECODER;
        component EXP_GOLOMB_DECODER
        port (  ENABLE : in std_logic;
                DATA_IN : in std_logic;
                RESET : in std_logic;
                CLOCK : in std_logic;
                READY : out std_logic;
                DATA_OUT : out std_logic_vector (31 downto 0));
        end component EXP_GOLOMB_DECODER;
        signal BYTES_INPUT : std_logic_vector (31 downto 0);
        type STATUS is (OFFSET,FIND_START,GET_SIZE,FEED_DATA,PAUSE,FINISHED);
        signal DECODER_STATE : STATUS := OFFSET;
        signal ENABLE_DECODER : std_logic;
        signal DECODER_DATA_IN : std_logic;
        signal NEWCONTEXT : std_logic;
        signal CONTEXT_SELECT : std_logic_vector (5 downto 0);
        signal HALVECOUNTS : std_logic;
        signal FLUSH : std_logic;
        signal RESET : std_logic;
        signal CLOCK : std_logic := '0';
        signal SENDING : std_logic;
        signal DATA_OUT : std_logic;
        signal GETCONTEXT : std_logic;
        signal EG_ENABLE : std_logic;
        signal EG_DATA_IN : std_logic;
        signal EG_READY : std_logic;
        signal INIT : std_logic := '1';
--      signal LAST_BYTE : integer;
--      signal AFTER_FLUSH : std_logic;
--      signal BITPOS2 : integer;
--      signal COMPDATA : integer;
        signal BYTES_TO_DECODE : std_logic_vector (31 downto 0);
        type CHARFILE is file of character;
        file HEADERFILE : CHARFILE open read_mode is "test1.hdr";
        file DIRACFILE : CHARFILE open read_mode is "test1.dr1";
        file CONTEXTFILE : CHARFILE open read_mode is "test1.ctx";
        file TARGETFILE : CHARFILE open read_mode is "test1.dr0";
        type INTARRAY is array (5 downto 0) of integer;
        constant PERIOD : time := 10 ns;
begin

UUT : ARITHMETICDECODER
        port map(ENABLE => ENABLE_DECODER,
                DATA_IN => DECODER_DATA_IN,
                NEWCONTEXT => NEWCONTEXT,
                CONTEXT_SELECT => CONTEXT_SELECT,
                HALVECOUNTS => HALVECOUNTS,
                RESET => RESET,
                CLOCK => CLOCK,
                SENDING => SENDING,
                DATA_OUT => DATA_OUT);
                
EGD : EXP_GOLOMB_DECODER
        port map(ENABLE => EG_ENABLE,
                DATA_IN => EG_DATA_IN,
                RESET => RESET,
                CLOCK => CLOCK,
                READY => EG_READY,
                DATA_OUT => BYTES_TO_DECODE);
                
                
        CLOCK <= not CLOCK after PERIOD/2;
        
--DELAY_FLUSH_SIGNAL : process (CLOCK)
--begin
--      if CLOCK'event and CLOCK = '1' then
--              AFTER_FLUSH <= FLUSH;
--      end if;
--end process DELAY_FLUSH_SIGNAL;
        
TESTBENCH : process (CLOCK)
variable SCAN : INTARRAY;
variable READPLACE : integer := 5;
variable BITPOSITION : integer;
variable DIRACDATA : integer;
variable DIRACREAD : character;
variable TARGETREAD : character;
variable PAUSECOUNT : integer;
begin
        if CLOCK'event and CLOCK='1' then
                if DECODER_STATE = OFFSET then
                        if READPLACE = 0 then
                                DECODER_STATE <= FIND_START;
                                BITPOSITION := 0;
                --      elsif AFTER_FLUSH = '1' and READPLACE = 4 then
                --              SCAN(5) := LAST_BYTE;
                        else
                                if READPLACE < 5 and INIT = '1' then
                                        INIT <= '0';
                                end if;
                                read(TARGETFILE,TARGETREAD);
                                SCAN(READPLACE) := character'pos(TARGETREAD);
                                READPLACE := READPLACE - 1;
                                
                        end if;
                elsif DECODER_STATE = FIND_START then
                        if SCAN (5 downto 1) = ( 16#42#, 16#42#, 16#43#, 16#44#, 16#AC# ) then
                                --BITPOS2 <= BITPOSITION;
                                --COMPDATA <= SCAN(0);
                                DECODER_STATE <= GET_SIZE;
                                if BITPOSITION = 0 then
                                        BITPOSITION := 128;
                                end if;
                        elsif SCAN(5 downto 1) = (16#42#, 16#42#, 16#43#, 16#44#, 16#D0# ) then
                                DECODER_STATE <= FINISHED;
                        elsif BITPOSITION = 0 then
                                read(TARGETFILE,TARGETREAD);
                                read(HEADERFILE,DIRACREAD);
                                SCAN(0) := character'pos(TARGETREAD);
                                DIRACDATA := character'pos(DIRACREAD);
                                BITPOSITION := 128;
                        else
                                for I in 5 downto 1 loop
                                        if SCAN(I) > 127 then
                                                SCAN(I) := SCAN(I) - 128;
                                        end if;
                                        SCAN(I) := SCAN(I)*2;
                                        if SCAN(I-1) > 127 then
                                                SCAN(I) := SCAN(I) + 1;
                                        end if;
                                end loop;
                                if SCAN(0) > 127 then
                                        SCAN(0) := SCAN(0) - 128;
                                end if;
                                SCAN(0) := SCAN(0)*2;
                                BITPOSITION := BITPOSITION/2;
                        end if;
                elsif DECODER_STATE = GET_SIZE then
                        if EG_READY = '1' then
                                DECODER_STATE <= FEED_DATA;
                                BITPOSITION := 128;
                                EG_ENABLE <= '0';
                                BYTES_INPUT <= (others => '0');
                        elsif EG_ENABLE = '1' then
                                EG_ENABLE <= '0';
                        else
                                if BITPOSITION = 128 then
                                        READ(HEADERFILE,DIRACREAD);
                                        DIRACDATA := character'pos(DIRACREAD);
                                end if;
                                if (DIRACDATA rem (BITPOSITION*2))/BITPOSITION = 1 then
                                        EG_DATA_IN <= '1';
                                else
                                        EG_DATA_IN <= '0';
                                end if;
                                EG_ENABLE <= '1';
                                if BITPOSITION = 1 then
                                        BITPOSITION := 128;
                                else
                                        BITPOSITION := BITPOSITION/2;
                                end if;
                        end if;
                elsif DECODER_STATE = FEED_DATA then
                        if FLUSH = '1' then
                                DECODER_STATE <= OFFSET;
                                ENABLE_DECODER <= '0';
                        --      if BITPOSITION = 128 then
                        --              READPLACE := 4;
                        --      else
                                        READPLACE := 5;
                        --      end if;
                        elsif BITPOSITION = 0 then
                                DECODER_STATE <= PAUSE;
                                BYTES_INPUT <= BYTES_INPUT + 1;
                                ENABLE_DECODER <= '0';
                                PAUSECOUNT := 0;
                        else
                                if BITPOSITION = 128 then
                                        if BYTES_INPUT < BYTES_TO_DECODE then
                                                read(DIRACFILE,DIRACREAD);
                                                DIRACDATA := character'pos(DIRACREAD);
                                        else
                                                DIRACDATA := 0;
                                        end if;
                                end if;
                                if (DIRACDATA rem (BITPOSITION*2))/BITPOSITION = 1 then
                                        DECODER_DATA_IN <= '1';
                                else
                                        DECODER_DATA_IN <= '0';
                                end if;
                                ENABLE_DECODER <= '1';
                                BITPOSITION := BITPOSITION/2;
                        end if;
                elsif DECODER_STATE = PAUSE then
                        if FLUSH = '1' then
                                DECODER_STATE <= OFFSET;
                                READPLACE := 5;
                        elsif PAUSECOUNT > 7 then
                                DECODER_STATE <= FEED_DATA;
                                BITPOSITION := 128;
                        elsif SENDING = '1' then
                                PAUSECOUNT := 0;
                        else
                                PAUSECOUNT := PAUSECOUNT+1;
                        end if;
                else --DECODER_STATE = FINISHED;
                        report "Finished" severity failure;
                end if;
        end if;
end process TESTBENCH;

RESET <= INIT or FLUSH;

GETCONTEXT <= (RESET or SENDING) and not NEWCONTEXT;

CONTEXT : process (CLOCK)
variable CONTEXTREAD : character;
variable CONTEXTDATA : integer;
variable READPOSITION : integer;
variable NUMBER_READ : integer :=0;
begin
        if CLOCK'event and CLOCK = '1' then
                if GETCONTEXT = '1' then
                        read(CONTEXTFILE,CONTEXTREAD);
                        NUMBER_READ := NUMBER_READ + 1;
                        CONTEXTDATA := character'pos(CONTEXTREAD);
                        if (CONTEXTDATA rem 2) = 1 then
                                FLUSH <= '1';
                        else
                                FLUSH <= '0';
                                if(CONTEXTDATA rem 4)/2 = 1 then
                                        HALVECOUNTS <= '1';
                                else
                                        HALVECOUNTS <= '0';
                                end if;
                                READPOSITION := 128;
                                for I in 5 downto 0 loop
                                        if (CONTEXTDATA rem (READPOSITION*2))/READPOSITION = 1 then
                                                CONTEXT_SELECT(I) <= '1';
                                        else
                                                CONTEXT_SELECT(I) <= '0';
                                        end if;
                                READPOSITION := READPOSITION/2;
                                end loop;
                                NEWCONTEXT <= '1';
                        end if;
                else
                        NEWCONTEXT <= '0';
                        FLUSH <= '0';
                        HALVECOUNTS <= '0';
                end if;
        end if;
end process CONTEXT;


CHECK_RESULTS : process (CLOCK)
variable DATA : integer;
variable COMPARISON : integer;
variable COMP2 : integer;
--variable BITPOSITION : integer;
variable INDEX : integer;
variable COMPREAD : character;
begin
        if CLOCK'event and CLOCK = '1' then
                if RESET = '1' then
                --      DATA := 0;
                --      BITPOSITION := BITPOS2;
                --      read(TARGETFILE,COMPREAD);
                --      COMPARISON := character'pos(COMPREAD);
                --      COMP2 := 0;
                        INDEX := 128;
                elsif SENDING = '1' then
                        if INDEX = 128 then
                                DATA := 0;
                                read(TARGETFILE,COMPREAD);
                                COMPARISON := character'pos(COMPREAD);
                                COMP2 := 0;
                        end if;
                        if DATA_OUT = '1' then
                                DATA:=DATA+INDEX;
                        end if;
                        if (COMPARISON rem (INDEX*2))/INDEX = 1 then
                                COMP2 := COMP2 + INDEX;
                        end if;
                        assert COMP2 = DATA report "Decoder has Diverged" severity failure;
                        if INDEX = 1 then
                --              read(TARGETFILE,COMPREAD);
                --              COMPARISON := character'pos(COMPREAD);
                --              LAST_BYTE <= COMPARISON;
                --              COMP2 := 0;
                --              DATA := 0;
                        --      BITPOSITION := 128;
                                INDEX := 128;
                        else
                        --      BITPOSITION := BITPOSITION/2;
                                INDEX := INDEX/2;
                        end if;
                end if;
        end if;
end process CHECK_RESULTS;

end architecture BEHAVIOUR;