URL https://opencores.org/ocsvn/xmatchpro/xmatchpro/trunk

Subversion Repositories xmatchpro

[/] [xmatchpro/] [trunk/] [xmw4-comdec/] [xmatch_sim7/] [src/] [ob_assembler.vhd] - Blame information for rev 9

Details | Compare with Previous | View Log


--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
 
 
 
 
 
 
 

Browse

Tools

Subversion Repositories xmatchpro

[/] [xmatchpro/] [trunk/] [xmw4-comdec/] [xmatch_sim7/] [src/] [ob_assembler.vhd] - Blame information for rev 9

Line No.	Rev	Author	Line
1	9	eejlny	`--This library is free software; you can redistribute it and/or`
2			`--modify it under the terms of the GNU Lesser General Public`
3			`--License as published by the Free Software Foundation; either`
4			`--version 2.1 of the License, or (at your option) any later version.`
5
6			`--This library is distributed in the hope that it will be useful,`
7			`--but WITHOUT ANY WARRANTY; without even the implied warranty of`
8			`--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
9			`--Lesser General Public License for more details.`
10
11			`--You should have received a copy of the GNU Lesser General Public`
12			`--License along with this library; if not, write to the Free Software`
13			`--Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA`
14
15			`-- e_mail : j.l.nunez-yanez@byacom.co.uk`
16
17			`-----------------------------------`
18			`-- ENTITY = OB_ASSEMBLER --`
19			`-- version = 2.0 --`
20			`-- last update = 6/06/01 --`
21			`-- author = Jose Nunez --`
22			`-----------------------------------`
23
24
25			`-- FUNCTION`
26			`-- final assembly stage for output compressed data.`
27
28
29			`-- PIN LIST`
30			`-- CLK = master clock`
31			`-- CLEAR = asynchronous clear signal (active LOW)`
32			`-- CODE_OLD = current contents of the output code register`
33			`-- LENGTH_OLD = current length of the output code register`
34			`-- CODE_IN = new input code to be added to the current code`
35			`-- LENGTH_IN = length of the input code`
36			`-- COMP = indicates that we are in compression mode (active low)`
37			`-- FLUSH_IN = indicates that we are at the end of compression and thus must flush any`
38			`-- remaining data from the output code register (new input data is no`
39			`-- longer valid)`
40			`-- CODE_NEW = new data for the output code register`
41			`-- LENGTH_NEW = new output code register length`
42			`-- OVERFLOW_LENGTH = new overflow status (active low). Will go active if more than 64 bits`
43			`-- of the new code are valid`
44			`-- OVERFLOW_FLUSH = indicates a flushing overflow (data must go out when flushing )`
45			`-- FLUSH_END = indicates end of flushing operation (active low)`
46
47
48			`library ieee,dzx;`
49			`use ieee.std_logic_1164.all;`
50			`use dzx.bit_arith.all;`
51			`use dzx.bit_utils.all;`
52
53
54			`entity OB_ASSEMBLER is`
55			`port`
56			`(`
57			`CLK : in bit;`
58			`CLEAR : in bit;`
59			`RESET : in bit;`
60			`CODE_OLD : in bit_vector(97 downto 0);`
61			`LENGTH_OLD : in bit_vector(5 downto 0);`
62			`CODE_IN : in bit_vector(34 downto 0);`
63			`LENGTH_IN : in bit_vector(5 downto 0);`
64			`COMP : in bit;`
65			`FLUSH_IN : in bit;`
66			`OVERFLOW_OLD : in bit;`
67			`CODE_NEW : out bit_vector(97 downto 0);`
68			`LENGTH_NEW : out bit_vector(5 downto 0);`
69			`OVERFLOW_LENGTH : out bit;`
70			`OVERFLOW_FLUSH : out bit;`
71			`SHORT : out bit;`
72			`FLUSH_END : out bit`
73			`);`
74
75
76
77			`end OB_ASSEMBLER;`
78
79
80			`architecture ASSEMBLE2 of OB_ASSEMBLER is`
81
82			`signal FLUSHING_D : bit;`
83			`signal FLUSHING_Q : bit;`
84			`signal EFC_D : bit;`
85			`signal EFC_Q : bit;`
86			`signal LENGTH_ZERO : bit;`
87			`signal INT_CODE_IN : bit_vector(34 downto 0);`
88			`signal INT_LENGTH_IN : bit_vector(5 downto 0);`
89			`signal CYCLE1_END : bit;`
90			`signal CYCLE1_FORCE : bit;`
91			`signal OVERFLOW_FLUSH_AUX : bit;`
92			`signal LONG_WORD_D : bit;`
93			`signal LONG_WORD_Q : bit;`
94
95			`begin`
96
97			`LENGTH_ZERO <= Nor_Bits(LENGTH_OLD);`
98			`EFC_D <= FLUSH_IN or LENGTH_ZERO or OVERFLOW_OLD;`
99			`FLUSHING_D <= FLUSH_IN and FLUSHING_Q;`
100			`CYCLE1_END <= FLUSH_IN or not(OVERFLOW_OLD or LENGTH_ZERO);`
101			`CYCLE1_FORCE <= FLUSH_IN or LENGTH_ZERO or not(OVERFLOW_OLD);`
102
103
104
105			`FLUSH_END <= CYCLE1_END and EFC_Q;`
106			`OVERFLOW_FLUSH_AUX <= CYCLE1_FORCE and EFC_Q;`
107			`OVERFLOW_FLUSH <= OVERFLOW_FLUSH_AUX;`
108			`SHORT <= OVERFLOW_FLUSH_AUX or LONG_WORD_Q;`
109
110			`VALIDATE_INPUTS : process( COMP, CODE_IN , LENGTH_IN , FLUSHING_D )`
111			`begin`
112			`if (FLUSHING_D = '1' and COMP='0') then`
113			`INT_CODE_IN <= CODE_IN;`
114			`INT_LENGTH_IN <= LENGTH_IN;`
115			`else`
116			`INT_CODE_IN <= "00000000000000000000000000000000000";`
117			`INT_LENGTH_IN <= "000000";`
118			`end if;`
119			`end process VALIDATE_INPUTS;`
120
121
122			`CONTROL_FLIPS : process(CLEAR,CLK)`
123			`begin`
124			`if (CLEAR='0') then`
125			`FLUSHING_Q <= '1';`
126			`EFC_Q <= '1';`
127			`LONG_WORD_Q <= '1';`
128			`elsif ((CLK'event) and (CLK = '1')) then`
129			`if ((RESET = '0') or (COMP = '1')) then`
130			`FLUSHING_Q <= '1';`
131			`EFC_Q <= '1';`
132			`LONG_WORD_Q <= '1';`
133			`else`
134			`FLUSHING_Q <= FLUSHING_D;`
135			`EFC_Q <= EFC_D;`
136			`LONG_WORD_Q <= LONG_WORD_D;`
137			`end if;`
138			`end if;`
139			`end process CONTROL_FLIPS;`
140
141
142			`LENGTH_CALC : process( LENGTH_OLD , INT_LENGTH_IN , FLUSHING_D , COMP)`
143			`variable TEMP_LENGTH : bit_vector(6 downto 0);`
144			`variable TEMP_LENGTH_AUX : bit_vector(6 downto 0);`
145
146			`begin`
147
148			`TEMP_LENGTH_AUX := ('0' & LENGTH_OLD) + ('0' & INT_LENGTH_IN);`
149
150			`LONG_WORD_D <= TEMP_LENGTH_AUX(6) or (TEMP_LENGTH_AUX(5) and or_bits(TEMP_LENGTH_AUX(4 downto 0)));`
151
152			`if ((COMP = '1') or (FLUSHING_D = '0')) then`
153			`TEMP_LENGTH := "0000000";`
154			`else`
155			`TEMP_LENGTH := TEMP_LENGTH_AUX;`
156			`end if;`
157
158
159			`LENGTH_NEW <= TEMP_LENGTH(5 downto 0);`
160			`OVERFLOW_LENGTH <= not(TEMP_LENGTH(6));`
161			`end process LENGTH_CALC;`
162
163
164
165			`CODE_SHIFT : process (CODE_OLD , LENGTH_OLD , INT_CODE_IN , OVERFLOW_OLD)`
166			`begin`
167			`--if (COMP = '0') then`
168			`case LENGTH_OLD is`
169			`when "000000" => CODE_NEW <= INT_CODE_IN & x"000000000000000" & "000";`
170
171			`when "000001" => if (OVERFLOW_OLD = '0') then`
172			`CODE_NEW(97) <= CODE_OLD(33);`
173			`else`
174			`CODE_NEW(97) <= CODE_OLD(97);`
175			`end if;`
176			`CODE_NEW(96 downto 62) <= INT_CODE_IN;`
177			`CODE_NEW(61 downto 0) <= x"000000000000000" & "00";`
178
179			`when "000010" => if (OVERFLOW_OLD = '0') then`
180			`CODE_NEW(97 downto 96) <= CODE_OLD(33 downto 32);`
181			`else`
182			`CODE_NEW(97 downto 96) <= CODE_OLD(97 downto 96);`
183			`end if;`
184			`CODE_NEW(95 downto 61) <= INT_CODE_IN;`
185			`CODE_NEW(60 downto 0) <= x"000000000000000" & "0";`
186
187			`when "000011" => if (OVERFLOW_OLD = '0') then`
188			`CODE_NEW(97 downto 95) <= CODE_OLD(33 downto 31);`
189			`else`
190			`CODE_NEW(97 downto 95) <= CODE_OLD(97 downto 95);`
191			`end if;`
192			`CODE_NEW(94 downto 60) <= INT_CODE_IN;`
193			`CODE_NEW(59 downto 0) <= x"000000000000000";`
194
195			`when "000100" => if (OVERFLOW_OLD = '0') then`
196			`CODE_NEW(97 downto 94) <= CODE_OLD(33 downto 30);`
197			`else`
198			`CODE_NEW(97 downto 94) <= CODE_OLD(97 downto 94);`
199			`end if;`
200			`CODE_NEW(93 downto 59) <= INT_CODE_IN;`
201			`CODE_NEW(58 downto 0) <= x"00000000000000" & "000";`
202
203			`when "000101" => if (OVERFLOW_OLD = '0') then`
204			`CODE_NEW(97 downto 93) <= CODE_OLD(33 downto 29);`
205			`else`
206			`CODE_NEW(97 downto 93) <= CODE_OLD(97 downto 93);`
207			`end if;`
208			`CODE_NEW(92 downto 58) <= INT_CODE_IN;`
209			`CODE_NEW(57 downto 0) <= x"00000000000000" & "00";`
210
211			`when "000110" => if (OVERFLOW_OLD = '0') then`
212			`CODE_NEW(97 downto 92) <= CODE_OLD(33 downto 28);`
213			`else`
214			`CODE_NEW(97 downto 92) <= CODE_OLD(97 downto 92);`
215			`end if;`
216			`CODE_NEW(91 downto 57) <= INT_CODE_IN;`
217			`CODE_NEW(56 downto 0) <= x"00000000000000" & "0";`
218
219			`when "000111" => if (OVERFLOW_OLD = '0') then`
220			`CODE_NEW(97 downto 91) <= CODE_OLD(33 downto 27);`
221			`else`
222			`CODE_NEW(97 downto 91) <= CODE_OLD(97 downto 91);`
223			`end if;`
224			`CODE_NEW(90 downto 56) <= INT_CODE_IN;`
225			`CODE_NEW(55 downto 0) <= x"00000000000000";`
226
227			`when "001000" => if (OVERFLOW_OLD = '0') then`
228			`CODE_NEW(97 downto 90) <= CODE_OLD(33 downto 26);`
229			`else`
230			`CODE_NEW(97 downto 90) <= CODE_OLD(97 downto 90);`
231			`end if;`
232			`CODE_NEW(89 downto 55) <= INT_CODE_IN;`
233			`CODE_NEW(54 downto 0) <= x"0000000000000" & "000";`
234
235			`when "001001" => if (OVERFLOW_OLD = '0') then`
236			`CODE_NEW(97 downto 89) <= CODE_OLD(33 downto 25);`
237			`else`
238			`CODE_NEW(97 downto 89) <= CODE_OLD(97 downto 89);`
239			`end if;`
240			`CODE_NEW(88 downto 54) <= INT_CODE_IN;`
241			`CODE_NEW(53 downto 0) <= x"0000000000000" & "00";`
242
243			`when "001010" => if (OVERFLOW_OLD = '0') then`
244			`CODE_NEW(97 downto 88) <= CODE_OLD(33 downto 24);`
245			`else`
246			`CODE_NEW(97 downto 88) <= CODE_OLD(97 downto 88);`
247			`end if;`
248			`CODE_NEW(87 downto 53) <= INT_CODE_IN;`
249			`CODE_NEW(52 downto 0) <= x"0000000000000" & "0";`
250
251			`when "001011" => if (OVERFLOW_OLD = '0') then`
252			`CODE_NEW(97 downto 87) <= CODE_OLD(33 downto 23);`
253			`else`
254			`CODE_NEW(97 downto 87) <= CODE_OLD(97 downto 87);`
255			`end if;`
256			`CODE_NEW(86 downto 52) <= INT_CODE_IN;`
257			`CODE_NEW(51 downto 0) <= x"0000000000000";`
258
259			`when "001100" => if (OVERFLOW_OLD = '0') then`
260			`CODE_NEW(97 downto 86) <= CODE_OLD(33 downto 22);`
261			`else`
262			`CODE_NEW(97 downto 86) <= CODE_OLD(97 downto 86);`
263			`end if;`
264			`CODE_NEW(85 downto 51) <= INT_CODE_IN;`
265			`CODE_NEW(50 downto 0) <= x"000000000000" & "000";`
266
267			`when "001101" => if (OVERFLOW_OLD = '0') then`
268			`CODE_NEW(97 downto 85) <= CODE_OLD(33 downto 21);`
269			`else`
270			`CODE_NEW(97 downto 85) <= CODE_OLD(97 downto 85);`
271			`end if;`
272			`CODE_NEW(84 downto 50) <= INT_CODE_IN;`
273			`CODE_NEW(49 downto 0) <= x"000000000000" & "00";`
274
275			`when "001110" => if (OVERFLOW_OLD = '0') then`
276			`CODE_NEW(97 downto 84) <= CODE_OLD(33 downto 20);`
277			`else`
278			`CODE_NEW(97 downto 84) <= CODE_OLD(97 downto 84);`
279			`end if;`
280			`CODE_NEW(83 downto 49) <= INT_CODE_IN;`
281			`CODE_NEW(48 downto 0) <= x"000000000000" & "0";`
282
283			`when "001111" => if (OVERFLOW_OLD = '0') then`
284			`CODE_NEW(97 downto 83) <= CODE_OLD(33 downto 19);`
285			`else`
286			`CODE_NEW(97 downto 83) <= CODE_OLD(97 downto 83);`
287			`end if;`
288			`CODE_NEW(82 downto 48) <= INT_CODE_IN;`
289			`CODE_NEW(47 downto 0) <= x"000000000000";`
290
291			`when "010000" => if (OVERFLOW_OLD = '0') then`
292			`CODE_NEW(97 downto 82) <= CODE_OLD(33 downto 18);`
293			`else`
294			`CODE_NEW(97 downto 82) <= CODE_OLD(97 downto 82);`
295			`end if;`
296			`CODE_NEW(81 downto 47) <= INT_CODE_IN;`
297			`CODE_NEW(46 downto 0) <= x"00000000000" & "000";`
298
299			`when "010001" => if (OVERFLOW_OLD = '0') then`
300			`CODE_NEW(97 downto 81) <= CODE_OLD(33 downto 17);`
301			`else`
302			`CODE_NEW(97 downto 81) <= CODE_OLD(97 downto 81);`
303			`end if;`
304			`CODE_NEW(80 downto 46) <= INT_CODE_IN;`
305			`CODE_NEW(45 downto 0) <= x"00000000000" & "00";`
306
307			`when "010010" => if (OVERFLOW_OLD = '0') then`
308			`CODE_NEW(97 downto 80) <= CODE_OLD(33 downto 16);`
309			`else`
310			`CODE_NEW(97 downto 80) <= CODE_OLD(97 downto 80);`
311			`end if;`
312			`CODE_NEW(79 downto 45) <= INT_CODE_IN;`
313			`CODE_NEW(44 downto 0) <= x"00000000000" & "0";`
314
315			`when "010011" => if (OVERFLOW_OLD = '0') then`
316			`CODE_NEW(97 downto 79) <= CODE_OLD(33 downto 15);`
317			`else`
318			`CODE_NEW(97 downto 79) <= CODE_OLD(97 downto 79);`
319			`end if;`
320			`CODE_NEW(78 downto 44) <= INT_CODE_IN;`
321			`CODE_NEW(43 downto 0) <= x"00000000000";`
322
323			`when "010100" => if (OVERFLOW_OLD = '0') then`
324			`CODE_NEW(97 downto 78) <= CODE_OLD(33 downto 14);`
325			`else`
326			`CODE_NEW(97 downto 78) <= CODE_OLD(97 downto 78);`
327			`end if;`
328			`CODE_NEW(77 downto 43) <= INT_CODE_IN;`
329			`CODE_NEW(42 downto 0) <= x"0000000000" & "000";`
330
331			`when "010101" => if (OVERFLOW_OLD = '0') then`
332			`CODE_NEW(97 downto 77) <= CODE_OLD(33 downto 13);`
333			`else`
334			`CODE_NEW(97 downto 77) <= CODE_OLD(97 downto 77);`
335			`end if;`
336			`CODE_NEW(76 downto 42) <= INT_CODE_IN;`
337			`CODE_NEW(41 downto 0) <= x"0000000000" & "00";`
338
339			`when "010110" => if (OVERFLOW_OLD = '0') then`
340			`CODE_NEW(97 downto 76) <= CODE_OLD(33 downto 12);`
341			`else`
342			`CODE_NEW(97 downto 76) <= CODE_OLD(97 downto 76);`
343			`end if;`
344			`CODE_NEW(75 downto 41) <= INT_CODE_IN;`
345			`CODE_NEW(40 downto 0) <= x"0000000000" & "0";`
346
347			`when "010111" => if (OVERFLOW_OLD = '0') then`
348			`CODE_NEW(97 downto 75) <= CODE_OLD(33 downto 11);`
349			`else`
350			`CODE_NEW(97 downto 75) <= CODE_OLD(97 downto 75);`
351			`end if;`
352			`CODE_NEW(74 downto 40) <= INT_CODE_IN;`
353			`CODE_NEW(39 downto 0) <= x"0000000000";`
354
355			`when "011000" => if (OVERFLOW_OLD = '0') then`
356			`CODE_NEW(97 downto 74) <= CODE_OLD(33 downto 10);`
357			`else`
358			`CODE_NEW(97 downto 74) <= CODE_OLD(97 downto 74);`
359			`end if;`
360			`CODE_NEW(73 downto 39) <= INT_CODE_IN;`
361			`CODE_NEW(38 downto 0) <= x"000000000" & "000";`
362
363			`when "011001" => if (OVERFLOW_OLD = '0') then`
364			`CODE_NEW(97 downto 73) <= CODE_OLD(33 downto 9);`
365			`else`
366			`CODE_NEW(97 downto 73) <= CODE_OLD(97 downto 73);`
367			`end if;`
368			`CODE_NEW(72 downto 38) <= INT_CODE_IN;`
369			`CODE_NEW(37 downto 0) <= x"000000000" & "00";`
370
371			`when "011010" => if (OVERFLOW_OLD = '0') then`
372			`CODE_NEW(97 downto 72) <= CODE_OLD(33 downto 8);`
373			`else`
374			`CODE_NEW(97 downto 72) <= CODE_OLD(97 downto 72);`
375			`end if;`
376			`CODE_NEW(71 downto 37) <= INT_CODE_IN;`
377			`CODE_NEW(36 downto 0) <= x"000000000" & "0";`
378
379			`when "011011" => if (OVERFLOW_OLD = '0') then`
380			`CODE_NEW(97 downto 71) <= CODE_OLD(33 downto 7);`
381			`else`
382			`CODE_NEW(97 downto 71) <= CODE_OLD(97 downto 71);`
383			`end if;`
384			`CODE_NEW(70 downto 36) <= INT_CODE_IN;`
385			`CODE_NEW(35 downto 0) <= x"000000000";`
386
387			`when "011100" => if (OVERFLOW_OLD = '0') then`
388			`CODE_NEW(97 downto 70) <= CODE_OLD(33 downto 6);`
389			`else`
390			`CODE_NEW(97 downto 70) <= CODE_OLD(97 downto 70);`
391			`end if;`
392			`CODE_NEW(69 downto 35) <= INT_CODE_IN;`
393			`CODE_NEW(34 downto 0) <= x"00000000" & "000";`
394
395			`when "011101" => if (OVERFLOW_OLD = '0') then`
396			`CODE_NEW(97 downto 69) <= CODE_OLD(33 downto 5);`
397			`else`
398			`CODE_NEW(97 downto 69) <= CODE_OLD(97 downto 69);`
399			`end if;`
400			`CODE_NEW(68 downto 34) <= INT_CODE_IN;`
401			`CODE_NEW(33 downto 0) <= x"00000000" & "00";`
402
403			`when "011110" => if (OVERFLOW_OLD = '0') then`
404			`CODE_NEW(97 downto 68) <= CODE_OLD(33 downto 4);`
405			`else`
406			`CODE_NEW(97 downto 68) <= CODE_OLD(97 downto 68);`
407			`end if;`
408			`CODE_NEW(67 downto 33) <= INT_CODE_IN;`
409			`CODE_NEW(32 downto 0) <= x"00000000" & "0";`
410
411			`when "011111" => if (OVERFLOW_OLD = '0') then`
412			`CODE_NEW(97 downto 67) <= CODE_OLD(33 downto 3);`
413			`else`
414			`CODE_NEW(97 downto 67) <= CODE_OLD(97 downto 67);`
415			`end if;`
416			`CODE_NEW(66 downto 32) <= INT_CODE_IN;`
417			`CODE_NEW(31 downto 0) <= x"00000000";`
418
419			`when "100000" => if (OVERFLOW_OLD = '0') then`
420			`CODE_NEW(97 downto 66) <= CODE_OLD(33 downto 2);`
421			`else`
422			`CODE_NEW(97 downto 66) <= CODE_OLD(97 downto 66);`
423			`end if;`
424			`CODE_NEW(65 downto 31) <= INT_CODE_IN;`
425			`CODE_NEW(30 downto 0) <= x"0000000" & "000";`
426
427			`when "100001" => if (OVERFLOW_OLD = '0') then`
428			`CODE_NEW(97 downto 65) <= CODE_OLD(33 downto 1);`
429			`else`
430			`CODE_NEW(97 downto 65) <= CODE_OLD(97 downto 65);`
431			`end if;`
432			`CODE_NEW(64 downto 30) <= INT_CODE_IN;`
433			`CODE_NEW(29 downto 0) <= x"0000000" & "00";`
434
435			`when "100010" => if (OVERFLOW_OLD = '0') then`
436			`CODE_NEW(97 downto 64) <= CODE_OLD(33 downto 0);`
437			`else`
438			`CODE_NEW(97 downto 64) <= CODE_OLD(97 downto 64);`
439			`end if;`
440			`CODE_NEW(63 downto 29) <= INT_CODE_IN;`
441			`CODE_NEW(28 downto 0) <= x"0000000" & "0";`
442
443			`when "100011" => CODE_NEW <= CODE_OLD(97 downto 63) & INT_CODE_IN & x"0000000";`
444
445			`when "100100" => CODE_NEW <= CODE_OLD(97 downto 62) & INT_CODE_IN & x"000000" & "000";`
446
447			`when "100101" => CODE_NEW <= CODE_OLD(97 downto 61) & INT_CODE_IN & x"000000" & "00";`
448
449			`when "100110" => CODE_NEW <= CODE_OLD(97 downto 60) & INT_CODE_IN & x"000000" & "0";`
450
451			`when "100111" => CODE_NEW <= CODE_OLD(97 downto 59) & INT_CODE_IN & x"000000";`
452
453			`when "101000" => CODE_NEW <= CODE_OLD(97 downto 58) & INT_CODE_IN & x"00000" & "000";`
454
455			`when "101001" => CODE_NEW <= CODE_OLD(97 downto 57) & INT_CODE_IN & x"00000" & "00";`
456
457			`when "101010" => CODE_NEW <= CODE_OLD(97 downto 56) & INT_CODE_IN & x"00000" & "0";`
458
459			`when "101011" => CODE_NEW <= CODE_OLD(97 downto 55) & INT_CODE_IN & x"00000";`
460
461			`when "101100" => CODE_NEW <= CODE_OLD(97 downto 54) & INT_CODE_IN & x"0000" & "000";`
462
463			`when "101101" => CODE_NEW <= CODE_OLD(97 downto 53) & INT_CODE_IN & x"0000" & "00";`
464
465			`when "101110" => CODE_NEW <= CODE_OLD(97 downto 52) & INT_CODE_IN & x"0000" & "0";`
466
467			`when "101111" => CODE_NEW <= CODE_OLD(97 downto 51) & INT_CODE_IN & x"0000";`
468
469			`when "110000" => CODE_NEW <= CODE_OLD(97 downto 50) & INT_CODE_IN & x"000" & "000";`
470
471			`when "110001" => CODE_NEW <= CODE_OLD(97 downto 49) & INT_CODE_IN & x"000" & "00";`
472
473			`when "110010" => CODE_NEW <= CODE_OLD(97 downto 48) & INT_CODE_IN & x"000" & "0";`
474
475			`when "110011" => CODE_NEW <= CODE_OLD(97 downto 47) & INT_CODE_IN & x"000";`
476
477			`when "110100" => CODE_NEW <= CODE_OLD(97 downto 46) & INT_CODE_IN & x"00" & "000";`
478
479			`when "110101" => CODE_NEW <= CODE_OLD(97 downto 45) & INT_CODE_IN & x"00" & "00";`
480
481			`when "110110" => CODE_NEW <= CODE_OLD(97 downto 44) & INT_CODE_IN & x"00" & "0";`
482
483			`when "110111" => CODE_NEW <= CODE_OLD(97 downto 43) & INT_CODE_IN & x"00";`
484
485			`when "111000" => CODE_NEW <= CODE_OLD(97 downto 42) & INT_CODE_IN & x"0" & "000";`
486
487			`when "111001" => CODE_NEW <= CODE_OLD(97 downto 41) & INT_CODE_IN & x"0" & "00";`
488
489			`when "111010" => CODE_NEW <= CODE_OLD(97 downto 40) & INT_CODE_IN & x"0" & "0";`
490
491			`when "111011" => CODE_NEW <= CODE_OLD(97 downto 39) & INT_CODE_IN & x"0";`
492
493			`when "111100" => CODE_NEW <= CODE_OLD(97 downto 38) & INT_CODE_IN & "000";`
494
495			`when "111101" => CODE_NEW <= CODE_OLD(97 downto 37) & INT_CODE_IN & "00";`
496
497			`when "111110" => CODE_NEW <= CODE_OLD(97 downto 36) & INT_CODE_IN & "0";`
498
499			`when "111111" => CODE_NEW <= CODE_OLD(97 downto 35) & INT_CODE_IN;`
500			`end case;`
501			`--else`
502			`-- CODE_NEW <= x"000000000000000000000000";`
503			`--end if;`
504			`end process CODE_SHIFT;`
505
506
507			`end ASSEMBLE2; -- end of architecture`
508
509
510
511
512
513
514