Subversion Repositories xmatchpro

--This library is free software; you can redistribute it and/or
--modify it under the terms of the GNU Lesser General Public
--License as published by the Free Software Foundation; either
--version 2.1 of the License, or (at your option) any later version.
 
--This library is distributed in the hope that it will be useful,
--but WITHOUT ANY WARRANTY; without even the implied warranty of
--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--Lesser General Public License for more details.
 
--You should have received a copy of the GNU Lesser General Public
--License along with this library; if not, write to the Free Software
--Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-- e_mail : j.l.nunez-yanez@byacom.co.uk
 
-----------------------------------
--  ENTITY       = OB_ASSEMBLER  --
--  version      = 2.0           --
--  last update  = 6/06/01      --
--  author       = Jose Nunez    --
-----------------------------------
 
 
-- FUNCTION
-- final assembly stage for output compressed data.
 
 
-- PIN LIST
-- CLK          = master clock
-- CLEAR        = asynchronous clear signal (active LOW)
-- CODE_OLD     = current contents of the output code register
-- LENGTH_OLD   = current length of the output code register
-- CODE_IN      = new input code to be added to the current code
-- LENGTH_IN    = length of the input code
-- COMP         = indicates that we are in compression mode (active low)
-- FLUSH_IN     = indicates that we are at the end of compression and thus must flush any
--                remaining data from the output code register (new input data is no
--                longer valid)
-- CODE_NEW     = new data for the output code register
-- LENGTH_NEW   = new output code register length
-- OVERFLOW_LENGTH = new overflow status (active low). Will go active if more than 64 bits
--                of the new code are valid
-- OVERFLOW_FLUSH  = indicates a flushing overflow (data must go out when flushing )
-- FLUSH_END    = indicates end of flushing operation (active low)
 
 
library ieee,dzx;
use ieee.std_logic_1164.all;
use dzx.bit_arith.all;
use dzx.bit_utils.all; 
 
 
entity OB_ASSEMBLER is
port
(
	CLK : in bit;
	CLEAR : in bit;
	RESET : in bit;
   	CODE_OLD : in bit_vector(97 downto 0);
	LENGTH_OLD : in bit_vector(5 downto 0);
	CODE_IN : in bit_vector(34 downto 0);
	LENGTH_IN : in bit_vector(5 downto 0);
	COMP : in bit;
	FLUSH_IN : in bit;
	OVERFLOW_OLD : in bit;
	CODE_NEW : out bit_vector(97 downto 0);
	LENGTH_NEW : out bit_vector(5 downto 0);
	OVERFLOW_LENGTH : out bit;
	OVERFLOW_FLUSH : out bit;
	SHORT : out bit;
	FLUSH_END : out bit
);
 
 
 
end OB_ASSEMBLER;
 
 
architecture ASSEMBLE2 of OB_ASSEMBLER is
 
signal FLUSHING_D : bit;
signal FLUSHING_Q : bit;
signal EFC_D : bit;
signal EFC_Q : bit;
signal LENGTH_ZERO : bit;
signal INT_CODE_IN : bit_vector(34 downto 0);
signal INT_LENGTH_IN : bit_vector(5 downto 0);
signal CYCLE1_END : bit;
signal CYCLE1_FORCE : bit;
signal OVERFLOW_FLUSH_AUX : bit;
signal LONG_WORD_D : bit;
signal LONG_WORD_Q : bit;
 
begin
 
LENGTH_ZERO <= Nor_Bits(LENGTH_OLD);
EFC_D <= FLUSH_IN or LENGTH_ZERO or OVERFLOW_OLD;
FLUSHING_D <= FLUSH_IN and FLUSHING_Q;
CYCLE1_END <= FLUSH_IN or not(OVERFLOW_OLD or LENGTH_ZERO);
CYCLE1_FORCE <= FLUSH_IN or LENGTH_ZERO or not(OVERFLOW_OLD);
 
 
 
FLUSH_END <= CYCLE1_END and EFC_Q;
OVERFLOW_FLUSH_AUX <= CYCLE1_FORCE and EFC_Q;
OVERFLOW_FLUSH <= OVERFLOW_FLUSH_AUX;
SHORT <= OVERFLOW_FLUSH_AUX or LONG_WORD_Q; 
 
VALIDATE_INPUTS : process( COMP, CODE_IN , LENGTH_IN , FLUSHING_D )
begin
if (FLUSHING_D = '1' and COMP='0') then
	INT_CODE_IN <= CODE_IN;
	INT_LENGTH_IN <= LENGTH_IN;
else
	INT_CODE_IN <= "00000000000000000000000000000000000";
	INT_LENGTH_IN <= "000000";
end if;
end process VALIDATE_INPUTS;
 
 
CONTROL_FLIPS : process(CLEAR,CLK)
begin
if (CLEAR='0') then
 		FLUSHING_Q <= '1';
		EFC_Q <= '1';
		LONG_WORD_Q <= '1';
elsif ((CLK'event) and (CLK = '1')) then
	if ((RESET = '0') or (COMP = '1')) then
		FLUSHING_Q <= '1';
		EFC_Q <= '1';
                LONG_WORD_Q <= '1';
	else
		FLUSHING_Q <= FLUSHING_D;
		EFC_Q <= EFC_D;
		LONG_WORD_Q <= LONG_WORD_D;
	end if;
end if;
end process CONTROL_FLIPS;
 
 
LENGTH_CALC : process( LENGTH_OLD , INT_LENGTH_IN , FLUSHING_D , COMP)
variable TEMP_LENGTH : bit_vector(6 downto 0);
variable TEMP_LENGTH_AUX : bit_vector(6 downto 0);
 
begin
 
TEMP_LENGTH_AUX := ('0' & LENGTH_OLD) + ('0' & INT_LENGTH_IN);
 
LONG_WORD_D <= TEMP_LENGTH_AUX(6) or (TEMP_LENGTH_AUX(5) and or_bits(TEMP_LENGTH_AUX(4 downto 0)));
 
if ((COMP = '1') or (FLUSHING_D = '0')) then
    TEMP_LENGTH := "0000000";
else
    TEMP_LENGTH := TEMP_LENGTH_AUX;
end if;
 
 
LENGTH_NEW <= TEMP_LENGTH(5 downto 0);
OVERFLOW_LENGTH <= not(TEMP_LENGTH(6));
end process LENGTH_CALC;
 
 
 
CODE_SHIFT : process (CODE_OLD , LENGTH_OLD , INT_CODE_IN , OVERFLOW_OLD)
begin
--if (COMP = '0') then
case LENGTH_OLD is
    when "000000" => CODE_NEW <= INT_CODE_IN & x"000000000000000" & "000";
 
    when "000001" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97) <= CODE_OLD(33);
		     else
		        	    CODE_NEW(97) <= CODE_OLD(97);
		     end if;
		     CODE_NEW(96 downto 62) <= INT_CODE_IN;
		     CODE_NEW(61 downto 0) <= x"000000000000000" & "00";
 
    when "000010" => if (OVERFLOW_OLD = '0') then
    	    	CODE_NEW(97 downto 96) <= CODE_OLD(33 downto 32);
		     else
		     	CODE_NEW(97 downto 96) <= CODE_OLD(97 downto 96);
		     end if;
		     CODE_NEW(95 downto 61) <= INT_CODE_IN;
		     CODE_NEW(60 downto 0) <= x"000000000000000" & "0";
 
    when "000011" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 95) <= CODE_OLD(33 downto 31);
		     else
		     	CODE_NEW(97 downto 95) <= CODE_OLD(97 downto 95);
		     end if;
		     CODE_NEW(94 downto 60) <= INT_CODE_IN;
		     CODE_NEW(59 downto 0) <= x"000000000000000";
 
    when "000100" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 94) <= CODE_OLD(33 downto 30);
		     else
		     	CODE_NEW(97 downto 94) <= CODE_OLD(97 downto 94);
		     end if;
		     CODE_NEW(93 downto 59) <= INT_CODE_IN;
		     CODE_NEW(58 downto 0) <= x"00000000000000" & "000";
 
    when "000101" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 93) <= CODE_OLD(33 downto 29);
		     else
		     	CODE_NEW(97 downto 93) <= CODE_OLD(97 downto 93);
		     end if;
		     CODE_NEW(92 downto 58) <= INT_CODE_IN;
		     CODE_NEW(57 downto 0) <= x"00000000000000" & "00";
 
    when "000110" => if (OVERFLOW_OLD = '0') then
    	    	 CODE_NEW(97 downto 92) <= CODE_OLD(33 downto 28);
		     else
		     	 CODE_NEW(97 downto 92) <= CODE_OLD(97 downto 92);
		     end if;
		     CODE_NEW(91 downto 57) <= INT_CODE_IN;
		     CODE_NEW(56 downto 0) <= x"00000000000000" & "0";
 
    when "000111" => if (OVERFLOW_OLD = '0') then
    	    	CODE_NEW(97 downto 91) <= CODE_OLD(33 downto 27);
		     else
		     	CODE_NEW(97 downto 91) <= CODE_OLD(97 downto 91);
		     end if;
		     CODE_NEW(90 downto 56) <= INT_CODE_IN;
		     CODE_NEW(55 downto 0) <= x"00000000000000";
 
    when "001000" => if (OVERFLOW_OLD = '0') then
    	    	CODE_NEW(97 downto 90) <= CODE_OLD(33 downto 26);
		     else
		     	CODE_NEW(97 downto 90) <= CODE_OLD(97 downto 90);
		     end if;
		     CODE_NEW(89 downto 55) <= INT_CODE_IN;
		     CODE_NEW(54 downto 0) <= x"0000000000000" & "000";
 
    when "001001" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 89) <= CODE_OLD(33 downto 25);
		     else
		     	CODE_NEW(97 downto 89) <= CODE_OLD(97 downto 89);
		     end if;
		     CODE_NEW(88 downto 54) <= INT_CODE_IN;
		     CODE_NEW(53 downto 0) <= x"0000000000000" & "00";
 
    when "001010" => if (OVERFLOW_OLD = '0') then
    	    	CODE_NEW(97 downto 88) <= CODE_OLD(33 downto 24);
		     else
		     	CODE_NEW(97 downto 88) <= CODE_OLD(97 downto 88);
		     end if;
		     CODE_NEW(87 downto 53) <= INT_CODE_IN;
		     CODE_NEW(52 downto 0) <= x"0000000000000" & "0";
 
    when "001011" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 87) <= CODE_OLD(33 downto 23);
		     else
		     	CODE_NEW(97 downto 87) <= CODE_OLD(97 downto 87);
		     end if;
		     CODE_NEW(86 downto 52) <= INT_CODE_IN;
		     CODE_NEW(51 downto 0) <= x"0000000000000";
 
    when "001100" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 86) <= CODE_OLD(33 downto 22);
		     else
		     	CODE_NEW(97 downto 86) <= CODE_OLD(97 downto 86);
		     end if;
		     CODE_NEW(85 downto 51) <= INT_CODE_IN;
		     CODE_NEW(50 downto 0) <= x"000000000000" & "000";
 
    when "001101" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 85) <= CODE_OLD(33 downto 21);
		     else
		     	CODE_NEW(97 downto 85) <= CODE_OLD(97 downto 85);
		     end if;
		     CODE_NEW(84 downto 50) <= INT_CODE_IN;
		     CODE_NEW(49 downto 0) <= x"000000000000" & "00";
 
    when "001110" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 84) <= CODE_OLD(33 downto 20);
		     else
		     	CODE_NEW(97 downto 84) <= CODE_OLD(97 downto 84);
		     end if;
		     CODE_NEW(83 downto 49) <= INT_CODE_IN;
		     CODE_NEW(48 downto 0) <= x"000000000000" & "0";
 
    when "001111" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 83) <= CODE_OLD(33 downto 19);
		     else
		     	CODE_NEW(97 downto 83) <= CODE_OLD(97 downto 83);
		     end if;
		     CODE_NEW(82 downto 48) <= INT_CODE_IN;
		     CODE_NEW(47 downto 0) <= x"000000000000";
 
    when "010000" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 82) <= CODE_OLD(33 downto 18);
		     else
		     	CODE_NEW(97 downto 82) <= CODE_OLD(97 downto 82);
		     end if;
		     CODE_NEW(81 downto 47) <= INT_CODE_IN;
		     CODE_NEW(46 downto 0) <= x"00000000000" & "000";
 
    when "010001" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 81) <= CODE_OLD(33 downto 17);
		     else
		     	CODE_NEW(97 downto 81) <= CODE_OLD(97 downto 81);
		     end if;
		     CODE_NEW(80 downto 46) <= INT_CODE_IN;
		     CODE_NEW(45 downto 0) <= x"00000000000" & "00";
 
    when "010010" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 80) <= CODE_OLD(33 downto 16);
		     else
		     	CODE_NEW(97 downto 80) <= CODE_OLD(97 downto 80);
		     end if;
		     CODE_NEW(79 downto 45) <= INT_CODE_IN;
		     CODE_NEW(44 downto 0) <= x"00000000000" & "0";
 
    when "010011" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 79) <= CODE_OLD(33 downto 15);
		     else
		     	CODE_NEW(97 downto 79) <= CODE_OLD(97 downto 79);
		     end if;
		     CODE_NEW(78 downto 44) <= INT_CODE_IN;
		     CODE_NEW(43 downto 0) <= x"00000000000";
 
    when "010100" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 78) <= CODE_OLD(33 downto 14);
		     else
		     	CODE_NEW(97 downto 78) <= CODE_OLD(97 downto 78);
		     end if;
		     CODE_NEW(77 downto 43) <= INT_CODE_IN;
		     CODE_NEW(42 downto 0) <= x"0000000000" & "000";
 
    when "010101" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 77) <= CODE_OLD(33 downto 13);
		     else
		     	CODE_NEW(97 downto 77) <= CODE_OLD(97 downto 77);
		     end if;
		     CODE_NEW(76 downto 42) <= INT_CODE_IN;
		     CODE_NEW(41 downto 0) <= x"0000000000" & "00";
 
    when "010110" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 76) <= CODE_OLD(33 downto 12);
		     else
		     	CODE_NEW(97 downto 76) <= CODE_OLD(97 downto 76);
		     end if;
		     CODE_NEW(75 downto 41) <= INT_CODE_IN;
		     CODE_NEW(40 downto 0) <= x"0000000000" & "0";
 
    when "010111" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 75) <= CODE_OLD(33 downto 11);
		     else
		     	CODE_NEW(97 downto 75) <= CODE_OLD(97 downto 75);
		     end if;
		     CODE_NEW(74 downto 40) <= INT_CODE_IN;
		     CODE_NEW(39 downto 0) <= x"0000000000";
 
    when "011000" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 74) <= CODE_OLD(33 downto 10);
		     else
		     	CODE_NEW(97 downto 74) <= CODE_OLD(97 downto 74);
		     end if;
		     CODE_NEW(73 downto 39) <= INT_CODE_IN;
		     CODE_NEW(38 downto 0) <= x"000000000" & "000";
 
    when "011001" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 73) <= CODE_OLD(33 downto 9);
		     else
		     	CODE_NEW(97 downto 73) <= CODE_OLD(97 downto 73);
		     end if;
		     CODE_NEW(72 downto 38) <= INT_CODE_IN;
		     CODE_NEW(37 downto 0) <= x"000000000" & "00";
 
    when "011010" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 72) <= CODE_OLD(33 downto 8);
		     else
		     	CODE_NEW(97 downto 72) <= CODE_OLD(97 downto 72);
		     end if;
		     CODE_NEW(71 downto 37) <= INT_CODE_IN;
		     CODE_NEW(36 downto 0) <= x"000000000" & "0";
 
    when "011011" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 71) <= CODE_OLD(33 downto 7);
		     else
		     	CODE_NEW(97 downto 71) <= CODE_OLD(97 downto 71);
		     end if;
		     CODE_NEW(70 downto 36) <= INT_CODE_IN;
		     CODE_NEW(35 downto 0) <= x"000000000";
 
    when "011100" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 70) <= CODE_OLD(33 downto 6);
		     else
		     	CODE_NEW(97 downto 70) <= CODE_OLD(97 downto 70);
		     end if;
		     CODE_NEW(69 downto 35) <= INT_CODE_IN;
		     CODE_NEW(34 downto 0) <= x"00000000" & "000";
 
    when "011101" => if (OVERFLOW_OLD = '0') then
    	    	CODE_NEW(97 downto 69) <= CODE_OLD(33 downto 5);
		     else
		     	CODE_NEW(97 downto 69) <= CODE_OLD(97 downto 69);
		     end if;
		     CODE_NEW(68 downto 34) <= INT_CODE_IN;
		     CODE_NEW(33 downto 0) <= x"00000000" & "00";
 
    when "011110" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 68) <= CODE_OLD(33 downto 4);
		     else
		     	CODE_NEW(97 downto 68) <= CODE_OLD(97 downto 68);
		     end if;
		     CODE_NEW(67 downto 33) <= INT_CODE_IN;
		     CODE_NEW(32 downto 0) <= x"00000000" & "0";
 
    when "011111" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 67) <= CODE_OLD(33 downto 3);
		     else
		     	CODE_NEW(97 downto 67) <= CODE_OLD(97 downto 67);
		     end if;
		     CODE_NEW(66 downto 32) <= INT_CODE_IN;
		     CODE_NEW(31 downto 0) <= x"00000000";
 
    when "100000" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 66) <= CODE_OLD(33 downto 2);
		     else
		     	CODE_NEW(97 downto 66) <= CODE_OLD(97 downto 66);
		     end if;
		     CODE_NEW(65 downto 31) <= INT_CODE_IN;
		     CODE_NEW(30 downto 0) <= x"0000000" & "000";
 
   when "100001" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 65) <= CODE_OLD(33 downto 1);
		     else
		     	CODE_NEW(97 downto 65) <= CODE_OLD(97 downto 65);
		     end if;
		     CODE_NEW(64 downto 30) <= INT_CODE_IN;
		     CODE_NEW(29 downto 0) <= x"0000000" & "00";
 
   when "100010" => if (OVERFLOW_OLD = '0') then
    	    	    	CODE_NEW(97 downto 64) <= CODE_OLD(33 downto 0);
		     else
		     	CODE_NEW(97 downto 64) <= CODE_OLD(97 downto 64);
		     end if;
		     CODE_NEW(63 downto 29) <= INT_CODE_IN;
		     CODE_NEW(28 downto 0) <= x"0000000" & "0";
 
    when "100011" => CODE_NEW <= CODE_OLD(97 downto 63) & INT_CODE_IN & x"0000000";
 
    when "100100" => CODE_NEW <= CODE_OLD(97 downto 62) & INT_CODE_IN & x"000000" & "000";
 
    when "100101" => CODE_NEW <= CODE_OLD(97 downto 61) & INT_CODE_IN & x"000000" & "00";
 
    when "100110" => CODE_NEW <= CODE_OLD(97 downto 60) & INT_CODE_IN & x"000000" & "0";
 
    when "100111" => CODE_NEW <= CODE_OLD(97 downto 59) & INT_CODE_IN & x"000000";
 
    when "101000" => CODE_NEW <= CODE_OLD(97 downto 58) & INT_CODE_IN & x"00000" & "000";
 
    when "101001" => CODE_NEW <= CODE_OLD(97 downto 57) & INT_CODE_IN & x"00000" & "00";
 
    when "101010" => CODE_NEW <= CODE_OLD(97 downto 56) & INT_CODE_IN & x"00000" & "0";
 
    when "101011" => CODE_NEW <= CODE_OLD(97 downto 55) & INT_CODE_IN & x"00000";
 
    when "101100" => CODE_NEW <= CODE_OLD(97 downto 54) & INT_CODE_IN & x"0000" & "000";
 
    when "101101" => CODE_NEW <= CODE_OLD(97 downto 53) & INT_CODE_IN & x"0000" & "00";
 
    when "101110" => CODE_NEW <= CODE_OLD(97 downto 52) & INT_CODE_IN & x"0000" & "0";
 
    when "101111" => CODE_NEW <= CODE_OLD(97 downto 51) & INT_CODE_IN & x"0000";
 
    when "110000" => CODE_NEW <= CODE_OLD(97 downto 50) & INT_CODE_IN & x"000" & "000";
 
    when "110001" => CODE_NEW <= CODE_OLD(97 downto 49) & INT_CODE_IN & x"000" & "00";
 
    when "110010" => CODE_NEW <= CODE_OLD(97 downto 48) & INT_CODE_IN & x"000" & "0";
 
    when "110011" => CODE_NEW <= CODE_OLD(97 downto 47) & INT_CODE_IN & x"000";
 
    when "110100" => CODE_NEW <= CODE_OLD(97 downto 46) & INT_CODE_IN & x"00" & "000";
 
    when "110101" => CODE_NEW <= CODE_OLD(97 downto 45) & INT_CODE_IN & x"00" & "00";
 
    when "110110" => CODE_NEW <= CODE_OLD(97 downto 44) & INT_CODE_IN & x"00" & "0";
 
    when "110111" => CODE_NEW <= CODE_OLD(97 downto 43) & INT_CODE_IN & x"00";
 
    when "111000" => CODE_NEW <= CODE_OLD(97 downto 42) & INT_CODE_IN & x"0" & "000";
 
    when "111001" => CODE_NEW <= CODE_OLD(97 downto 41) & INT_CODE_IN & x"0" & "00";
 
    when "111010" => CODE_NEW <= CODE_OLD(97 downto 40) & INT_CODE_IN & x"0" & "0";
 
    when "111011" => CODE_NEW <= CODE_OLD(97 downto 39) & INT_CODE_IN & x"0";
 
    when "111100" => CODE_NEW <= CODE_OLD(97 downto 38) & INT_CODE_IN & "000";
 
    when "111101" => CODE_NEW <= CODE_OLD(97 downto 37) & INT_CODE_IN & "00";
 
    when "111110" => CODE_NEW <= CODE_OLD(97 downto 36) & INT_CODE_IN & "0";
 
    when "111111" => CODE_NEW <= CODE_OLD(97 downto 35) & INT_CODE_IN;
end case;
--else
--     CODE_NEW <= x"000000000000000000000000";
--end if;
end process CODE_SHIFT;
 
 
end ASSEMBLE2; -- end of architecture