Subversion Repositories g729a_codec

-----------------------------------------------------------------

--                                                             --

-----------------------------------------------------------------

--                                                             --

-- Copyright (C) 2013 Stefano Tonello                          --

--                                                             --

-- This source file may be used and distributed without        --

-- restriction provided that this copyright statement is not   --

-- removed from the file and that any derivative work contains --

-- the original copyright notice and the associated disclaimer.--

--                                                             --

-- THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY         --

-- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   --

-- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   --

-- FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      --

-- OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         --

-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    --

-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   --

-- GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        --

-- BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  --

-- LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  --

-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  --

-- OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         --

-- POSSIBILITY OF SUCH DAMAGE.                                 --

--                                                             --

-----------------------------------------------------------------

---------------------------------------------------------------

-- Basic data types

---------------------------------------------------------------

library IEEE;

use IEEE.std_logic_1164.all;

use IEEE.numeric_std.all;

library WORK;

use WORK.G729A_ASIP_PKG.all;

package G729A_ASIP_BASIC_PKG is

  constant MIN_16 : SDWORD_T := (SDLEN-1 => '1', others => '0');

  constant MAX_16 : SDWORD_T := (SDLEN-1 => '0', others => '1');

  constant MIN_32 : LDWORD_T := (LDLEN-1 => '1', others => '0');

  constant MAX_32 : LDWORD_T := (LDLEN-1 => '0', others => '1');

  subtype SHORT_SHIFT_T is integer range -SDLEN to SDLEN-1;

  subtype LONG_SHIFT_T is integer range -LDLEN to LDLEN-1;

  -- These additional types have been defined to handle overflow

  -- conditions: valid range top/bottom values are used to flag

  -- overflow.

  subtype SHORT_SHIFT_OVF_T is integer range -SDLEN to SDLEN;

  subtype LONG_SHIFT_OVF_T is integer range -LDLEN to LDLEN;

  ------------------------------------

  -- Convert hex digit string to signed value 

  ------------------------------------

  function hex_to_signed(XSTR : string;LEN : integer) return signed;

  ------------------------------------

  -- Convert LDWORD_T-type value to SDWORD_T-type

  ------------------------------------

  procedure sature(

    LVAL : in LDWORD_T;

    SVAL : out SDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Get absolute value of SDWORD_T-type value

  ------------------------------------

  function abs_s(SVAL : SDWORD_T) return SDWORD_T;

  ------------------------------------

  -- Shift Left (WORD-type value)

  ------------------------------------

  procedure shl(

    SVALI : in SDWORD_T;

    SHFT : in  SHORT_SHIFT_T;

    SVALO : out SDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Shift Right (WORD-type value)

  ------------------------------------

  procedure shr(

    SVALI : in SDWORD_T;

    SHFT : in  SHORT_SHIFT_T;

    SVALO : out SDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Multiply (WORD-type result)

  ------------------------------------

  procedure mult(

    PROD : in LDWORD_T;

    RES : out SDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Long Multiply (DWORD-type result)

  ------------------------------------

  procedure L_mult(

    PROD : in LDWORD_T;

    RES : out LDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Get 2's complement of SDWORD_T-type value

  ------------------------------------

  function negate(SVAL : SDWORD_T) return SDWORD_T;

  ------------------------------------

  -- Long Addition/Subtraction 

  -- (DWORD-type result)

  ------------------------------------

  procedure L_add_sub(

    SUM : in LDWORD_T;

    AS : in std_logic;

    SA : in std_logic;

    SB : in std_logic;

    RES : out LDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Get 2's complement of LDWORD_T-type value

  ------------------------------------

  function L_negate(LVAL : LDWORD_T) return LDWORD_T;

  ------------------------------------

  --  Long Shift Left (DWORD-type result)

  ------------------------------------

  procedure L_shl(

    LVALI : in LDWORD_T;

    SHFT : in  LONG_SHIFT_T;

    LVALO : out LDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  --  Long Shift Right (DWORD-type result)

  ------------------------------------

  procedure L_shr(

    LVALI : in LDWORD_T;

    SHFT : in  LONG_SHIFT_T;

    LVALO : out LDWORD_T;

    OVF : out std_logic

  );

  ------------------------------------

  -- Get absolute value of LDWORD_T-type value

  ------------------------------------

  function L_abs(LVAL : LDWORD_T) return LDWORD_T;

  ------------------------------------

  -- Get normalization shift amount

  -- (for a SDWORD_T-type value)

  ------------------------------------

  function norm_s(SVAL : SDWORD_T) return  SHORT_SHIFT_T;

  ------------------------------------

  -- Divide (WORD-type operands and result)

  ------------------------------------

  --function div_s(DD,DR : SDWORD_T) return SDWORD_T;

  ------------------------------------

  -- Get normalization shift amount

  -- (for a LDWORD_T-type value)

  ------------------------------------

  function norm_l(LVAL : LDWORD_T) return  LONG_SHIFT_T;

  ------------------------------------

  --function pos_overflow(VAL : LDWORD_T) return std_logic;

  --function neg_overflow(VAL : LDWORD_T) return std_logic;

end G729A_ASIP_BASIC_PKG;

package body G729A_ASIP_BASIC_PKG is

  ------------------------------------

  function hex_to_signed(XSTR : string;LEN : integer) return signed is

    variable VAL : signed(XSTR'length*4-1 downto 0);

    variable DGT : std_logic_vector(3 downto 0);

  begin

    for i in 1 to XSTR'length loop

      case XSTR(i) is

        when '0' => DGT := "0000";

        when '1' => DGT := "0001";

        when '2' => DGT := "0010";

        when '3' => DGT := "0011";

        when '4' => DGT := "0100";

        when '5' => DGT := "0101";

        when '6' => DGT := "0110";

        when '7' => DGT := "0111";

        when '8' => DGT := "1000";

        when '9' => DGT := "1001";

        when 'a' => DGT := "1010";

        when 'b' => DGT := "1011";

        when 'c' => DGT := "1100";

        when 'd' => DGT := "1101";

        when 'e' => DGT := "1110";

        when others => DGT := "1111";

      end case;

      for j in 3 downto 0 loop

        VAL((XSTR'length-i)*4+j) := DGT(j);

      end loop;

    end loop;

    return(VAL(LEN-1 downto 0));

  end function;

  ------------------------------------

  procedure sature(

    LVAL : in LDWORD_T;

    SVAL : out SDWORD_T;

    OVF : out std_logic

  ) is

    constant ALL_ZERO : LDWORD_T := to_signed(0,LDLEN);

    constant ALL_ONE : LDWORD_T := not(ALL_ZERO);

    variable TMP : LDWORD_T;

  begin

    TMP := shift_right(LVAL,SDLEN-1);

    if((LVAL > 0) and not(TMP = ALL_ZERO)) then

      -- positive overflow

      SVAL := MAX_16;

      OVF := '1';

    elsif((LVAL < 0) and  not(TMP = ALL_ONE)) then

      -- negative overflow

      SVAL := MIN_16;

      OVF := '1';

    else

      -- exact result

      SVAL := LVAL(SDLEN-1 downto 0);

      OVF := '0';

    end if;

  end sature;

  ------------------------------------

  function abs_s(SVAL : SDWORD_T) return SDWORD_T is

  begin

    if(SVAL = MIN_16) then

      return(MAX_16);

    elsif(SVAL < 0) then

      return(-SVAL);

    else

      return(SVAL);

    end if;

  end function;

  ------------------------------------

  procedure shl(

    SVALI : in SDWORD_T;

    SHFT : in  SHORT_SHIFT_T;

    SVALO : out SDWORD_T;

    OVF : out std_logic

  ) is

    constant ALL_ZERO : SDWORD_T := to_signed(0,SDLEN);

    variable TMP : SDWORD_T;

  begin

    if(SVALI = ALL_ZERO) then

      SVALO := SVALI;

      OVF := '0';

    elsif(SHFT >= 0) then

      TMP := shift_left(SVALI,SHFT);

      if(TMP = ALL_ZERO)then

        if(SVALI < 0) then

          SVALO := MIN_16;

        else

          SVALO := MAX_16;

        end if;

        OVF := '1';

      else

        SVALO := TMP;

        OVF := '0';

      end if;

    else

      SVALO := shift_right(SVALI,-SHFT);

      OVF := '0';

    end if;

  end shl;

  ------------------------------------

  procedure shr(

    SVALI : in SDWORD_T;

    SHFT : in  SHORT_SHIFT_T;

    SVALO : out SDWORD_T;

    OVF : out std_logic

  ) is

    constant ALL_ZERO : SDWORD_T := to_signed(0,SDLEN);

    variable TMP : SDWORD_T;

  begin

    if(SVALI = ALL_ZERO) then

      SVALO := SVALI;

      OVF := '0';

    elsif(SHFT <= 0) then

      TMP := shift_left(SVALI,-SHFT);

      if(TMP = ALL_ZERO)then

        if(SVALI < 0) then

          SVALO := MIN_16;

        else

          SVALO := MAX_16;

        end if;

        OVF := '1';

      else

        SVALO := TMP;

        OVF := '0';

      end if;

    else

      SVALO := shift_right(SVALI,SHFT);

      OVF := '0';

    end if;

  end shr;

  ------------------------------------

  -- This procedure takes WLEN x WLEN multiplication

  -- result, right-shift it by WLEN-1 bits and

  -- convert it to WLEN-bits with saturation.

  -- Actual multiplication must be performed before

  -- invoking this procedure.

  procedure mult(

    PROD : in LDWORD_T;

    RES : out SDWORD_T;

    OVF : out std_logic

  ) is

    variable TMP : LDWORD_T;

  begin

    TMP := shift_right(PROD,SDLEN-1);

    sature(TMP,RES,OVF);

  end mult;

  ------------------------------------

  -- This procedure takes WLEN x WLEN multiplication

  -- result and left-shift it by 1, checking for 

  -- overflow

  procedure L_mult(

    PROD : in LDWORD_T;

    RES : out LDWORD_T;

    OVF : out std_logic

  ) is

    constant OVFVAL : LDWORD_T := hex_to_signed("40000000",LDLEN);

  begin

    if(PROD = OVFVAL) then

      RES := MAX_32;

      OVF := '1';

    else

      RES := shift_left(PROD,1);

      OVF := '0';

    end if;

  end L_mult;

  ------------------------------------

  -- This procedure generates -SVAL value.

  -- If SVAL = MIN_16 (minimum signed integer)

  -- negate result can't be exact, and is

  -- approximated to MAX_16.

  function negate(SVAL : SDWORD_T) return SDWORD_T is

  begin

    if(SVAL = MIN_16) then

      return(MAX_16);

    else

      return(-SVAL);

    end if;

  end function;

  ------------------------------------

  -- This procedure takes LDLEN-bit

  -- addition/subtraction result and

  -- operand signs, and checks for overflow.

  procedure L_add_sub(

    SUM : in LDWORD_T;

    AS : in std_logic;

    SA : in std_logic;

    SB : in std_logic;

    RES : out LDWORD_T;

    OVF : out std_logic

  ) is

    variable ST : std_logic;

    variable IOVF : std_logic;

  begin

    ST := SUM(LDLEN-1);

    -- overflow flag

    if(AS = '1') then

      -- addition

      if(ST = '1') then

        IOVF := not(SA or SB);

      else

        IOVF := (SA and SB);

      end if;

    else

      -- subtraction

      if(ST = '1') then

        IOVF := (not(SA) and SB);

      else

        IOVF := (SA and not(SB));

      end if;

    end if;

    -- saturated result

    if(IOVF = '0') then

      RES := SUM;

    elsif(ST = '0') then

      RES := MIN_32;

    else

      RES := MAX_32;

    end if;

    OVF := IOVF;

  end L_add_sub;

  ------------------------------------

  -- This procedure generates -LVAL value.

  -- If LVAL = MIN_32 (minimum signed integer)

  -- negate result can't be exact, and is

  -- approximated to MAX_32.

  function L_negate(LVAL : LDWORD_T) return LDWORD_T is

  begin

    if(LVAL = MIN_32) then

      return(MAX_32);

    else

      return(-LVAL);

    end if;

  end function;

  ------------------------------------

  procedure L_shl(

    LVALI : in LDWORD_T;

    SHFT : in  LONG_SHIFT_T;

    LVALO : out LDWORD_T;

    OVF : out std_logic

  ) is

    constant ALL_ZERO : LDWORD_T := to_signed(0,LDLEN);

    variable TMP : LDWORD_T;

  begin

    if(LVALI = ALL_ZERO) then

      LVALO := LVALI;

      OVF := '0';

    elsif(SHFT >= 0) then

      TMP := shift_left(LVALI,SHFT);

      if(TMP = ALL_ZERO)then

        if(LVALI < 0) then

          LVALO := MIN_32;

        else

          LVALO := MAX_32;

        end if;

        OVF := '1';

      else

        LVALO := TMP;

        OVF := '0';

      end if;

    else

      LVALO := shift_right(LVALI,-SHFT);

      OVF := '0';

    end if;

  end L_shl;

  ------------------------------------

  procedure L_shr(

    LVALI : in LDWORD_T;

    SHFT : in  LONG_SHIFT_T;

    LVALO : out LDWORD_T;

    OVF : out std_logic

  ) is

    constant ALL_ZERO : LDWORD_T := to_signed(0,LDLEN);

    variable TMP : LDWORD_T;

  begin

    if(LVALI = ALL_ZERO) then

      LVALO := LVALI;

      OVF := '0';

    elsif(SHFT <= 0) then

      TMP := shift_left(LVALI,-SHFT);

      if(TMP = ALL_ZERO)then

        if(LVALI < 0) then

          LVALO := MIN_32;

        else

          LVALO := MAX_32;

        end if;

        OVF := '1';

      else

        LVALO := TMP;

        OVF := '0';

      end if;

    else

      LVALO := shift_right(LVALI,SHFT);

      OVF := '0';

    end if;

  end L_shr;

  ------------------------------------

  function L_abs(LVAL : LDWORD_T) return LDWORD_T is

  begin

    if(LVAL = MIN_32) then

      return(MAX_32);

    elsif(LVAL < 0) then

      return(-LVAL);

    else

      return(LVAL);

    end if;

  end function;

  ------------------------------------

  function norm_s(SVAL : SDWORD_T) return  SHORT_SHIFT_T is

    constant ALL_ZERO : SDWORD_T := to_signed(0,SDLEN);

    constant ALL_ONE : SDWORD_T := not(ALL_ZERO);

    variable TMP : SDWORD_T;

    variable NRM :  SHORT_SHIFT_T;

  begin

    if(SVAL = ALL_ZERO) then

      return(0);

    elsif(SVAL = ALL_ONE) then

      return(SDLEN-1);

    else

      if(SVAL < 0) then

        TMP := not(SVAL);

      else

        TMP := SVAL;

      end if;

      if(TMP(SDLEN-2) = '1') then NRM := 0;

      elsif(TMP(SDLEN-3) = '1') then NRM := 1;

      elsif(TMP(SDLEN-4) = '1') then NRM := 2;

      elsif(TMP(SDLEN-5) = '1') then NRM := 3;

      elsif(TMP(SDLEN-6) = '1') then NRM := 4;

      elsif(TMP(SDLEN-7) = '1') then NRM := 5;

      elsif(TMP(SDLEN-8) = '1') then NRM := 6;

      elsif(TMP(SDLEN-9) = '1') then NRM := 7;

      elsif(TMP(SDLEN-10) = '1') then NRM := 8;

      elsif(TMP(SDLEN-11) = '1') then NRM := 9;

      elsif(TMP(SDLEN-12) = '1') then NRM := 10;

      elsif(TMP(SDLEN-13) = '1') then NRM := 11;

      elsif(TMP(SDLEN-14) = '1') then NRM := 12;

      elsif(TMP(SDLEN-15) = '1') then NRM := 13;

      else NRM := 14;

      end if;

--      case TMP is

--        when "0000000000000001" => NRM := 15; 

--        when "000000000000001-" => NRM := 14; 

--        when "00000000000001--" => NRM := 13; 

--        when "0000000000001---" => NRM := 12; 

--        when "000000000001----" => NRM := 11; 

--        when "00000000001-----" => NRM := 10; 

--        when "0000000001------" => NRM := 9; 

--        when "000000001-------" => NRM := 8; 

--        when "00000001--------" => NRM := 7; 

--        when "0000001---------" => NRM := 6; 

--        when "000001----------" => NRM := 5; 

--        when "00001-----------" => NRM := 4; 

--        when "0001------------" => NRM := 3; 

--        when "001-------------" => NRM := 2; 

--        when others => NRM := 1; 

--      end case;

      return(NRM);

    end if;

  end function;

  ------------------------------------

  function norm_l(LVAL : LDWORD_T) return  LONG_SHIFT_T is

    constant ALL_ZERO : LDWORD_T := to_signed(0,LDLEN);

    constant ALL_ONE : LDWORD_T := not(ALL_ZERO);

    variable TMP : LDWORD_T;

    variable NRM :  LONG_SHIFT_T;

  begin

    if(LVAL = ALL_ZERO) then

      return(0);

    elsif(LVAL = ALL_ONE) then

      return(LDLEN-1);

    else

      if(LVAL < 0) then

        TMP := not(LVAL);

      else

        TMP := LVAL;

      end if;

      NRM := 0;

      for i in 0 to LDLEN-2 loop

        if(TMP (i) = '1') then

          NRM := (LDLEN-2)-i;

        end if;

      end loop;

      if(TMP(LDLEN-2) = '1') then NRM := 0;

      elsif(TMP(LDLEN-3)  = '1') then NRM := 1;

      elsif(TMP(LDLEN-4)  = '1') then NRM := 2;

      elsif(TMP(LDLEN-5)  = '1') then NRM := 3;

      elsif(TMP(LDLEN-6)  = '1') then NRM := 4;

      elsif(TMP(LDLEN-7)  = '1') then NRM := 5;

      elsif(TMP(LDLEN-8)  = '1') then NRM := 6;

      elsif(TMP(LDLEN-9)  = '1') then NRM := 7;

      elsif(TMP(LDLEN-10) = '1') then NRM := 8;

      elsif(TMP(LDLEN-11) = '1') then NRM := 9;

      elsif(TMP(LDLEN-12) = '1') then NRM := 10;

      elsif(TMP(LDLEN-13) = '1') then NRM := 11;

      elsif(TMP(LDLEN-14) = '1') then NRM := 12;

      elsif(TMP(LDLEN-15) = '1') then NRM := 13;

      elsif(TMP(LDLEN-16) = '1') then NRM := 14;

      elsif(TMP(LDLEN-17) = '1') then NRM := 15;

      elsif(TMP(LDLEN-18) = '1') then NRM := 16;

      elsif(TMP(LDLEN-19) = '1') then NRM := 17;

      elsif(TMP(LDLEN-20) = '1') then NRM := 18;

      elsif(TMP(LDLEN-21) = '1') then NRM := 19;

      elsif(TMP(LDLEN-22) = '1') then NRM := 20;

      elsif(TMP(LDLEN-23) = '1') then NRM := 21;

      elsif(TMP(LDLEN-24) = '1') then NRM := 22;

      elsif(TMP(LDLEN-25) = '1') then NRM := 23;

      elsif(TMP(LDLEN-26) = '1') then NRM := 24;

      elsif(TMP(LDLEN-27) = '1') then NRM := 25;