end if;         result := ('0' & UNum) * ('0' & Prod);      if Num(Num'High) = '1' then --negative result         result := (not result) + 1; --2's Complement      end if;      return result(24 downto 0);	end MultiplierQ;      function Mult_Columns (Line : in std_logic_vector) return std_logic_vector;   	function Mult_Columns (Line : in std_logic_vector) return std_logic_vector is		variable result : std_logic_vector(12 downto 0);	begin      result := "0000000000000" + (Line & "00000000") + (Line & "000000") + (Line & "00000");		return result; --with Line max=1111, the max. result will be=1010010100000 (12..0)	end Mult_Columns;   function Mult_Half_Columns (Line : in std_logic_vector) return std_logic_vector;   	function Mult_Half_Columns (Line : in std_logic_vector) return std_logic_vector is		variable result : std_logic_vector(10 downto 0);	begin      result := "00000000000" + (Line & "0000000") + (Line & "00000") + (Line & "0000");		return result; --with Line max=111, the max. result will be=10011010000 (10..0)	end Mult_Half_Columns;        function GetCategory (Coef : in std_logic_vector) return integer;      --function fixed to work under ModelSim by Peter Eisemann      function GetCategory (Coef : in std_logic_vector) return integer is         --tells us the category of the coefficient (AC and DC) based on a "sign-less" version of itself!         variable Coeff : std_logic_vector(Coef'High downto 0);         variable result: integer := 0;      begin         if Coef(Coef'High) = '1' then            Coeff := (not Coef) + 1;         else            Coeff := Coef;         end if;            categoryloop:for index in Coeff'range loop            if Coeff(index) = '1' then               -- return (index + 1);  Eim               result := (index +1);               exit categoryloop when Coeff(index) = '1';            end if;            end loop categoryloop;                        return result;   end GetCategory;      --   function GetCategory (Coef : in std_logic_vector) return integer;--   --   function GetCategory (Coef : in std_logic_vector) return integer is--      --tells us the category of the coefficient (AC and DC) based on a "sign-less" version of itself!--      variable Coeff : std_logic_vector(Coef'High downto 0);--   begin--      if Coef(Coef'High) = '1' then--         Coeff := (not Coef) + 1;--      else--        Coeff := Coef;--      end if;   --      for index in Coeff'range loop--         if Coeff(index) = '1' then--            return (index + 1);--        end if;   --      end loop;               --      return 0;--   end GetCategory;         function AppendHuffmanWord (HuffmanWord, Code : in std_logic_vector; Pos : in integer) return std_logic_vector;      function AppendHuffmanWord (HuffmanWord, Code : in std_logic_vector; Pos : in integer) return std_logic_vector is      variable result : std_logic_vector(22 downto 0);      begin      result := HuffmanWord;      for i in (Code'length-1) downto 0 loop        result(Pos-i) := Code(i); --Code(Code'length-1-i); --MSB first!!        --IMPORTANT: the std_logic_vector is "to", not "downto", that's why the MSB is opposite as usual      end loop;         return result;   end AppendHuffmanWord;   --this function is an overload with Code as std_logic (used when it must only append the sign)   function AppendHuffmanWord (HuffmanWord : in std_logic_vector; Code : in std_logic; Pos : in integer) return std_logic_vector;      function AppendHuffmanWord (HuffmanWord : in std_logic_vector; Code : in std_logic; Pos : in integer) return std_logic_vector is      variable result : std_logic_vector(22 downto 0);   begin      result := HuffmanWord;      result(Pos) := Code;            return result;   end AppendHuffmanWord;      --this one is to define the MSB of Code in case it is not length-1, so that CodeLength is the new length-1   function AppendHuffmanWordL (HuffmanWord, Code : in std_logic_vector; CodeLength : in integer; Pos : in integer) return std_logic_vector;      function AppendHuffmanWordL (HuffmanWord, Code : in std_logic_vector; CodeLength : in integer; Pos : in integer) return std_logic_vector is      variable result : std_logic_vector(22 downto 0);   begin      result := HuffmanWord;      for i in Code'length downto 0 loop         if i < CodeLength then --this may look redundant but it avoids an "unbound loop" error            result(Pos-i) := Code(CodeLength-1-i); --careful! here bit 0 is the LSB, X-File         end if;         end loop;         return result;   end AppendHuffmanWordL;         function To_std_logicvpor11(ZeroRun : in integer) return std_logic_vector;      function To_std_logicvpor11(ZeroRun : in integer) return std_logic_vector is      --returns the integer times 11 in a std_logic_vector(8 downto 0)   begin      case ZeroRun is         when 0 =>            return "000000000";         when 1 =>            return "000001011";         when 2 =>            return "000010110";         when 3 =>            return "000100001";         when 4 =>            return "000101100";         when 5 =>            return "000110111";         when 6 =>            return "001000010";         when 7 =>            return "001001101";         when 8 =>            return "001011000";         when 9 =>            return "001100011";         when 10 =>            return "001101110";         when 11 =>            return "001111001";         when 12 =>            return "010000100";         when 13 =>            return "010001111";         when 14 =>            return "010011010";         when others => --15 =>            return "010100101"; --165      end case;   end To_std_logicvpor11;         function To_std_logicv(Cat : in integer) return std_logic_vector;      function To_std_logicv(Cat : in integer) return std_logic_vector is   begin      case Cat is         when 0 =>            return "0000";         when 1 =>            return "0001";         when 2 =>            return "0010";         when 3 =>            return "0011";         when 4 =>            return "0100";         when 5 =>            return "0101";         when 6 =>            return "0110";         when 7 =>            return "0111";         when 8 =>            return "1000";         when 9 =>            return "1001";         when others => -- 10 => there won't be 11 because we only use it for AC            return "1010";      end case;            end To_std_logicv;      function GetMagnitude (Coef : in std_logic_vector; Cat : in integer) return std_logic_vector;      function GetMagnitude (Coef : in std_logic_vector; Cat : in integer) return std_logic_vector is   begin      case Cat is         when 0 =>            return "000000000000"; --we avoid this case with an if because it wouldn't be correct         when 1 =>            return "000000000000"; --we avoid this case with an if because it wouldn't be correct         when 2 =>            return (Coef - "10");         when 3 =>            return (Coef - "100");         when 4 =>            return (Coef - "1000");         when 5 =>            return (Coef - "10000");         when 6 =>            return (Coef - "100000");         when 7 =>            return (Coef - "1000000");         when 8 =>            return (Coef - "10000000");         when 9 =>            return (Coef - "100000000");         when 10 =>            return (Coef - "1000000000");         when others => --11 =>            return (Coef - "10000000000");      end case;   end GetMagnitude;         function CompressDC(Cat : in integer; LumaBlock : in std_logic) return std_logic_vector;      function CompressDC(Cat : in integer; LumaBlock : in std_logic) return std_logic_vector is      variable result : std_logic_vector(14 downto 0) := (others => '0');   begin --the four MSBs of result keep the number of the MSB bit of the data in the LSBs      if LumaBlock = '1' then --compress with DC Luminance Table         case Cat is            when 0 =>               result := "000100000000000";            when 1 =>               result := "001000000000010";            when 2 =>               result := "001000000000011";            when 3 =>               result := "001000000000100";            when 4 =>               result := "001000000000101";            when 5 =>               result := "001000000000110";            when 6 =>               result := "001100000001110";            when 7 =>               result := "010000000011110";            when 8 =>               result := "010100000111110";            when 9 =>               result := "011000001111110";            when 10 =>               result := "011100011111110";            when others => --11               result := "100000111111110";         end case;      else --DC chrominance table         case Cat is            when 0 =>               result := "000100000000000";            when 1 =>               result := "000100000000001";            when 2 =>               result := "000100000000010";            when 3 =>               result := "001000000000110";            when 4 =>               result := "001100000001110";            when 5 =>               result := "010000000011110";            when 6 =>               result := "010100000111110";            when 7 =>               result := "011000001111110";            when 8 =>               result := "011100011111110";            when 9 =>               result := "100000111111110";            when 10 =>               result := "100101111111110";            when others => --11               result := "101011111111110";         end case;      end if;